Tutorial: Automatizar os builds de imagem de contêiner na nuvem ao confirmar o código-fonte

Artigo
10/16/2024

Além de uma tarefa rápida, as Tarefas do ACR são compatíveis com builds de imagem de contêiner automatizados do Docker na nuvem quando você faz commit do código-fonte em um repositório Git. Os contextos do Git compatíveis com as Tarefas do ACR incluem o Azure Repos ou o GitHub público ou privado.

Observação

Atualmente, as Tarefas do ACR não dão suporte a gatilhos de solicitação de pull ou commit em Repos do GitHub Enterprise.

Neste tutorial, a tarefa ACR cria e envia por push uma única imagem de contêiner especificada em um Dockerfile quando você faz commit do código-fonte em um repositório Git. Para criar uma tarefa de várias etapas que usa um arquivo YAML para definir etapas para criar, enviar por push e, opcionalmente, testar vários contêineres ao fazer commit do código, confira o Tutorial: Executar um fluxo de trabalho de contêiner de várias etapas na nuvem ao fazer commit do código-fonte. Para uma visão geral sobre as Tarefas do ACR, confira Automatizar aplicação de patch do sistema operacional e de estrutura com Tarefas do ACR

Neste tutorial:

Cria uma tarefa
Testar a tarefa
Exibir status da tarefa
Disparar a tarefa com uma confirmação de código

Este tutorial presume que você já tenha concluído as tarefas no tutorial anterior. Se você ainda não tiver feito isso, conclua as etapas na seção Pré-requisitos do tutorial anterior antes de continuar.

Pré-requisitos

Obter código de exemplo

Este tutorial presume que você já tenha concluído as tarefas no tutorial anterior e tenha criado o fork para e clonado o repositório de exemplo. Se você ainda não tiver feito isso, conclua as etapas na seção Pré-requisitos do tutorial anterior antes de continuar.

Registro de contêiner

Você deve ter um registro de contêiner do Azure em sua assinatura do Azure para concluir este tutorial. Se você precisar de um registro, consulte o tutorial anterior ou Início Rápido: criar um registro de contêiner usando a CLI do Azure.

Criar um token de acesso pessoal do GitHub

Para disparar uma tarefa em uma confirmação de um repositório Git, as Tarefas do ACR precisam de um PAT (token de acesso pessoal) para acessar o repositório. Se você ainda não tiver um PAT, siga estas etapas para gerar um no GitHub:

Navegue até a página de criação do PAT no GitHub em https://github.com/settings/tokens/new
Digite uma breve descrição para o token, por exemplo, “Demonstração de tarefas do ACR”
Selecione os escopos do ACR para acessar o repositório. Para acessar um repositório público como neste tutorial, em repositório, habilite repo:status e public_repo

Observação

Para gerar um PAT e acessar um repositório privado, selecione o escopo completo de controle do repositório.
Selecione o botão Gerar token (você pode ser solicitado a confirmar sua senha)
Copie e salve o token gerado em um local seguro (use esse token quando você definir uma tarefa na seção a seguir)

Preparar o ambiente para a CLI do Azure

Use o ambiente Bash no Azure Cloud Shell. Para obter mais informações, confira Início Rápido para Bash no Azure Cloud Shell.
Se preferir executar os comandos de referência da CLI localmente, instale a CLI do Azure. Para execuções no Windows ou no macOS, considere executar a CLI do Azure em um contêiner do Docker. Para obter mais informações, confira Como executar a CLI do Azure em um contêiner do Docker.
- Se estiver usando uma instalação local, entre com a CLI do Azure usando o comando az login. Para concluir o processo de autenticação, siga as etapas exibidas no terminal. Para ver outras opções de entrada, confira Conectar-se com a CLI do Azure.
- Quando solicitado, instale a extensão da CLI do Azure no primeiro uso. Para obter mais informações sobre extensões, confira Usar extensões com a CLI do Azure.
- Execute az version para localizar a versão e as bibliotecas dependentes que estão instaladas. Para fazer a atualização para a versão mais recente, execute az upgrade.

Criar a tarefa de build

Agora que você concluiu as etapas necessárias para habilitar as Tarefas do ACR para ler o status de confirmação e criar webhooks em um repositório, você pode criar uma tarefa que dispara um build de imagem de contêiner em confirmações para o repositório.

Primeiro, preencha essas variáveis de ambiente de shell com valores apropriados para seu ambiente. Esta etapa não é estritamente necessária, mas torna a execução dos comandos da CLI do Azure com várias linhas neste tutorial um pouco mais fácil. Se não preencher essas variáveis de ambiente, você precisará substituir manualmente cada valor sempre que aparecerem nos comandos de exemplo.

ACR_NAME=<registry-name>        # The name of your Azure container registry
GIT_USER=<github-username>      # Your GitHub user account name
GIT_PAT=<personal-access-token> # The PAT you generated in the previous section

Agora, crie a tarefa executando o comando az acr task create a seguir.

Observação

O Dockerfile usado no exemplo a seguir depende de uma imagem de contêiner base pública do Docker Hub. Para melhorar a confiabilidade ao usar conteúdo público, importe e gerencie a imagem em um registro de contêiner do Azure privado e atualize seu Dockerfile para usar sua imagem de base gerenciada de forma privada. Saiba mais sobre como trabalhar com imagens públicas.

az acr task create \
    --registry $ACR_NAME \
    --name taskhelloworld \
    --image helloworld:{{.Run.ID}} \
    --context https://github.com/$GIT_USER/acr-build-helloworld-node.git#master \
    --file Dockerfile \
    --git-access-token $GIT_PAT

Essa tarefa especifica que, sempre que for feito commit do código no branch principal no repositório especificado por --context, as Tarefas do ACR compilarão a imagem de contêiner por meio do código desse branch. O Dockerfile especificado pelo --file da raiz do repositório é usado para criar a imagem. O argumento --image especifica um valor com parâmetros de {{.Run.ID}} para a parte da versão de marca da imagem, garantindo que a imagem criada esteja correlacionada a um build específico e seja marcada exclusivamente.

A saída de um comando az acr task create bem-sucedido é semelhante à seguinte:

{
  "agentConfiguration": {
    "cpu": 2
  },
  "creationDate": "2010-11-19T22:42:32.972298+00:00",
  "id": "/subscriptions/<Subscription ID>/resourceGroups/myregistry/providers/Microsoft.ContainerRegistry/registries/myregistry/tasks/taskhelloworld",
  "location": "westcentralus",
  "name": "taskhelloworld",
  "platform": {
    "architecture": "amd64",
    "os": "Linux",
    "variant": null
  },
  "provisioningState": "Succeeded",
  "resourceGroup": "myregistry",
  "status": "Enabled",
  "step": {
    "arguments": [],
    "baseImageDependencies": null,
    "contextPath": "https://github.com/gituser/acr-build-helloworld-node#main",
    "dockerFilePath": "Dockerfile",
    "imageNames": [
      "helloworld:{{.Run.ID}}"
    ],
    "isPushEnabled": true,
    "noCache": false,
    "type": "Docker"
  },
  "tags": null,
  "timeout": 3600,
  "trigger": {
    "baseImageTrigger": {
      "baseImageTriggerType": "Runtime",
      "name": "defaultBaseimageTriggerName",
      "status": "Enabled"
    },
    "sourceTriggers": [
      {
        "name": "defaultSourceTriggerName",
        "sourceRepository": {
          "branch": "main",
          "repositoryUrl": "https://github.com/gituser/acr-build-helloworld-node#main",
          "sourceControlAuthProperties": null,
          "sourceControlType": "GitHub"
        },
        "sourceTriggerEvents": [
          "commit"
        ],
        "status": "Enabled"
      }
    ]
  },
  "type": "Microsoft.ContainerRegistry/registries/tasks"
}

Testar a tarefa de build

Agora, você tem uma tarefa que define seu build. Para testar o pipeline de build, dispare um build manualmente executando o comando az acr task run:

az acr task run --registry $ACR_NAME --name taskhelloworld

Por padrão, o comando az acr task run transmite a saída de log para o console quando você executa o comando. A saída foi condensada para mostrar as principais etapas.

2020/11/19 22:51:00 Using acb_vol_9ee1f28c-4fd4-43c8-a651-f0ed027bbf0e as the home volume
2020/11/19 22:51:00 Setting up Docker configuration...
2020/11/19 22:51:02 Successfully set up Docker configuration
2020/11/19 22:51:02 Logging in to registry: myregistry.azurecr.io
2020/11/19 22:51:03 Successfully logged in
2020/11/19 22:51:03 Executing step: build
2020/11/19 22:51:03 Obtaining source code and scanning for dependencies...
2020/11/19 22:51:05 Successfully obtained source code and scanned for dependencies
Sending build context to Docker daemon  23.04kB
Step 1/5 : FROM node:15-alpine
[...]
Step 5/5 : CMD ["node", "/src/server.js"]
 ---> Running in 7382eea2a56a
Removing intermediate container 7382eea2a56a
 ---> e33cd684027b
Successfully built e33cd684027b
Successfully tagged myregistry.azurecr.io/helloworld:da2
2020/11/19 22:51:11 Executing step: push
2020/11/19 22:51:11 Pushing image: myregistry.azurecr.io/helloworld:da2, attempt 1
The push refers to repository [myregistry.azurecr.io/helloworld]
4a853682c993: Preparing
[...]
4a853682c993: Pushed
[...]
da2: digest: sha256:c24e62fd848544a5a87f06ea60109dbef9624d03b1124bfe03e1d2c11fd62419 size: 1366
2020/11/19 22:51:21 Successfully pushed image: myregistry.azurecr.io/helloworld:da2
2020/11/19 22:51:21 Step id: build marked as successful (elapsed time in seconds: 7.198937)
2020/11/19 22:51:21 Populating digests for step id: build...
2020/11/19 22:51:22 Successfully populated digests for step id: build
2020/11/19 22:51:22 Step id: push marked as successful (elapsed time in seconds: 10.180456)
The following dependencies were found:
- image:
    registry: myregistry.azurecr.io
    repository: helloworld
    tag: da2
    digest: sha256:c24e62fd848544a5a87f06ea60109dbef9624d03b1124bfe03e1d2c11fd62419
  runtime-dependency:
    registry: registry.hub.docker.com
    repository: library/node
    tag: 9-alpine
    digest: sha256:8dafc0968fb4d62834d9b826d85a8feecc69bd72cd51723c62c7db67c6dec6fa
  git:
    git-head-revision: 68cdf2a37cdae0873b8e2f1c4d80ca60541029bf


Run ID: ca6 was successful after 27s

Disparar um build com uma confirmação

Agora que você testou a tarefa executando-a manualmente, dispare-a automaticamente com uma alteração de código-fonte.

Primeiro, certifique-se de que você esteja no diretório que contém o clone local do repositório:

cd acr-build-helloworld-node

Em seguida, execute os seguintes comandos para criar, confirmar e enviar um novo arquivo para o seu fork do repositório no GitHub:

echo "Hello World!" > hello.txt
git add hello.txt
git commit -m "Testing ACR Tasks"
git push origin main

Você pode ser solicitado a fornecer suas credenciais do GitHub quando executar o comando git push. Forneça seu nome de usuário do GitHub e insira o token de acesso pessoal (PAT) que criou anteriormente para a senha.

Username for 'https://github.com': <github-username>
Password for 'https://githubuser@github.com': <personal-access-token>

Depois que você tiver efetuado push em uma confirmação para o repositório, o webhook criado pelas Tarefas do ACR dispararão e iniciarão um build no Registro de Contêiner do Azure. Exiba os logs de compilação para a tarefa em execução no momento verificar e monitorar o andamento do build:

az acr task logs --registry $ACR_NAME

A saída é semelhante à seguinte, mostrando a tarefa em execução no momento (ou executada por último):

Showing logs of the last created run.
Run ID: ca7

[...]

Run ID: ca7 was successful after 38s

Listar builds

Para ver uma lista das execuções de tarefa que as Tarefas do ACR concluíram para seu registro, execute o comando az acr task list-runs:

az acr task list-runs --registry $ACR_NAME --output table

A saída do comando deve ser semelhante ao seguinte. As execuções que as Tarefas do ACR efetuou são exibidas, e “Confirmação de Git” aparece na coluna GATILHO para a tarefa mais recente:

RUN ID    TASK            PLATFORM    STATUS     TRIGGER    STARTED               DURATION
--------  --------------  ----------  ---------  ---------  --------------------  ----------
ca7       taskhelloworld  linux       Succeeded  Commit     2020-11-19T22:54:34Z  00:00:29
ca6       taskhelloworld  linux       Succeeded  Manual     2020-11-19T22:51:47Z  00:00:24
ca5                       linux       Succeeded  Manual     2020-11-19T22:23:42Z  00:00:23

Próximas etapas

Neste tutorial, você aprenderá como usar uma tarefa para disparar builds de imagem de contêiner automaticamente no Azure quando você confirmar o código-fonte para um repositório Git. Vá para o próximo tutorial para aprender a criar tarefas que disparam builds quando a imagem base de uma imagem de contêiner for atualizada.

Automatizar builds na atualização da imagem de base

Compartilhar via