Configurar uma Ação do GitHub para criar uma instância de contentor

GitHub Actions é um conjunto de funcionalidades no GitHub para automatizar os fluxos de trabalho de desenvolvimento de software no mesmo local onde armazena código e colabora em pedidos Pull e problemas.

Utilize a GitHub Actions Implementar para Azure Container Instances para automatizar a implementação de um único contentor para Azure Container Instances. A ação permite-lhe definir propriedades para uma instância de contentor semelhantes às do comando az container create .

Este artigo mostra como configurar um fluxo de trabalho num repositório do GitHub que executa as seguintes ações:

• Criar uma imagem a partir de um Dockerfile
• Enviar a imagem para um registo de contentor do Azure
• Implementar a imagem de contentor numa instância de contentor do Azure

Este artigo mostra duas formas de configurar o fluxo de trabalho:

• Configurar o fluxo de trabalho do GitHub – crie um fluxo de trabalho num repositório do GitHub com a ação Implementar para Azure Container Instances e outras ações.
• Utilizar a extensão da CLI – utilize o az container app up comando na extensão Implementar no Azure na CLI do Azure. Este comando simplifica a criação dos passos de implementação e fluxo de trabalho do GitHub.

Importante

A GitHub Actions para Azure Container Instances está atualmente em pré-visualização. As pré-visualizações são disponibilizadas a si na condição de concordar com os termos suplementares de utilização. Alguns aspetos desta funcionalidade podem alterar-se após a disponibilidade geral (GA).

Pré-requisitos

• Conta do GitHub – crie uma conta em https://github.com se ainda não tiver uma.
• CLI do Azure - Pode utilizar a Cloud Shell do Azure ou uma instalação local da CLI do Azure para concluir os passos da CLI do Azure. Se precisar de instalar ou atualizar, veja Install Azure CLI (Instalar o Azure CLI).
• Registo de contentor do Azure – se não tiver um, crie um registo de contentor do Azure no escalão Básico com a CLI do Azure, portal do Azure ou outros métodos. Tome nota do grupo de recursos utilizado para a implementação, que é utilizado para o fluxo de trabalho do GitHub.

Configurar o repositório

• Para obter os exemplos neste artigo, utilize o GitHub para criar o fork do seguinte repositório: https://github.com/Azure-Samples/acr-build-helloworld-node

  Este repositório contém um Dockerfile e ficheiros de origem para criar uma imagem de contentor de uma pequena aplicação Web.

  

• Certifique-se de que as Ações estão ativadas para o seu repositório. Navegue para o seu repositório bifurcado e selecione Definições Ações>. Em Permissões de ações, certifique-se de que a opção Permitir todas as ações está selecionada.

Configurar o fluxo de trabalho do GitHub

Criar credenciais para a autenticação do Azure

Service principal (Principal de serviço)

No fluxo de trabalho do GitHub, tem de fornecer credenciais do Azure para autenticar na CLI do Azure. O exemplo seguinte cria um principal de serviço com a função Contribuidor no âmbito do grupo de recursos do seu registo de contentor.

Primeiro, obtenha o ID de recurso do grupo de recursos. Substitua o nome do seu grupo no seguinte comando az group show :

groupId=$(az group show \
  --name <resource-group-name> \
  --query id --output tsv)

Utilize az ad sp create-for-rbac para criar o principal de serviço:

az ad sp create-for-rbac \
  --scope $groupId \
  --role Contributor \
  --json-auth

A saída é semelhante a:

{
  "clientId": "xxxx6ddc-xxxx-xxxx-xxx-ef78a99dxxxx",
  "clientSecret": "xxxx79dc-xxxx-xxxx-xxxx-aaaaaec5xxxx",
  "subscriptionId": "xxxx251c-xxxx-xxxx-xxxx-bf99a306xxxx",
  "tenantId": "xxxx88bf-xxxx-xxxx-xxxx-2d7cd011xxxx",
  "activeDirectoryEndpointUrl": "https://login.microsoftonline.com",
  "resourceManagerEndpointUrl": "https://management.azure.com/",
  "activeDirectoryGraphResourceId": "https://graph.windows.net/",
  "sqlManagementEndpointUrl": "https://management.core.windows.net:8443/",
  "galleryEndpointUrl": "https://gallery.azure.com/",
  "managementEndpointUrl": "https://management.core.windows.net/"
}

Guarde a saída JSON porque é utilizada num passo posterior. Além disso, tome nota do clientId, que tem de atualizar o principal de serviço na secção seguinte.

OpenID Connect

O OpenID Connect é um método de autenticação que utiliza tokens de curta duração. Configurar o OpenID Connect com GitHub Actions é um processo mais complexo que oferece segurança reforçada.

1. Se não tiver uma aplicação existente, registe uma nova aplicação do Active Directory e um principal de serviço que possa aceder aos recursos. Crie a aplicação do Active Directory.

   az ad app create --display-name myApp
   

   Este comando irá produzir JSON com um appId que é o seu client-id. Guarde o valor a utilizar como segredo do AZURE_CLIENT_ID GitHub mais tarde.

   Irá utilizar o valor ao objectId criar credenciais federadas com Graph API e referenciá-lo como .APPLICATION-OBJECT-ID

2. Criar um principal de serviço. Substitua pelo $appID appId da saída JSON.

   Este comando gera uma saída JSON com um diferente objectId e será utilizado no próximo passo. O novo objectId é o assignee-object-id.

   Copie o para utilizar como segredo do appOwnerTenantId GitHub para AZURE_TENANT_ID mais tarde.

    az ad sp create --id $appId
   

3. Crie uma nova atribuição de função por subscrição e objeto. Por predefinição, a atribuição de função estará associada à sua subscrição predefinida. Substitua pelo $subscriptionId ID da subscrição, $resourceGroupName pelo nome do grupo de recursos e $assigneeObjectId pelo gerado assignee-object-id. Saiba como gerir subscrições do Azure com a CLI do Azure.

   az role assignment create --role contributor --subscription $subscriptionId --assignee-object-id  $assigneeObjectId --scope /subscriptions/$subscriptionId/resourceGroups/$resourceGroupName/providers/Microsoft.Web/sites/ --assignee-principal-type ServicePrincipal
   

4. Execute o seguinte comando para criar uma nova credencial de identidade federada para a sua aplicação do Active Directory.

   • Substitua pelo APPLICATION-OBJECT-IDobjectId (gerado durante a criação da aplicação) para a sua aplicação do Active Directory.
   • Defina um valor para para CREDENTIAL-NAME referenciar mais tarde.
   • Defina o subject. O valor deste valor é definido pelo GitHub consoante o seu fluxo de trabalho:
     • Tarefas no seu ambiente de GitHub Actions:repo:< Organization/Repository >:environment:< Name >
     • Para Tarefas não associadas a um ambiente, inclua o caminho ref para ramo/etiqueta com base no caminho ref utilizado para acionar o fluxo de trabalho: repo:< Organization/Repository >:ref:< ref path>. Por exemplo, repo:n-username/ node_express:ref:refs/heads/my-branch ou repo:n-username/ node_express:ref:refs/tags/my-tag.
     • Para fluxos de trabalho acionados por um evento de pedido Pull: repo:< Organization/Repository >:pull_request.

   az ad app federated-credential create --id <APPLICATION-OBJECT-ID> --parameters credential.json
   ("credential.json" contains the following content)
   {
       "name": "<CREDENTIAL-NAME>",
       "issuer": "https://token.actions.githubusercontent.com/",
       "subject": "repo:organization/repository:ref:refs/heads/main",
       "description": "Testing",
       "audiences": [
           "api://AzureADTokenExchange"
       ]
   }
   

Para saber como criar uma aplicação do Active Directory, principal de serviço e credenciais federadas no portal do Azure, veja Ligar o GitHub e o Azure.

Atualização da autenticação do registo

Service principal (Principal de serviço)

Atualize as credenciais do principal de serviço do Azure para permitir o acesso push e pull ao seu registo de contentor. Este passo permite que o fluxo de trabalho do GitHub utilize o principal de serviço para autenticar com o registo de contentor e emitir e solicitar uma imagem do Docker.

Obtenha o ID de recurso do seu registo de contentor. Substitua o nome do seu registo no seguinte comando az acr show :

registryId=$(az acr show \
  --name <registry-name> \
  --resource-group <resource-group-name> \
  --query id --output tsv)

Utilize az role assignment create para atribuir a função AcrPush, que dá acesso push e pull ao registo. Substitua o ID de cliente do principal de serviço:

az role assignment create \
  --assignee <ClientId> \
  --scope $registryId \
  --role AcrPush

OpenID Connect

Tem de dar permissão à aplicação para aceder ao Azure Container Registry e criar uma Instância de Contentor do Azure.

1. Em portal do Azure, aceda a Registos de aplicações.

2. Procure o registo da aplicação OpenID Connect e copie o ID da Aplicação (cliente).

3. Conceda permissões para a sua aplicação ao seu grupo de recursos. Terá de definir permissões ao nível do grupo de recursos para poder criar instâncias do Azure Container.

   az role assignment create \
   --assignee <appID> \
   --role Contributor \
    --scope /subscriptions/<subscription-id>/resourceGroups/<resource-group>
   

Guardar credenciais no repositório do GitHub

Service principal (Principal de serviço)

1. Na IU do GitHub, navegue para o seu repositório bifurcado e selecione Segredos de Segurança > e variáveis Ações>.

2. Selecione Novo segredo do repositório para adicionar os seguintes segredos:

Segredo	Valor
AZURE_CREDENTIALS	Toda a saída JSON do passo de criação do principal de serviço
REGISTRY_LOGIN_SERVER	O nome do servidor de início de sessão do seu registo (em minúsculas). Exemplo: myregistry.azurecr.io
REGISTRY_USERNAME	O clientId da saída JSON da criação do principal de serviço
REGISTRY_PASSWORD	O clientSecret da saída JSON da criação do principal de serviço
RESOURCE_GROUP	O nome do grupo de recursos que utilizou para definir o âmbito do principal de serviço

OpenID Connect

Tem de fornecer o ID de Cliente, o ID de Inquilino e o ID de Subscrição da aplicação para a ação de início de sessão. Estes valores podem ser fornecidos diretamente no fluxo de trabalho ou podem ser armazenados em segredos do GitHub e referenciados no seu fluxo de trabalho. Guardar os valores como segredos do GitHub é a opção mais segura.

1. Abra o seu repositório do GitHub e aceda a Definições Segredos > de Segurança > e variáveis Ações >> Novo segredo do repositório.

2. Crie segredos para AZURE_CLIENT_ID, AZURE_TENANT_IDe AZURE_SUBSCRIPTION_ID. Utilize estes valores da sua aplicação do Active Directory para os segredos do GitHub:

   Segredo do GitHub	Aplicação do Active Directory
   AZURE_CLIENT_ID	ID da Aplicação (cliente)
   AZURE_TENANT_ID	ID do Diretório (inquilino)
   AZURE_SUBSCRIPTION_ID	ID da subscrição

3. Guarde cada segredo ao selecionar Adicionar segredo.

Criar ficheiro de fluxo de trabalho

1. Na IU do GitHub, selecione Ações.
2. Selecione configurar um fluxo de trabalho manualmente.
3. Em Editar novo ficheiro, cole os seguintes conteúdos YAML para substituir o código de exemplo. Aceite o nome main.ymlde ficheiro predefinido ou forneça um nome de ficheiro que escolher.
4. Selecione Iniciar consolidação, forneça opcionalmente descrições curtas e expandidas da consolidação e selecione Consolidar novo ficheiro.

Service principal (Principal de serviço)

on: [push]
name: Linux_Container_Workflow

jobs:
    build-and-deploy:
        runs-on: ubuntu-latest
        steps:
        # checkout the repo
        - name: 'Checkout GitHub Action'
          uses: actions/checkout@main

        - name: 'Login via Azure CLI'
          uses: azure/login@v1
          with:
            creds: ${{ secrets.AZURE_CREDENTIALS }}

        - name: 'Build and push image'
          uses: docker/login-action@v3
          with:
            registry: $({ secrets.REGISTRY_LOGIN_SERVER })
            username: ${{ secrets.AZURE_CLIENT_ID }}
            password: ${{ secrets.AZURE_CLIENT_SECRET }}
        - run: |
            docker build . -t ${{ secrets.REGISTRY_LOGIN_SERVER }}/sampleapp:${{ github.sha }}
            docker push ${{ secrets.REGISTRY_LOGIN_SERVER }}/sampleapp:${{ github.sha }}

        - name: 'Deploy to Azure Container Instances'
          uses: 'azure/aci-deploy@v1'
          with:
            resource-group: ${{ secrets.RESOURCE_GROUP }}
            dns-name-label: ${{ secrets.RESOURCE_GROUP }}${{ github.run_number }}
            image: ${{ secrets.REGISTRY_LOGIN_SERVER }}/sampleapp:${{ github.sha }}
            registry-login-server: ${{ secrets.REGISTRY_LOGIN_SERVER }}
            registry-username: ${{ secrets.REGISTRY_USERNAME }}
            registry-password: ${{ secrets.REGISTRY_PASSWORD }}
            name: aci-sampleapp
            location: 'west us'

OpenID Connect

on: [push]
name: Linux_Container_Workflow_OIDC

permissions:
  id-token: write
  contents: read

on:
  push:
    branches:
    - main
    - release/*

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

        - name: 'Login via Azure CLI'
          uses: azure/login@v1
          with:
           client-id: ${{ secrets.AZURE_CLIENT_ID }}
           tenant-id: ${{ secrets.AZURE_TENANT_ID }}
           subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}

        - name: Build and push image
          id: build-image
          run: |
           az acr build --image ${{ secrets.REGISTRY_LOGIN_SERVER }}/sampleapp:${{ github.sha }} --registry ${{ secrets.REGISTRY_LOGIN_SERVER }} --file "Dockerfile" .

        - name: 'Deploy to Azure Container Instances'
          uses: 'azure/aci-deploy@v1'
          with:
           resource-group: ${{ secrets.RESOURCE_GROUP }}
           dns-name-label: ${{ secrets.RESOURCE_GROUP }}${{ github.run_number }}
           image: ${{ secrets.REGISTRY_LOGIN_SERVER }}/sampleapp:${{ github.sha }}
           registry-login-server: ${{ secrets.REGISTRY_LOGIN_SERVER }}
           registry-username: ${{ secrets.REGISTRY_USERNAME }}
           registry-password: ${{ secrets.REGISTRY_PASSWORD }}
           name: aci-sampleapp
           location: 'west us'

Validar fluxo de trabalho

Depois de consolidar o ficheiro de fluxo de trabalho, o fluxo de trabalho é acionado. Para rever o progresso do fluxo de trabalho, navegue para Fluxosde Trabalho de Ações>.

Veja Ver o histórico de execuções de fluxos de trabalho para obter informações sobre como ver o estado e os resultados de cada passo no seu fluxo de trabalho. Se o fluxo de trabalho não estiver concluído, veja Ver registos para diagnosticar falhas.

Quando o fluxo de trabalho for concluído com êxito, obtenha informações sobre a instância de contentor com o nome aci-sampleapp ao executar o comando az container show . Substitua o nome do grupo de recursos:

az container show \
  --resource-group <resource-group-name> \
  --name aci-sampleapp \
  --query "{FQDN:ipAddress.fqdn,ProvisioningState:provisioningState}" \
  --output table

A saída é semelhante a:

FQDN                                   ProvisioningState
---------------------------------      -------------------
aci-action01.westus.azurecontainer.io  Succeeded

Depois de a instância ser aprovisionada, navegue para o FQDN do contentor no browser para ver a aplicação Web em execução.

Utilizar Implementar na extensão do Azure

Em alternativa, utilize a extensão Implementar no Azure na CLI do Azure para configurar o fluxo de trabalho. O az container app up comando na extensão utiliza os parâmetros de entrada para configurar um fluxo de trabalho para implementar no Azure Container Instances.

O fluxo de trabalho criado pela CLI do Azure é semelhante ao fluxo de trabalho que pode criar manualmente com o GitHub.

Pré-requisito adicional

Para além dos pré-requisitos e da configuração do repositório para este cenário, tem de instalar a extensão Implementar no Azure para a CLI do Azure.

Execute o comando az extension add para instalar a extensão:

az extension add \
  --name deploy-to-azure

Para obter informações sobre como localizar, instalar e gerir extensões, veja Utilizar extensões com a CLI do Azure.

Executar az container app up

Para executar o comando az container app up , indique, no mínimo:

• O nome do registo de contentor do Azure, por exemplo myregistry
• O URL para o seu repositório do GitHub, por exemplo, https://github.com/<your-GitHub-Id>/acr-build-helloworld-node

Comando de exemplo:

az container app up \
  --acr myregistry \
  --repository https://github.com/myID/acr-build-helloworld-node

Progresso do comando

• Quando lhe for pedido, forneça as suas credenciais do GitHub ou forneça um token de acesso pessoal (PAT) do GitHub que tenha âmbitos de repositório e utilizador para autenticar com a sua conta do GitHub. Se fornecer credenciais do GitHub, o comando cria um PAT para si. Siga as instruções adicionais para configurar o fluxo de trabalho.

• O comando cria segredos do repositório para o fluxo de trabalho:

  • Credenciais do principal de serviço para a CLI do Azure
  • Credenciais para aceder ao registo de contentor do Azure

• Depois de o comando consolidar o ficheiro de fluxo de trabalho no seu repositório, o fluxo de trabalho é acionado.

A saída é semelhante a:

[...]
Checking in file github/workflows/main.yml in the GitHub repository myid/acr-build-helloworld-node
Creating workflow...
GitHub Action Workflow has been created - https://github.com/myid/acr-build-helloworld-node/runs/515192398
GitHub workflow completed.
Workflow succeeded
Your app is deployed at:  http://acr-build-helloworld-node.eastus.azurecontainer.io:8080/

Para ver o estado do fluxo de trabalho e os resultados de cada passo na IU do GitHub, veja Ver o histórico de execuções de fluxos de trabalho.

Validar fluxo de trabalho

O fluxo de trabalho implementa uma instância de contentor do Azure com o nome base do seu repositório do GitHub, neste caso, acr-build-helloworld-node. Quando o fluxo de trabalho for concluído com êxito, obtenha informações sobre a instância de contentor com o nome acr-build-helloworld-node ao executar o comando az container show . Substitua o nome do grupo de recursos:

az container show \
  --resource-group <resource-group-name> \
  --name acr-build-helloworld-node \
  --query "{FQDN:ipAddress.fqdn,ProvisioningState:provisioningState}" \
  --output table

A saída é semelhante a:

FQDN                                                   ProvisioningState
---------------------------------                      -------------------
acr-build-helloworld-node.westus.azurecontainer.io     Succeeded

Depois de a instância ser aprovisionada, navegue para o FQDN do contentor no browser para ver a aplicação Web em execução.

Limpar os recursos

Pare a instância de contentor com o comando az container delete:

az container delete \
  --name <instance-name>
  --resource-group <resource-group-name>

Para eliminar o grupo de recursos e todos os recursos nele contidos, execute o comando az group delete :

az group delete \
  --name <resource-group-name>

Passos seguintes

Procure mais ações no GitHub Marketplace para automatizar o fluxo de trabalho de desenvolvimento