Entrega contínua usando ações do GitHub

Artigo
10/31/2024

Você pode usar um fluxo de trabalho de Ações do GitHub para definir um fluxo de trabalho para criar e implantar código automaticamente em seu aplicativo de função no Azure Functions.

Um arquivo YAML (.yml) que define a configuração do fluxo de trabalho é mantido no /.github/workflows/ caminho do repositório. Esta definição contém as ações e parâmetros que compõem o fluxo de trabalho, que é específico para a linguagem de desenvolvimento de suas funções. Um fluxo de trabalho de Ações do GitHub para Funções executa as seguintes tarefas, independentemente do idioma:

Configure o ambiente.
Crie o projeto de código.
Implante o pacote em um aplicativo de função no Azure.

A ação Azure Functions lida com a implantação em um aplicativo de função existente no Azure.

Você pode criar um arquivo de configuração de fluxo de trabalho para sua implantação manualmente. Você também pode gerar o arquivo a partir de um conjunto de modelos específicos do idioma de uma destas maneiras:

No portal do Azure
Com a CLI do Azure
A partir do seu repositório GitHub

Se você não quiser criar seu arquivo YAML manualmente, selecione um método diferente na parte superior do artigo.

Pré-requisitos

Uma conta do Azure com uma subscrição ativa. Crie uma conta gratuitamente.
Uma conta GitHub. Se não tiver uma, inscreva-se gratuitamente.
Um aplicativo de função de trabalho hospedado no Azure com código-fonte em um repositório GitHub.

CLI do Azure, ao desenvolver localmente. Você também pode usar a CLI do Azure no Azure Cloud Shell.

Gerar credenciais de implantação

Como o GitHub Actions usa seu perfil de publicação para acessar seu aplicativo de função durante a implantação, primeiro você precisa obter seu perfil de publicação e armazená-lo com segurança como um segredo do GitHub.

Importante

O perfil de publicação é uma credencial valiosa que permite o acesso aos recursos do Azure. Certifique-se de que transporta e armazena sempre de forma segura. No GitHub, o perfil de publicação só deve ser armazenado em segredos do GitHub.

Faça o download do seu perfil de publicação

Para baixar o perfil de publicação do seu aplicativo de função:

No portal do Azure, localize a página do seu aplicativo de função, expanda Configuração de Configurações>na coluna da esquerda.
Na página Configuração, selecione a guia Configurações gerais e verifique se as Credenciais de publicação de autenticação básica do SCM estão ativadas. Quando essa configuração estiver Desabilitada, você não poderá usar perfis de publicação, portanto, selecione Ativado e Salvar.
Volte para a página Visão geral do aplicativo de função e selecione Obter perfil de publicação.
Salve e copie o conteúdo do arquivo.

Adicione o segredo do GitHub

No GitHub, vá para o seu repositório.
Aceda a Definições.
Selecione Segredos e variáveis > Ações.
Selecione Novo segredo do repositório.
Adicione um novo segredo com o nome AZURE_FUNCTIONAPP_PUBLISH_PROFILE e o valor definido para o conteúdo do arquivo de perfil de publicação.
Selecione Add secret (Adicionar segredo).

O GitHub agora pode se autenticar em seu aplicativo de função no Azure.

Criar o fluxo de trabalho a partir de um modelo

A melhor maneira de criar manualmente uma configuração de fluxo de trabalho é começar a partir do modelo oficialmente suportado.

Criar a configuração do fluxo de trabalho no portal

Quando você usa o portal para habilitar as Ações do GitHub, o Functions cria um arquivo de fluxo de trabalho com base na pilha de aplicativos e o confirma no repositório do GitHub no diretório correto.

O portal obtém automaticamente seu perfil de publicação e o adiciona aos segredos do GitHub para seu repositório.

Durante a criação do aplicativo de função

Você pode começar rapidamente com as Ações do GitHub por meio da guia Implantação ao criar uma função no portal do Azure. Para adicionar um fluxo de trabalho de Ações do GitHub ao criar um novo aplicativo de função:

No portal do Azure, selecione Implantação no fluxo Criar Aplicativo de Função.
Habilite a Implantação Contínua se quiser que cada atualização de código acione um envio por push de código para o portal do Azure.
Insira sua organização, repositório e ramificação do GitHub.
Conclua a configuração do seu aplicativo de função. Seu repositório GitHub agora inclui um novo arquivo de fluxo de trabalho no /.github/workflows/.

Para um aplicativo de função existente

Para adicionar um fluxo de trabalho de Ações do GitHub a um aplicativo de função existente:

Navegue até seu aplicativo de função no portal do Azure e selecione Centro de Implantação.
Em Source, selecione GitHub. Se você não vir a mensagem padrão Criando com ações do GitHub, selecione Alterar provedor, escolha Ações do GitHub e selecione OK.
Se você ainda não autorizou o acesso ao GitHub, selecione Autorizar. Forneça suas credenciais do GitHub e selecione Entrar. Para autorizar uma conta diferente do GitHub, selecione Alterar conta e entre com outra conta.
Selecione sua organização, repositório e ramificação do GitHub. Para implantar com o GitHub Actions, você deve ter acesso de gravação a esse repositório.
Em Configurações de autenticação, escolha se deseja que as Ações do GitHub sejam autenticadas com uma identidade atribuída pelo usuário ou usando credenciais de autenticação básicas. Para autenticação básica, as credenciais atuais são usadas.
Selecione Visualizar arquivo para ver o arquivo de fluxo de trabalho que é adicionado ao repositório do GitHub em github/workflows/.
Selecione Salvar para adicionar o arquivo de fluxo de trabalho ao repositório.

Adicionar configuração de fluxo de trabalho ao repositório

Você pode usar o az functionapp deployment github-actions add comando para gerar um arquivo de configuração de fluxo de trabalho a partir do modelo correto para seu aplicativo de função. O novo arquivo YAML é então armazenado no local correto (/.github/workflows/) no repositório do GitHub fornecido, enquanto o arquivo de perfil de publicação do seu aplicativo é adicionado aos segredos do GitHub no mesmo repositório.

Execute este az functionapp comando, substituindo os valores githubUser/githubRepo, MyResourceGroupe MyFunctionapp:
```
az functionapp deployment github-actions add --repo "githubUser/githubRepo" -g MyResourceGroup -n MyFunctionapp --login-with-github
```
Este comando usa um método interativo para recuperar um token de acesso pessoal para sua conta do GitHub.

Na janela do terminal, você verá algo como a seguinte mensagem:

Please navigate to https://github.com/login/device and enter the user code XXXX-XXXX to activate and retrieve your GitHub personal access token.

Copie o código exclusivo XXXX-XXXX , navegue até https://github.com/login/devicee insira o código copiado. Depois de inserir seu código, você verá algo como a seguinte mensagem:

Verified GitHub repo and branch
Getting workflow template using runtime: java
Filling workflow template with name: func-app-123, branch: main, version: 8, slot: production, build_path: .
Adding publish profile to GitHub
Fetching publish profile with secrets for the app 'func-app-123'
Creating new workflow file: .github/workflows/master_func-app-123.yml

Vá para o repositório GitHub e selecione Ações. Verifique se o fluxo de trabalho foi executado.

Criar o arquivo de configuração do fluxo de trabalho

Você pode criar o arquivo de configuração de fluxo de trabalho do GitHub Actions a partir dos modelos do Azure Functions diretamente do repositório do GitHub.

No GitHub, vá para o seu repositório.
Selecione Ações e Novo fluxo de trabalho.
Pesquise funções.
Nos fluxos de trabalho do aplicativo de funções exibidas criados pelo Microsoft Azure, localize aquele que corresponde ao seu idioma de código e selecione Configurar.
No arquivo YAML recém-criado, atualize o env.AZURE_FUNCTIONAPP_NAME parâmetro com o nome do recurso do aplicativo de função no Azure. Opcionalmente, talvez seja necessário atualizar o parâmetro que define a versão de idioma usada pelo seu aplicativo, como DOTNET_VERSION para C#.
Verifique se o novo arquivo de fluxo de trabalho está sendo salvo e /.github/workflows/ selecione Confirmar alterações....

Atualizar uma configuração de fluxo de trabalho

Se, por algum motivo, você precisar atualizar ou alterar uma configuração de fluxo de trabalho existente, basta navegar até o /.github/workflows/ local em seu repositório, abrir o arquivo YAML específico, fazer as alterações necessárias e, em seguida, confirmar as atualizações no repositório.

Exemplo: arquivo de configuração do fluxo de trabalho

O exemplo de modelo a seguir usa a versão 1 do e a functions-action publish profile para autenticação. O modelo depende do idioma escolhido e do sistema operacional no qual seu aplicativo de função é implantado:

Windows
Linux

Se o seu aplicativo funcional for executado no Linux, selecione Linux.

name: Deploy DotNet project to Azure Function App

on:
  [push]

env:
  AZURE_FUNCTIONAPP_NAME: 'your-app-name'   # set this to your function app name on Azure
  AZURE_FUNCTIONAPP_PACKAGE_PATH: '.'       # set this to the path to your function app project, defaults to the repository root
  DOTNET_VERSION: '6.0.x'                   # set this to the dotnet version to use (e.g. '2.1.x', '3.1.x', '5.0.x')

jobs:
  build-and-deploy:
    runs-on: windows-latest
    environment: dev
    steps:
    - name: 'Checkout GitHub Action'
      uses: actions/checkout@v3

    - name: Setup DotNet ${{ env.DOTNET_VERSION }} Environment
      uses: actions/setup-dotnet@v3
      with:
        dotnet-version: ${{ env.DOTNET_VERSION }}

    - name: 'Resolve Project Dependencies Using Dotnet'
      shell: pwsh
      run: |
        pushd './${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}'
        dotnet build --configuration Release --output ./output
        popd

    - name: 'Run Azure Functions Action'
      uses: Azure/functions-action@v1
      id: fa
      with:
        app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
        package: '${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}/output'
        publish-profile: ${{ secrets.AZURE_FUNCTIONAPP_PUBLISH_PROFILE }}

name: Deploy DotNet project to Azure Function App

on:
  [push]

env:
  AZURE_FUNCTIONAPP_NAME: 'your-app-name'   # set this to your function app name on Azure
  AZURE_FUNCTIONAPP_PACKAGE_PATH: '.'       # set this to the path to your function app project, defaults to the repository root
  DOTNET_VERSION: '6.0.x'                   # set this to the dotnet version to use (e.g. '2.1.x', '3.1.x', '5.0.x')

jobs:
  build-and-deploy:
    runs-on: ubuntu-latest
    environment: dev
    steps:
    - name: 'Checkout GitHub Action'
      uses: actions/checkout@v3

    - name: Setup DotNet ${{ env.DOTNET_VERSION }} Environment
      uses: actions/setup-dotnet@v3
      with:
        dotnet-version: ${{ env.DOTNET_VERSION }}

    - name: 'Resolve Project Dependencies Using Dotnet'
      shell: bash
      run: |
        pushd './${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}'
        dotnet build --configuration Release --output ./output
        popd

    - name: 'Run Azure Functions Action'
      uses: Azure/functions-action@v1
      id: fa
      with:
        app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
        package: '${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}/output'
        publish-profile: ${{ secrets.AZURE_FUNCTIONAPP_PUBLISH_PROFILE }}

name: Deploy Java project to Azure Function App

on:
  [push]

env:
  AZURE_FUNCTIONAPP_NAME: 'your-app-name'   # set this to your function app name on Azure
  POM_XML_DIRECTORY: '.'                    # set this to the directory which contains pom.xml file
  JAVA_VERSION: '8'                         # set this to the java version to use (e.g. '8', '11', '17')

jobs:
  build-and-deploy:
    runs-on: windows-latest
    environment: dev
    steps:
    - name: 'Checkout GitHub Action'
      uses: actions/checkout@v3

    - name: Setup Java Sdk ${{ env.JAVA_VERSION }}
      uses: actions/setup-java@v1
      with:
        java-version: ${{ env.JAVA_VERSION }}

    - name: 'Restore Project Dependencies Using Mvn'
      shell: pwsh
      run: |
        pushd './${{ env.POM_XML_DIRECTORY }}'
        mvn clean package
        popd

    - name: 'Run Azure Functions Action'
      uses: Azure/functions-action@v1
      id: fa
      with:
        app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
        package: '${{ env.POM_XML_DIRECTORY }}' # if there are multiple function apps in same project, then this path will be like './${{ env.POM_XML_DIRECTORY }}/target/azure-functions/${{ env.POM_FUNCTIONAPP_NAME }'
        publish-profile: ${{ secrets.AZURE_FUNCTIONAPP_PUBLISH_PROFILE }}
        respect-pom-xml: true

name: Deploy Java project to Azure Function App

on:
  [push]

env:
  AZURE_FUNCTIONAPP_NAME: 'your-app-name'   # set this to your function app name on Azure
  POM_XML_DIRECTORY: '.'                    # set this to the directory which contains pom.xml file
  JAVA_VERSION: '8'                         # set this to the java version to use (e.g. '8', '11', '17')

jobs:
  build-and-deploy:
    runs-on: ubuntu-latest
    environment: dev
    steps:
    - name: 'Checkout GitHub Action'
      uses: actions/checkout@v3

    - name: Setup Java Sdk ${{ env.JAVA_VERSION }}
      uses: actions/setup-java@v1
      with:
        java-version: ${{ env.JAVA_VERSION }}

    - name: 'Restore Project Dependencies Using Mvn'
      shell: bash
      run: |
        pushd './${{ env.POM_XML_DIRECTORY }}'
        mvn clean package
        popd

    - name: 'Run Azure Functions Action'
      uses: Azure/functions-action@v1
      id: fa
      with:
        app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
        package: '${{ env.POM_XML_DIRECTORY }}' # if there are multiple function apps in same project, then this path will be like './${{ env.POM_XML_DIRECTORY }}/target/azure-functions/${{ env.POM_FUNCTIONAPP_NAME }'
        publish-profile: ${{ secrets.AZURE_FUNCTIONAPP_PUBLISH_PROFILE }}
        respect-pom-xml: true

name: Deploy Node.js project to Azure Function App

on:
  [push]

env:
  AZURE_FUNCTIONAPP_NAME: 'your-app-name'   # set this to your function app name on Azure
  AZURE_FUNCTIONAPP_PACKAGE_PATH: '.'       # set this to the path to your function app project, defaults to the repository root
  NODE_VERSION: '16.x'                      # set this to the node version to use (e.g. '8.x', '10.x', '12.x')

jobs:
  build-and-deploy:
    runs-on: windows-latest
    environment: dev
    steps:
    - name: 'Checkout GitHub Action'
      uses: actions/checkout@v3

    - name: Setup Node ${{ env.NODE_VERSION }} Environment
      uses: actions/setup-node@v3
      with:
        node-version: ${{ env.NODE_VERSION }}

    - name: 'Resolve Project Dependencies Using Npm'
      shell: pwsh
      run: |
        pushd './${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}'
        npm install
        npm run build --if-present
        npm run test --if-present
        popd

    - name: 'Run Azure Functions Action'
      uses: Azure/functions-action@v1
      id: fa
      with:
        app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
        package: ${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}
        publish-profile: ${{ secrets.AZURE_FUNCTIONAPP_PUBLISH_PROFILE }}

name: Deploy Node.js project to Azure Function App

on:
  [push]

env:
  AZURE_FUNCTIONAPP_NAME: 'your-app-name'   # set this to your function app name on Azure
  AZURE_FUNCTIONAPP_PACKAGE_PATH: '.'       # set this to the path to your function app project, defaults to the repository root
  NODE_VERSION: '16.x'                      # set this to the node version to use (e.g. '8.x', '10.x', '12.x')

jobs:
  build-and-deploy:
    runs-on: ubuntu-latest
    environment: dev
    steps:
    - name: 'Checkout GitHub Action'
      uses: actions/checkout@v3

    - name: Setup Node ${{ env.NODE_VERSION }} Environment
      uses: actions/setup-node@v3
      with:
        node-version: ${{ env.NODE_VERSION }}

    - name: 'Resolve Project Dependencies Using Npm'
      shell: bash
      run: |
        pushd './${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}'
        npm install
        npm run build --if-present
        npm run test --if-present
        popd

    - name: 'Run Azure Functions Action'
      uses: Azure/functions-action@v1
      id: fa
      with:
        app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
        package: ${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}
        publish-profile: ${{ secrets.AZURE_FUNCTIONAPP_PUBLISH_PROFILE }}

name: Deploy Python project to Azure Function App

on:
  [push]

env:
  AZURE_FUNCTIONAPP_NAME: 'your-app-name'   # set this to your function app name on Azure
  AZURE_FUNCTIONAPP_PACKAGE_PATH: '.'       # set this to the path to your function app project, defaults to the repository root
  PYTHON_VERSION: '3.9'                     # set this to the python version to use (e.g. '3.6', '3.7', '3.8')

jobs:
  build-and-deploy:
    runs-on: ubuntu-latest
    environment: dev
    steps:
    - name: 'Checkout GitHub Action'
      uses: actions/checkout@v3

    - name: Setup Python ${{ env.PYTHON_VERSION }} Environment
      uses: actions/setup-python@v4
      with:
        python-version: ${{ env.PYTHON_VERSION }}

    - name: 'Resolve Project Dependencies Using Pip'
      shell: bash
      run: |
        pushd './${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}'
        python -m pip install --upgrade pip
        pip install -r requirements.txt --target=".python_packages/lib/site-packages"
        popd

    - name: 'Run Azure Functions Action'
      uses: Azure/functions-action@v1
      id: fa
      with:
        app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
        package: ${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}
        publish-profile: ${{ secrets.AZURE_FUNCTIONAPP_PUBLISH_PROFILE }}
        scm-do-build-during-deployment: true
        enable-oryx-build: true

name: Deploy PowerShell project to Azure Function App

on:
  [push]

env:
  AZURE_FUNCTIONAPP_NAME: 'your-app-name'   # set this to your function app name on Azure
  AZURE_FUNCTIONAPP_PACKAGE_PATH: '.'       # set this to the path to your function app project, defaults to the repository root

jobs:
  build-and-deploy:
    runs-on: windows-latest
    environment: dev
    steps:
    - name: 'Checkout GitHub Action'
      uses: actions/checkout@v3

    - name: 'Run Azure Functions Action'
      uses: Azure/functions-action@v1
      id: fa
      with:
        app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
        package: ${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}
        publish-profile: ${{ secrets.AZURE_FUNCTIONAPP_PUBLISH_PROFILE }}

name: Deploy PowerShell project to Azure Function App

on:
  [push]

env:
  AZURE_FUNCTIONAPP_NAME: 'your-app-name'   # set this to your function app name on Azure
  AZURE_FUNCTIONAPP_PACKAGE_PATH: '.'       # set this to the path to your function app project, defaults to the repository root

jobs:
  build-and-deploy:
    runs-on: ubuntu-latest
    environment: dev
    steps:
    - name: 'Checkout GitHub Action'
      uses: actions/checkout@v3

    - name: 'Run Azure Functions Action'
      uses: Azure/functions-action@v1
      id: fa
      with:
        app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
        package: ${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}
        publish-profile: ${{ secrets.AZURE_FUNCTIONAPP_PUBLISH_PROFILE }}

Ação do Azure Functions

A ação Azure Functions (Azure/azure-functions) define como seu código é publicado em um aplicativo de função existente no Azure ou em um slot específico em seu aplicativo.

Parâmetros

Os seguintes parâmetros são necessários para todos os planos de aplicativo de função:

Parâmetro	Explicação
nome do aplicativo	O nome do seu aplicativo de função.
embalagem	Este é o local no seu projeto a ser publicado. Por padrão, esse valor é definido como `.`, o que significa que todos os arquivos e pastas no repositório GitHub serão implantados.

Os seguintes parâmetros são necessários para o plano Flex Consumption:

Parâmetro	Explicação
SKU	Defina isso como `flexconsumption` ao autenticar com publish-profile. Ao usar credenciais RBAC ou implantar em um plano de consumo não Flex, a Ação pode resolver o valor, portanto, o parâmetro não precisa ser incluído.
Construção remota	Defina isso para `true` habilitar uma ação de compilação do Kudu quando o pacote for implantado em um aplicativo Flex Consumption. A construção do Oryx é sempre realizada durante uma construção remota no Flex Consumption; Não defina scm-do-build-during-deployment ou enable-oryx-build. Por padrão, esse parâmetro é definido como `false`.

Os seguintes parâmetros são específicos para os planos Consumo, Elastic Premium e Serviço de Aplicativo (Dedicado):

Parâmetro Explicação

scm-do-build-during-deployment (Opcional) Permita que o site Kudu (por exemplo) execute operações de pré-implantação, como compilações remotas. https://<APP_NAME>.scm.azurewebsites.net/ Por padrão, isso é definido como false. Defina isso para true quando você quiser controlar comportamentos de implantação usando o Kudu em vez de resolver dependências em seu fluxo de trabalho do GitHub. Para obter mais informações, consulte a SCM_DO_BUILD_DURING_DEPLOYMENT configuração.

enable-oryx-build (Opcional) Permita que o site Kudu resolva as dependências do seu projeto com o Oryx. Por padrão, isso é definido como false. Se você quiser usar o Oryx para resolver suas dependências em vez do fluxo de trabalho do GitHub, defina scm-do-build-during-deployment e enable-oryx-build como true.

Parâmetro	Explicação
scm-do-build-during-deployment	(Opcional) Permita que o site Kudu (por exemplo) execute operações de pré-implantação, como compilações remotas. `https://<APP_NAME>.scm.azurewebsites.net/` Por padrão, isso é definido como `false`. Defina isso para `true` quando você quiser controlar comportamentos de implantação usando o Kudu em vez de resolver dependências em seu fluxo de trabalho do GitHub. Para obter mais informações, consulte a `SCM_DO_BUILD_DURING_DEPLOYMENT` configuração.
enable-oryx-build	(Opcional) Permita que o site Kudu resolva as dependências do seu projeto com o Oryx. Por padrão, isso é definido como `false`. Se você quiser usar o Oryx para resolver suas dependências em vez do fluxo de trabalho do GitHub, defina scm-do-build-during-deployment e enable-oryx-build como `true`.

Parâmetros opcionais para todos os planos de aplicativos funcionais:

Parâmetro	Explicação
nome do slot	Este é o nome do slot de implantação a ser implantado. Por padrão, esse valor está vazio, o que significa que a Ação do GitHub será implantada em seu local de produção. Quando essa configuração apontar para um slot que não seja de produção, verifique se o parâmetro publish-profile contém as credenciais para o slot em vez do local de produção. Atualmente não é suportado no Flex Consumption.
publicar-perfil	O nome do segredo do GitHub que contém seu perfil de publicação.
respeito-pom-xml	Usado apenas para funções Java. Se é necessário que o artefato de implantação do seu aplicativo seja derivado do arquivo pom.xml. Ao implementar aplicativos de função Java, você deve definir esse parâmetro como `true` e definido `package` como `.`. Por padrão, esse parâmetro é definido como `false`, o que significa que o parâmetro deve apontar para o `package` local do artefato do seu aplicativo, como `./target/azure-functions/`
respeito-funcignore	Se o GitHub Actions honra seu arquivo .funcignore para excluir arquivos e pastas definidos nele. Defina esse valor como `true` quando o repositório tiver um arquivo .funcignore e você quiser usá-lo para excluir caminhos e arquivos, como configurações do editor de texto, .vscode/, ou um ambiente virtual Python (.venv/). A predefinição é `false`.

Considerações

Tenha em mente as seguintes considerações ao usar a ação do Azure Functions:

Ao usar as Ações do GitHub, o código é implantado usando uma implantação em aplicativos no plano Flex Consumption e zip deploy em aplicativos nos planos Consumo, Elastic Premium e Dedicado (Serviço de Aplicativo ). A exceção é o Consumo do Linux, onde a URL do pacote externo é usada.
As credenciais exigidas pelo GitHub para conexão com o Azure para implantação são armazenadas como Segredos em seu repositório GitHub e acessadas na implantação como secrets.<SECRET_NAME>.
A maneira mais fácil para as Ações do GitHub se autenticarem com o Azure Functions para implantação é usando um perfil de publicação. Você também pode autenticar usando uma entidade de serviço. Para saber mais, consulte este repositório de ações do GitHub.
As ações para configurar o ambiente e executar uma compilação são geradas a partir dos modelos e são específicas do idioma.
Os modelos usam env elementos para definir configurações exclusivas para sua compilação e implantação.

Próximos passos

Saiba mais sobre a integração do Azure e do GitHub

Partilhar via