Implemente para o Funções do Azure usando o GitHub Actions

Quando utiliza o portal Azure para ativar o GitHub Actions, o Functions executa automaticamente estas tarefas, tanto na sua subscrição do Azure como no seu repositório GitHub.

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

Crie uma identidade gerida para a implementação do GitHub Actions

O OpenID Connect (OIDC) é o método de autenticação recomendado para implementações do GitHub Actions no Funções do Azure. Com o OIDC, configura uma identidade gerida atribuída pelo utilizador no Azure e cria uma relação de confiança com o seu repositório GitHub. O fluxo de trabalho pode então autenticar-se com o Azure sem guardar 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 seu grupo de recursos.

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

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

   Precisas destes três valores mais tarde, quando adicionares credenciais ao GitHub.

3. Use o comando az role assignment create para atribuir o Website Contributor papel à identidade gerida, com âmbito para a sua aplicação 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 da sua aplicação e do grupo de recursos, respetivamente.

4. Use o comando create de identidade federada da az para criar uma credencial federada que confie nos tokens do seu repositório 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> pelos seus valores. O sujeito deve corresponder ao ramo que desencadeia o teu fluxo de trabalho.

5. (Opcional) Se estiver a implementar um contentor do Azure Container Registry, atribua também o acrpull papel à identidade gerida:

   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> pelos teus valores.

Adicionar credenciais ao GitHub

Use os valores que copiou quando criou a identidade gerida.

1. Em GitHub, vai ao teu repositório.

2. Vai a Definições>Segredos e variáveis>Ações.

3. No separador Segredos , selecione Novo segredo de repositório.

4. Crie cada um dos seguintes segredos:

   Name	Value
   AZURE_CLIENT_ID	A clientId da identidade gerida
   AZURE_TENANT_ID	A tenantId da identidade gerida
   AZURE_SUBSCRIPTION_ID	O ID de subscrição que contém a tua aplicação de funções

Para implementações de contentores a partir de um registo privado, também precisa de segredos específicos de cada registo. Para mais informações, consulte Ação de Login no Docker.

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.

1. Escolha Windows ou Linux para garantir que obtém o modelo para o sistema operativo correto.

   • Windows
   • Linux

   Implementações para Windows usam runs-on: windows-latest. Implementações containerizadas requerem Linux.

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

   • .NET
   • Java
   • Javascript
   • Python
   • PowerShell
   • Contentor

   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. Cada modelo requer AZURE_FUNCTIONAPP_NAME. As outras variáveis dependem da tua linguagem:

   • .NET
   • Java
   • Javascript
   • Python
   • PowerShell
   • Contentor

   Variável	Required	Description
   AZURE_FUNCTIONAPP_NAME	Yes	O nome da tua function app no Azure
   DOTNET_VERSION	Yes	A versão .NET do seu projeto (por exemplo, 10.0.x)
   AZURE_FUNCTIONAPP_PROJECT_PATH	No	Caminho para a pasta do teu projeto. Padrão: . (raiz do repositório)

4. Os modelos OIDC já incluem o azure/login passo com autenticação OIDC. Verifique se os secrets.AZURE_CLIENT_ID, secrets.AZURE_TENANT_ID, e secrets.AZURE_SUBSCRIPTION_ID as referências correspondem aos segredos do repositório que criou.

5. Adicione este novo ficheiro YAML no caminho /.github/workflows/ do seu repositório.

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

Quando usas o portal para ativar o GitHub Actions, o Functions trata de toda a configuração automaticamente. Não precisa de criar manualmente uma identidade gerida, configurar credenciais ou escrever um ficheiro de workflow. A Functions realiza estas tarefas por si:

Na sua subscrição do Azure:

• Cria uma identidade gerida atribuída pelo utilizador e atribui-lhe o papel de Contribuidor do Website na tua aplicação de funções.
• Adiciona uma credencial federada à identidade gerida para autenticação OIDC do GitHub.

No teu repositório GitHub:

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

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:

1. No portal Azure, selecione Implementação no fluxo de Criar Aplicação de Função.

2. Ativa Continuous Deployment se quiseres que cada atualização de código desencadeie um push de código para Azure portal.

3. Nas definições do GitHub, selecione Autorizar para ligar a sua conta no GitHub. Inicia sessão com a conta do GitHub que tem acesso de escrita ao teu repositório.

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

5. Opcionalmente, selecione Ficheiro de Pré-visualização para ver como o ficheiro de workflow se apresenta antes de ser gerado e adicionado ao seu repositório.

6. 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:

1. Vá à sua aplicação de funções no portal do Azure e selecioneCentro de Implementação de >.

2. Selecione Implantação Contínua (CI/CD). Em Source, selecione GitHub. Se não vires a Construção de Mensagens por defeito com GitHub Actions, seleciona Change provider, escolhe GitHub Actions e seleciona OK.

3. Se ainda não autorizou o acesso ao GitHub, selecione Autorizar. 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.

4. Selecione o seu GitHub Organization, Repository e Branch. Para implementar através do GitHub Actions, deve ter acesso de escrita a este repositório.

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

6. Nas definições de Autenticação, escolha Identidade atribuída pelo utilizador para usar o OpenID Connect (OIDC), o que é recomendado porque não exige que armazene segredos no GitHub. Selecione a sua subscrição e o nome de identidade (Novo) sugerido. É criada uma nova identidade gerida atribuída pelo utilizador, que recebe acesso ao papel de Contribuidor do Website . Se usar uma identidade existente, deve primeiro conceder-lhe acesso ao papel de Contribuidor do Website .

   Importante

   Quando seleciona Autenticação Básica, o seu perfil de publicação, que contém segredos partilhados, é armazenado no GitHub Secrets. Deve também ativar a autenticação SCM básica, o que torna a sua aplicação menos segura.

7. Seleciona Preview file para ver o ficheiro de workflow que é adicionado ao teu repositório de GitHub em .github/workflows/.

8. Selecione Salvar para adicionar o arquivo de fluxo de trabalho ao repositório. Selecione o separador Logs para ver o estado das implementações atuais e anteriores.

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 Funções do Azure diretamente a partir do teu repositório GitHub.

1. Em GitHub, vai ao teu repositório.

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

3. Pesquise funções.

   

4. 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.

5. 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. Também pode precisar de atualizar o parâmetro que define a versão da linguagem usada pela sua aplicação, como DOTNET_VERSION para C# ou PYTHON_VERSION aplicações Python.

6. Os templates predefinidos podem usar autenticação de publicar perfil em vez do OIDC recomendado. Para mudar para 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 de Azure/functions-action.

   • Remova a environment definição do trabalho (se existir), uma vez que o sujeito da credencial federada deve corresponder ao disparador da ramificação.

   • 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 ficheiro de workflow está guardado com um nome apropriado em /.github/workflows/ e selecione Commit alterações.