Entrega contínua através do GitHub Actions

Pode usar um fluxo de trabalho GitHub Actions para definir um fluxo de trabalho que construa e implemente automaticamente código na sua aplicação de funções em 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 GitHub Actions para Funções realiza as seguintes tarefas, independentemente da linguagem:

Configure o ambiente.
Compile o projeto de código.
Implemente o pacote numa aplicação de funções no Azure.

A ação Azure Functions gere a implementação numa aplicação de funções 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
Utilização da Azure CLI
Do teu 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 no Azure com uma subscrição ativa. Crie uma conta gratuitamente.
Uma conta no GitHub. Se não tiver uma, inscreva-se gratuitamente.
Uma aplicação funcional funcional alojada no Azure com código-fonte num repositório do GitHub.

Azure CLI, quando se desenvolve localmente. Também pode usar a Azure CLI no Azure Cloud Shell.

Gerar credenciais de implantação

Como GitHub Actions usa o seu perfil de publicação para aceder à sua aplicação de funções durante a implementação, primeiro precisa de obter o seu perfil de publicação e armazená-lo de forma segura como um segredo 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 nos segredos do GitHub.

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

Para baixar o perfil de publicação da sua aplicação de funções:

No portal Azure, localize a página da sua aplicação de funções, expanda Settings>Configuration na coluna da esquerda.
Na página de Configuração, selecione o separador Configurações Gerais e certifique-se de que as Credenciais de Publicação de Autenticação Básica SCM estão Ativadas. Quando esta definição está Desligada, não podes usar publicar perfis, por isso seleciona Ligado e depois Aplicar.
Volte para a página de Visão Geral do aplicativo de função e depois selecione Obter perfil de publicação.
Salve e copie o conteúdo do arquivo.

Adicionar o segredo do GitHub

Em GitHub, vai ao teu repositório.
Vá para Configuraçõ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 Adicionar segredo.

O GitHub pode agora autenticar-se na sua aplicação de funções 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 usa o portal para ativar o GitHub Actions, o Functions cria um ficheiro de fluxo de trabalho baseado na sua pilha de aplicações e compromete-o no repositório GitHub no diretório correto.

O portal recebe automaticamente o teu perfil de publicação e adiciona-o aos segredos do GitHub para o teu repositório.

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

Podes começar rapidamente com o GitHub Actions através do separador Deployment quando crias uma função no portal do Azure. Para adicionar um fluxo de trabalho GitHub Actions quando crias uma nova aplicação funcional:

No portal Azure, selecione Implementação no fluxo de Criar Aplicação de Função.
Ativa Continuous Deployment se quiseres que cada atualização de código desencadeie um push de código para Azure portal.
Introduza a sua organização, repositório e branch do GitHub.
Conclua a configuração do seu aplicativo de função. O seu repositório de GitHub inclui agora um novo ficheiro de workflow em /.github/workflows/.

Para um aplicativo de função existente

Para adicionar um fluxo de trabalho GitHub Actions a uma aplicação de funções existente:

Navegue até à sua aplicação de funções no portal Azure e selecione Centro de Implementação.
Para Source selecione GitHub. Se não vir a mensagem padrão Construção com GitHub Actions, selecione Alterar fornecedor, escolha GitHub Actions e selecione OK.
Se ainda não autorizou GitHub acesso, selecione Authorize. Forneça as suas credenciais de GitHub e selecione Iniciar sessão. Para autorizar uma conta GitHub diferente, selecione Alterar Conta e inicie sessão com outra conta.
Selecione o seu GitHub Organization, Repository e Branch. Para implementar usando o GitHub Actions, deve ter acesso de escrita a este repositório.
Nas definições de autenticação Autenticação, escolha se querem autenticar GitHub Actions com credenciais Identidade atribuída pelo utilizador ou usando Autenticação básica credenciais. Para autenticação básica, as credenciais atuais são usadas.
Seleciona Preview file para ver o ficheiro de workflow que é adicionado ao teu repositório de 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 ficheiro YAML é então armazenado na localização correta (/.github/workflows/) no repositório do GitHub que você fornece, enquanto o ficheiro de perfil de publicação da sua aplicação é 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 utiliza um método interativo para recuperar um token de acesso pessoal para a sua conta no 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

Vai ao teu repositório de GitHub e seleciona Ações. Verifique se o fluxo de trabalho foi executado.

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

Podes criar o ficheiro de configuração do fluxo de trabalho GitHub Actions a partir dos templates do Azure Functions diretamente a partir do teu repositório GitHub.

Em GitHub, vai ao teu repositório.
Selecione Ações e Novo fluxo de trabalho.
Pesquise funções.
Nos fluxos de trabalho da aplicação de funções apresentados criados por Microsoft Azure, encontre aquele que corresponde à sua linguagem de código e selecione Configure.
No ficheiro YAML recém-criado, atualize o parâmetro env.AZURE_FUNCTIONAPP_NAME com o nome do recurso da sua aplicação de função em 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á a ser guardado em /.github/workflows/ e selecione Executar alterações....

Atualizar uma configuração de fluxo de trabalho

Se por algum motivo precisares de atualizar ou alterar uma configuração de workflow existente, basta navegar até à /.github/workflows/ localização no teu repositório, abrir o ficheiro YAML específico, fazer as alterações necessárias e depois comprometer 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 functions-action e um 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 }}

Azure Functions ação

A ação Azure Functions (Azure/functions-action) define como o seu código é publicado para uma aplicação de funções existente em Azure, ou para um slot específico na sua aplicação.

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 defeito, este valor é definido para `.`, o que significa que todos os ficheiros e pastas do repositório GitHub serão implementados.

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 implementar para um plano de consumo não Flex, a Ação pode resolver o valor, pelo que o parâmetro não precisa de ser incluído.
Construção remota	Defina isto para `true` para habilitar uma ação de construção do Kudu quando o pacote é implementado numa aplicação Flex Consumption. O build do Oryx é sempre realizado durante um build remoto no Flex Consumption; não definas 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) Permitir que o site Kudu (por exemplo, https://<APP_NAME>.scm.azurewebsites.net/) realize operações pré-implantação, como compilações remotas. Por padrão, isso é definido como false. Defina isto para true quando quiser controlar comportamentos de implementação usando Kudu em vez de resolver dependências no seu fluxo de trabalho 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 quiseres usar Oryx para resolver as dependências em vez do fluxo de trabalho GitHub, define tanto scm-do-build-during-deployment como enable-oryx-build para true.

Parâmetro	Explicação
scm-do-build-during-deployment	(Opcional) Permitir que o site Kudu (por exemplo, `https://<APP_NAME>.scm.azurewebsites.net/`) realize operações pré-implantação, como compilações remotas. Por padrão, isso é definido como `false`. Defina isto para `true` quando quiser controlar comportamentos de implementação usando Kudu em vez de resolver dependências no seu fluxo de trabalho 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 quiseres usar Oryx para resolver as dependências em vez do fluxo de trabalho GitHub, define tanto scm-do-build-during-deployment como enable-oryx-build para `true`.

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

Parâmetro	Explicação
nome do slot	Este é o nome do slot de implementação a ser usado para implementação. Por defeito, este valor está vazio, o que significa que a Ação do GitHub será implementada no seu site de produção. Quando esta configuração aponta para um slot não de produção, certifique-se de que o parâmetro de perfil de publicação contém as credenciais do 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 o teu perfil de publicação.
respect-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 aplicações de funções Java, deve definir este parâmetro para `true` e definir `package` para `.`. Por predefinição, este parâmetro é definido como `false`, o que significa que o parâmetro `package` deve apontar para a localização do artefato da sua aplicação, como `./target/azure-functions/`.
respect-funcignore	Se o GitHub Actions honra o seu ficheiro .funcignore para a exclusão de ficheiros e pastas nele definidos. Defina este valor para `true` quando o seu repositório tiver um ficheiro .funcignore e quiser usá-lo para excluir caminhos e ficheiros, como configurações de editores de texto, .vscode/, ou um ambiente virtual Python (.venv/). A predefinição é `false`.

Considerações

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

Ao usar o GitHub Actions, a forma como o seu código é implementado depende do seu plano de alojamento, como mostrado nesta tabela:

Plano de alojamento	Método de implantação
Consumo Flexível	Uma implantação
Elástico Premium	Zip deploy para aplicações no Consumo
Dedicado (Serviço de Aplicativo)	Zip deploy para aplicações no Consumo
Consumo	Windows: Zip deploy Linux: URL do pacote externo^*

* A capacidade de executar seus aplicativos no Linux em um plano de consumo está planejada para a aposentadoria. Para mais informações, consulte o Plano de Consumo para Alojamento do Azure Functions.

As credenciais exigidas por GitHub para se ligar a Azure para implementação são armazenadas como Segredos no seu repositório de GitHub e acedidas na implementação como secrets.<SECRET_NAME>.
A forma mais fácil do GitHub Actions autenticar-se com o Azure Functions para implementação é através de um perfil de publicação. Você também pode autenticar usando uma entidade de serviço. Para saber mais, consulte este repositório de GitHub Actions.
As ações para configurar o ambiente e executar uma build são geradas a partir dos templates e são específicas da linguagem.
Os modelos usam elementos env para definir configurações exclusivas para a sua compilação e implantação.

Próximos passos

Saiba mais sobre integração Azure e GitHub

Comentários

Esta página foi útil?

Last updated on 2026-03-11