Implante no Azure Functions usando o GitHub Actions

Quando você usa o portal do Azure para habilitar o GitHub Actions, o Functions executa automaticamente essas tarefas, tanto na sua assinatura do Azure quanto no seu repositório do GitHub.

• CLI do Azure, ao desenvolver localmente. Você também pode usar o CLI do Azure em Azure Cloud Shell.

Crie uma identidade gerenciada para a implantação no GitHub Actions

OpenID Connect (OIDC) é o método de autenticação recomendado para implantações do GitHub Actions no Azure Functions. Com o OIDC, você configura uma identidade gerenciada atribuída pelo usuário no Azure e cria uma relação de confiança com seu repositório GitHub. O fluxo de trabalho pode então autenticar com o Azure sem armazenar credenciais como segredos.

1. Use o comando az identity create para criar uma identidade gerenciada atribuída pelo usuário:

   az identity create --name myGitHubDeployIdentity --resource-group <RESOURCE_GROUP> \
   --query "{clientId: clientId, tenantId: tenantId}" -o table
   

   Substitua <RESOURCE_GROUP> pelo nome do grupo de recursos.

2. A partir da saída, note os clientId valores de e tenantId . Também obtenha seu ID de assinatura:

   az account show --query "{subId: id}" -o table
   

   Você precisa desses três valores depois, quando adicionar credenciais ao GitHub.

3. Use o comando create de atribuição de papel do az para atribuir a Website Contributor função à identidade gerenciada, com escopo para o seu app de função:

   IDENTITY_PRINCIPAL=$(az identity show --name myGitHubDeployIdentity --resource-group <RESOURCE_GROUP> --query 'principalId' -o tsv)
   FUNCTION_APP_ID=$(az functionapp show --name <APP_NAME> --resource-group <RESOURCE_GROUP> --query 'id' -o tsv)
   az role assignment create --assignee $IDENTITY_PRINCIPAL --role "Website Contributor" --scope $FUNCTION_APP_ID
   

   Substitua <APP_NAME> e <RESOURCE_GROUP> pelos nomes do seu app e do grupo de recursos, respectivamente.

4. Use o comando create de credenciais federadas da identidade az para criar uma credencial federada que confie nos tokens do seu repositório do GitHub:

   az identity federated-credential create \
       --identity-name myGitHubDeployIdentity \
       --resource-group <RESOURCE_GROUP> \
       --name github-deploy-credential \
       --issuer https://token.actions.githubusercontent.com \
       --subject repo:<GITHUB_ORG>/<REPO_NAME>:ref:refs/heads/<BRANCH_NAME> \
       --audiences api://AzureADTokenExchange
   

   Substitua <RESOURCE_GROUP>, <GITHUB_ORG>, <REPO_NAME>e <BRANCH_NAME> com seus valores. O sujeito deve corresponder ao ramo que aciona seu fluxo de trabalho.

5. (Opcional) Se você está implantando um container do Registro de Contêiner do Azure, também atribua a acrpull função à identidade gerenciada:

   IDENTITY_PRINCIPAL=$(az identity show --name myGitHubDeployIdentity --resource-group <RESOURCE_GROUP> --query 'principalId' -o tsv)
   az role assignment create --assignee $IDENTITY_PRINCIPAL --role acrpull \
       --scope /subscriptions/<SUBSCRIPTION_ID>/resourceGroups/<RESOURCE_GROUP>/providers/Microsoft.ContainerRegistry/registries/<REGISTRY_NAME>
   

   Substitua <SUBSCRIPTION_ID>, <RESOURCE_GROUP> e <REGISTRY_NAME> por seus valores.

Adicionar credenciais ao GitHub

Use os valores que você copiou ao criar a identidade gerenciada.

1. Em GitHub, vá para o repositório.

2. Vá para Configurações>Segredos e variáveis>Ações.

3. Na aba Segredos , selecione Novo segredo do repositório.

4. Crie cada um dos seguintes segredos:

   Name	Valor
   AZURE_CLIENT_ID	A clientId da identidade gerenciada
   AZURE_TENANT_ID	A tenantId da identidade gerenciada
   AZURE_SUBSCRIPTION_ID	O ID de assinatura que contém seu aplicativo de função

Para implantações de contêineres a partir de um registro privado, você também precisa de segredos específicos do registro. Para mais informações, veja Ação de Login no Docker.

Criar um fluxo de trabalho com base em um modelo

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

1. Escolha Windows ou Linux para garantir que você obtenha o modelo para o sistema operacional correto.

   • Windows
   • Linux

   As implantações no Windows usam runs-on: windows-latest. Implantações em contêineres exigem Linux.

2. Use o modelo de workflow OIDC específico para linguagem do repositório de ações do Azure Functions. Copie o conteúdo completo do arquivo para um novo arquivo nomeado .github/workflows/deploy-function-app.yml no seu repositório:

   • .NET
   • Java
   • JavaScript
   • Python
   • PowerShell
   • Contêiner

   name: Build and deploy .NET project to Azure Function App using OIDC
   
   on:
     push:
       branches: [ main ]
     workflow_dispatch:
   
   env:
     AZURE_FUNCTIONAPP_NAME: 'APP_NAME'         # Set this to your function app name on Azure 
     AZURE_FUNCTIONAPP_PROJECT_PATH: '.'        # Set this to the path to your function app project, defaults to the repository root. The deploy action will package the contents of this path.
     DOTNET_VERSION: '10.0.x'                   # Set this to the .NET version of your project
     BUILD_ARTIFACT_NAME: 'released-package'    # Set this according to your team's naming convention
     
   jobs:
     build:
       runs-on: windows-latest # Assumes your target function app is Windows-based
       permissions:
         id-token: write  # Required for OIDC
         contents: read   # Required for actions/checkout
       defaults:
         run:
           shell: bash
           working-directory: ${{ env.AZURE_FUNCTIONAPP_PROJECT_PATH }}
       steps:
         - name: 'Checkout repository'
           uses: actions/checkout@v6
   
         - name: 'Set up .NET version: ${{ env.DOTNET_VERSION }}'
           uses: actions/setup-dotnet@v5
           with:
             dotnet-version: ${{ env.DOTNET_VERSION }}
   
         # Perform additional steps such as running tests, if needed
   
         - name: 'Build and prepare .NET project for deployment'
           run: dotnet publish --configuration Release --output ./output
   
         - name: Upload artifact for the deployment job
           uses: actions/upload-artifact@v7
           with:
             name: ${{ env.BUILD_ARTIFACT_NAME }}
             path: ${{ env.AZURE_FUNCTIONAPP_PROJECT_PATH }}/output
             include-hidden-files: true  # Required for .NET projects
     
     deploy:
       runs-on: windows-latest # Assumes your target function app is Windows-based
       needs: build
       permissions:
         id-token: write  # Required for OIDC
       steps:
         - name: 'Download artifact from build job'
           uses: actions/download-artifact@v8
           with:
             name: ${{ env.BUILD_ARTIFACT_NAME }}
             path: '${{ env.AZURE_FUNCTIONAPP_PROJECT_PATH }}/downloaded-artifact'
        
         - name: 'Log in to Azure with AZ CLI'
           uses: azure/login@v3
           with:
             client-id: ${{ vars.AZURE_CLIENT_ID }}
             tenant-id: ${{ vars.AZURE_TENANT_ID }}
             subscription-id: ${{ vars.AZURE_SUBSCRIPTION_ID }}
           
         - name: 'Run the Azure Functions action'
           uses: Azure/functions-action@v1
           id: deploy-to-function-app
           with:
             app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
             package: '${{ env.AZURE_FUNCTIONAPP_PROJECT_PATH }}/downloaded-artifact'
   

3. No modelo, atualize as env: variáveis do seu projeto. Todo template requer AZURE_FUNCTIONAPP_NAME. As outras variáveis dependem do seu idioma:

   • .NET
   • Java
   • JavaScript
   • Python
   • PowerShell
   • Contêiner

   Variable	Obrigatório	Description
   AZURE_FUNCTIONAPP_NAME	Sim	Seu nome do aplicativo de função no Azure
   DOTNET_VERSION	Sim	A versão .NET do seu projeto (por exemplo, 10.0.x)
   AZURE_FUNCTIONAPP_PROJECT_PATH	Não	Caminho para a pasta do seu projeto. Padrão: . (raiz do repositório)

4. Os templates OIDC já incluem a azure/login etapa com autenticação OIDC. Verifique se os secrets.AZURE_CLIENT_ID, secrets.AZURE_TENANT_ID, e secrets.AZURE_SUBSCRIPTION_IDreferências correspondem aos segredos do repositório que você criou.

5. Adicione esse novo arquivo YAML no caminho /.github/workflows/ em seu repositório.

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

Quando você usa o portal para ativar o GitHub Actions, o Functions cuida de toda a configuração automaticamente. Você não precisa criar manualmente uma identidade gerenciada, configurar credenciais ou escrever um arquivo de fluxo de trabalho. Funções realiza as seguintes tarefas para você:

Na sua assinatura do Azure:

• Cria uma identidade gerenciada atribuída pelo usuário e atribui a ela a função de Contribuidor do Site no seu aplicativo de função.
• Adiciona uma credencial federada à identidade gerenciada para autenticação OIDC do GitHub.

No seu repositório do GitHub:

• Adiciona os valores do ID do cliente, ID de assinatura e ID de tenant como segredos do GitHub Actions.
• Cria um arquivo de fluxo de trabalho baseado na sua pilha de aplicações e o faz commit em .github/workflows.

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

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

1. No portal Azure, selecione Implantação no fluxo Criar Aplicativo de Função.

2. Habilite a Implantação Contínua se quiser que cada atualização de código dispare um push de código para o Portal do Azure.

3. Nas configurações do GitHub, selecione Autorizar para conectar sua conta no GitHub. Faça login com a conta do GitHub que tem acesso de escrita ao seu repositório.

4. Insira sua organização, repositório e branch do GitHub.

5. Opcionalmente, selecione Arquivo de Pré-visualização para ver como o arquivo de fluxo de trabalho fica antes de ser gerado e adicionado ao seu repositório.

6. Conclua a configuração do aplicativo de funções. Seu repositório GitHub agora inclui um novo arquivo de fluxo de trabalho em /.github/workflows/.

Adicionar a um aplicativo de funções existente

Para adicionar um fluxo de trabalho GitHub Actions a um aplicativo de funções existente:

1. Vá ao seu aplicativo de funções no portal do Azure e selecione Centro de Implantação(Deployment >Deployment Center).

2. Selecione Implantação Contínua (CI/CD). Em Fonte, selecione GitHub. Se você não vir a construção de mensagens padrão com GitHub Actions, selecione o provedor de alteração, escolha GitHub Actions e selecione OK.

3. Se você ainda não autorizou o acesso ao GitHub, selecione Autorizar. Forneça suas credenciais de GitHub e selecione Sign in. Para autorizar uma conta de GitHub diferente, selecione Alterar Conta e faça login com outra conta.

4. Selecione seu GitHub Organization, Repository e Branch. Para implantar usando o GitHub Actions, você deve ter acesso de escrita a esse repositório.

5. Para a opção Fluxo de Trabalho, selecione Adicionar um fluxo de trabalho. Essa opção cria um novo arquivo de fluxo de trabalho em /.github/workflows/. Para usar um fluxo de trabalho existente, selecione Usar fluxo de trabalho disponível e escolha seu arquivo de workflow.

6. Nas configurações de autenticação, escolha Identidade atribuída ao usuário para usar o OpenID Connect (OIDC), o que é recomendado porque não exige que você armazene segredos no GitHub. Selecione sua assinatura e o nome de identidade sugerido (Novo ). Uma nova identidade gerenciada atribuída pelo usuário é criada e recebe acesso ao papel de Contribuidor do Site . Se você usar uma identidade existente, primeiro deve conceder a ela acesso ao papel de Contribuidor do Site .

   Importante

   Quando você seleciona Autenticação Básica, seu perfil de publicação, que contém segredos compartilhados, é armazenado no GitHub Secrets. Você também deve ativar a autenticação básica SCM, o que torna seu app menos seguro.

7. Selecione Preview file para ver o arquivo de fluxo de trabalho que é adicionado ao repositório GitHub no .github/workflows/.

8. Selecione Salvar para adicionar o arquivo de fluxo de trabalho ao repositório. Selecione a aba Logs para ver o status das implantações atuais e anteriores.

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

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

1. Em GitHub, vá para o repositório.

2. Selecione Ações e Novo fluxo de trabalho.

3. Pesquise por funções.

   

4. Nos fluxos de trabalho do aplicativo de funções exibidas criados por Microsoft Azure, localize aquele que corresponda ao idioma do código e selecione Configure.

5. No arquivo YAML recém-criado, atualize o parâmetro env.AZURE_FUNCTIONAPP_NAME com o nome do recurso do aplicativo de funções no Azure. Você também pode precisar atualizar o parâmetro que define a versão da linguagem usada pelo seu app, como DOTNET_VERSION para C# ou PYTHON_VERSION para apps Python.

6. Os templates padrão podem usar autenticação de publicar perfil em vez do OIDC recomendado. Para migrar para o OIDC e alinhar com os comportamentos do portal, faça as seguintes alterações:

   • Remova os publish-profileparâmetros , scm-do-build-during-deployment, e enable-oryx-build parâmetros de Azure/functions-action.

   • Remova a environment configuração do trabalho (se presente), pois o sujeito da credencial federada deve corresponder ao gatilho do ramo.

   • Adicione um azure/login passo antes do Azure/functions-action passo:

     - name: 'Login via OIDC'
       uses: azure/login@v3
       with:
         client-id: ${{ secrets.AZURE_CLIENT_ID }}
         tenant-id: ${{ secrets.AZURE_TENANT_ID }}
         subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
     
     - name: 'Run Azure Functions Action'
       uses: Azure/functions-action@v1
       with:
         app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
         package: ${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}
     

   • Adicione as seguintes permissões ao trabalho:

     permissions:
       id-token: write
       contents: read
     

7. Verifique se o novo arquivo de fluxo de trabalho está salvo com um nome apropriado em /.github/workflows/ e selecione Commit alterações.