Tutorial: automatizar builds de imagem de contêiner na atualização da imagem base em um Registro de Contêiner do Azure

Artigo
10/31/2023

As Tarefas do ACR dão suporte aos builds de imagem de contêiner automatizados quando a imagem base de um contêiner é atualizada, como quando um patch é aplicado ao sistema operacional ou à estrutura do aplicativo em uma das imagens base.

Neste tutorial, você aprenderá a criar uma tarefa do ACR que dispara um build na nuvem quando a imagem base de um contêiner é enviada por push para o mesmo Registro. Experimente também um tutorial para criar uma tarefa do ACR que dispara um build de imagem quando uma imagem base é enviada por push para outro Registro de Contêiner do Azure.

Neste tutorial:

Compilar a imagem base
Criar uma imagem de aplicativo no mesmo Registro para acompanhar a imagem base
Atualizar a imagem base para disparar uma tarefa de imagem de aplicativo
Exibir a tarefa disparada
Verificar a imagem do aplicativo atualizada

Pré-requisitos

Conclua os tutoriais anteriores

Este tutorial pressupõe que você já tenha configurado seu ambiente e concluído as etapas nos dois primeiros tutoriais da série, em que você:

Crie um registro de contêiner do Azure
Repositório de exemplo de fork
Clona o repositório de exemplo
Cria um token de acesso pessoal do GitHub

Caso ainda não tenha feito isso, conclua os seguintes tutoriais antes de continuar:

Compilar imagens de contêineres na nuvem com as Tarefas do Registro de Contêiner do Azure

Automatizar builds de imagem de contêiner com as Tarefas do Registro de Contêiner do Azure

Configure o ambiente

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 saber mais, 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.

Este artigo exige a versão 2.0.46 ou posterior da CLI do Azure. Se você está usando o Azure Cloud Shell, a versão mais recente já está instalada.

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 second tutorial

Cenário de atualização de imagem base

Este tutorial descreve um cenário de atualização de imagem base no qual uma imagem base e uma imagem de aplicativo são mantidas em um só Registro.

O exemplo de código inclui dois Dockerfiles: uma imagem do aplicativo e uma imagem que ele especifica como base. Nas seções a seguir, você criará uma tarefa do ACR que dispara automaticamente um build da imagem do aplicativo quando uma nova versão da imagem base é enviada por push para o mesmo registro de contêiner.

Dockerfile-app: um pequeno aplicativo Web Node.js que renderiza uma página da Web estática exibindo a versão do Node.js no qual é baseado. A cadeia de caracteres de versão é simulada: ela exibe o conteúdo de uma variável de ambiente, NODE_VERSION, que é definida na imagem base.
Dockerfile-base: a imagem que Dockerfile-app especifica como base. É baseado em uma imagem Node e inclui a variável de ambiente NODE_VERSION.

Nas seções a seguir, você criará uma tarefa, atualizará o valor NODE_VERSION no Dockerfile da imagem base e usará as Tarefas do ACR para compilar a imagem base. Quando a tarefa do ACR efetua push na nova imagem base para o registro, ela automaticamente dispara um build da imagem do aplicativo. Opcionalmente, você pode executar a imagem de contêiner do aplicativo localmente para ver as cadeias de caracteres de versões diferentes nas imagens compiladas.

Neste tutorial, a tarefa do ACR compila e envia por push uma única imagem do contêiner especificada em um Dockerfile. As Tarefas do ACR também podem executar tarefas de várias etapas, usando um arquivo YAML para definir as etapas para criar, efetuar push e, opcionalmente, testar vários contêineres.

Compilar a imagem base

Comece compilando a imagem base com uma tarefa rápida das Tarefas do ACR usando az acr build. Conforme discutido no primeiro tutorial da série, esse processo não só compila a imagem, mas efetuar push para o registro de contêiner, se o build for bem-sucedido.

az acr build --registry $ACR_NAME --image baseimages/node:15-alpine --file Dockerfile-base .

Cria uma tarefa

Em seguida, crie uma tarefa com az acr task create:

az acr task create \
    --registry $ACR_NAME \
    --name baseexample1 \
    --image helloworld:{{.Run.ID}} \
    --arg REGISTRY_NAME=$ACR_NAME.azurecr.io \
    --context https://github.com/$GIT_USER/acr-build-helloworld-node.git#main \
    --file Dockerfile-app \
    --git-access-token $GIT_PAT

Esta tarefa é semelhante à tarefa criada no tutorial anterior. Ela instrui as Tarefas do ACR para disparar um build de imagem quando as confirmações são enviadas por push para o repositório especificado por --context. Embora o Dockerfile usado para criar a imagem no tutorial anterior especifique uma imagem base pública (FROM node:15-alpine), o Dockerfile nessa tarefa, Dockerfile-app, especifica uma imagem base no mesmo registro:

FROM ${REGISTRY_NAME}/baseimages/node:15-alpine

Essa configuração facilita simular um patch do framework na imagem base, posteriormente no tutorial.

Compilar contêiner de aplicativo

Use o az acr task run para disparar a tarefa manualmente e compilar a imagem do aplicativo. Esta etapa é necessária para que a tarefa acompanhe a dependência da imagem do aplicativo na imagem base.

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

Depois que a tarefa for concluída, anote a ID de execução (por exemplo, “da6”) se você desejar concluir a etapa opcional a seguir.

Opcional: executar contêiner do aplicativo localmente

Se você estiver trabalhando localmente (não no Cloud Shell), e você tiver o Docker instalado, execute o contêiner para ver o aplicativo renderizado em um navegador da web antes de recriar a imagem base. Se você estiver usando o Cloud Shell, ignore esta seção (Cloud Shell não oferece suporte a az acr login ou docker run).

Primeiro, faça a autenticação em seu registro de contêiner com az acr login:

az acr login --name $ACR_NAME

Agora, execute o contêiner localmente com docker run. Substitua <run-id> pela ID de execução encontrada na saída da etapa anterior (por exemplo, “da6”). Este exemplo nomeia o contêiner myapp e inclui o parâmetro --rm para remover o contêiner quando você o interrompe.

docker run -d -p 8080:80 --name myapp --rm $ACR_NAME.azurecr.io/helloworld:<run-id>

Navegue até http://localhost:8080 no seu navegador, e você deverá ver o número de versão do Node.js renderizado na página da web, semelhante à seguinte. Em uma etapa posterior, você deve aumentar a versão adicionando uma "a" para a cadeia de caracteres de versão.

Captura de tela do aplicativo de exemplo no navegador

Para interromper e remover o contêiner, execute o comando a seguir:

docker stop myapp

Listar os builds

Em seguida, liste as execuções de tarefa que as tarefas do ACR concluíram em seu registro usando o comando az acr task list-runs:

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

Se você concluiu o tutorial anterior (e não excluiu o registro), você verá uma saída semelhante à seguinte. Anote o número de execuções de tarefa e a ID de EXECUÇÃO mais recente para que seja possível comparar a saída depois de atualizar a imagem base na próxima seção.

RUN ID    TASK            PLATFORM    STATUS     TRIGGER    STARTED               DURATION
--------  --------------  ----------  ---------  ---------  --------------------  ----------
cax       baseexample1    linux       Succeeded  Manual     2020-11-20T23:33:12Z  00:00:30
caw       taskhelloworld  linux       Succeeded  Commit     2020-11-20T23:16:07Z  00:00:29
cav       example2        linux       Succeeded  Commit     2020-11-20T23:16:07Z  00:00:55
cau       example1        linux       Succeeded  Commit     2020-11-20T23:16:07Z  00:00:40
cat       taskhelloworld  linux       Succeeded  Manual     2020-11-20T23:07:29Z  00:00:27

Atualizar a imagem base

Aqui você pode simular um patch de estrutura na imagem base. Edite Dockerfile-basee adicione um "a" depois do número de versão definido em NODE_VERSION:

ENV NODE_VERSION 15.2.1a

Execute uma tarefa rápida para compilar a imagem base modificada. Anote a ID de execução na saída.

az acr build --registry $ACR_NAME --image baseimages/node:15-alpine --file Dockerfile-base .

Quando o build tiver sido concluído e a tarefa do ACR tiver efetuado push a nova imagem base para o registro, ele disparará um build da imagem do aplicativo. Pode levar alguns instantes para que a tarefa criada anteriormente disparar o build da imagem do aplicativo, porque ela precisa detectar a imagem base recém-compilada e enviada por push.

Listar o build atualizado

Agora que você atualizou a imagem base, liste suas execuções de tarefa novamente para compará-la com a lista anterior. Se a saída não diferir nem primeiro momento, execute periodicamente o comando para ver a nova execução de tarefa aparecer na lista.

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

A saída deverá ser semelhante à seguinte. O GATILHO para o build executado por último será “Atualização da Imagem”, indicando que a tarefa foi iniciada pela sua tarefa rápida da imagem base.

Run ID    TASK            PLATFORM    STATUS     TRIGGER       STARTED               DURATION
--------  --------------  ----------  ---------  ------------  --------------------  ----------
ca11      baseexample1    linux       Succeeded  Image Update  2020-11-20T23:38:24Z  00:00:34
ca10      taskhelloworld  linux       Succeeded  Image Update  2020-11-20T23:38:24Z  00:00:24
cay                       linux       Succeeded  Manual        2020-11-20T23:38:08Z  00:00:22
cax       baseexample1    linux       Succeeded  Manual        2020-11-20T23:33:12Z  00:00:30
caw       taskhelloworld  linux       Succeeded  Commit        2020-11-20T23:16:07Z  00:00:29
cav       example2        linux       Succeeded  Commit        2020-11-20T23:16:07Z  00:00:55
cau       example1        linux       Succeeded  Commit        2020-11-20T23:16:07Z  00:00:40
cat       taskhelloworld  linux       Succeeded  Manual        2020-11-20T23:07:29Z  00:00:27

Caso deseje realizar a etapa opcional a seguir de execução do contêiner recém-criado para ver o número de versão atualizado, anote o valor da ID DE EXECUÇÃO do build disparado pela Atualização da Imagem (na saída anterior, ela é "ca11").

Opcional: executar imagem criada recentemente

Se você estiver trabalhando localmente (não no Cloud Shell), e tiver o Docker instalado, execute a nova imagem de aplicativo após a conclusão da sua compilação. Substitua <run-id> pela ID de EXECUÇÃO obtida na etapa anterior. Se você estiver usando o Cloud Shell, ignore esta seção (Cloud Shell não oferece suporte a docker run).

docker run -d -p 8081:80 --name updatedapp --rm $ACR_NAME.azurecr.io/helloworld:<run-id>

Navegue até http://localhost:8081 no seu navegador, e você deverá ver o número de versão do Node.js atualizado (com o “a”) na página da web:

Captura de tela do aplicativo de exemplo atualizado no navegador

O que é importante a observar é que você atualizou sua imagem base com um novo número de versão, mas a última imagem de aplicativo compilada exibe a nova versão. As Tarefas do ACR obtiveram sua alteração da imagem base e recriaram sua imagem de aplicativo automaticamente.