Tutorial: Automatizar compilações de imagens de contentor quando uma imagem de base é atualizada num registo de contentor do Azure

Artigo
10/31/2023

As Tarefas do ACR suportam compilações de imagens de contentor automatizadas quando a imagem de base de um contentor é atualizada, como quando corrigir o SO ou a arquitetura da aplicação numa das suas imagens base.

Neste tutorial, vai aprender a criar uma tarefa do ACR que aciona uma compilação na cloud quando a imagem base de um contentor é enviada para o mesmo registo. Também pode experimentar um tutorial para criar uma tarefa do ACR que aciona uma compilação de imagens quando uma imagem de base é enviada para outro registo de contentor do Azure.

Neste tutorial:

Compilar a imagem de base
Criar uma imagem de aplicação no mesmo registo para controlar a imagem de base
Atualizar a imagem de base para acionar uma tarefa das imagens da aplicação
Apresentar a tarefa acionada
Verificar a imagem da aplicação atualizada

Pré-requisitos

Concluir os tutoriais anteriores

Este tutorial pressupõe que já configurou o seu ambiente e concluiu os passos nos dois primeiros tutoriais da série, nos quais:

Criar um registo de contentor do Azure
Bifurcar um repositório de exemplo
Clonar um repositório de exemplo
Criar token de acesso pessoal do GitHub

Se ainda não o fez, conclua os seguintes tutoriais antes de continuar:

Compilar imagens de contentor na cloud com o Azure Container Registry Tasks

Automatizar as compilações da imagem de contentor com o Azure Container Registry Tasks

Configurar o ambiente

Utilize o ambiente bash no Azure Cloud Shell. Para obter mais informações, veja Início Rápido do Bash no Azure Cloud Shell.
Se preferir executar comandos de referência da CLI localmente, instale a CLI do Azure. Se estiver a utilizar o Windows ou macOS, considere executar a CLI do Azure num contentor Docker. Para obter mais informações, veja Como executar a CLI do Azure num contentor do Docker.
- Se estiver a utilizar uma instalação local, inicie sessão no CLI do Azure ao utilizar o comando az login. Para concluir o processo de autenticação, siga os passos apresentados no seu terminal. Para outras opções de início de sessão, veja Iniciar sessão com a CLI do Azure.
- Quando lhe for pedido, instale a extensão da CLI do Azure na primeira utilização. Para obter mais informações sobre as extensões, veja Utilizar extensões com o CLI do Azure.
- Execute o comando az version para localizar a versão e as bibliotecas dependentes instaladas. Para atualizar para a versão mais recente, execute o comando az upgrade.

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

Preencha estas variáveis de ambiente da shell com os valores adequados para o seu ambiente. Este passo não é estritamente necessário, mas facilita um pouco a execução dos comandos da CLI do Azure com várias linhas neste tutorial. Se não preencher estas variáveis de ambiente, tem de substituir manualmente cada valor onde quer que apareça 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 da imagem de base

Este tutorial orienta-o através de um cenário de atualização de imagem base no qual uma imagem de base e uma imagem de aplicação são mantidas num único registo.

O exemplo de código inclui dois Dockerfiles: uma imagem da aplicação e uma imagem que é especificada como a sua base. Nas secções seguintes, vai criar uma tarefa do ACR que aciona automaticamente uma compilação da imagem da aplicação quando uma nova versão da imagem de base é enviada para o mesmo registo de contentor.

Dockerfile-app: uma pequena aplicação Web Node.js que compõe uma página Web estática, que apresenta a versão do Node.js na qual se baseia. A cadeia de versão é simulada: apresenta o conteúdo de uma variável de ambiente, NODE_VERSION, definido na imagem de base.
Dockerfile-base: a imagem que Dockerfile-app especifica como a sua base. A própria baseia-se numa imagem do Nó e inclui a variável de ambiente NODE_VERSION.

Nas próximas secções, vai criar uma tarefa, atualizar o valor NODE_VERSION no Dockerfile da imagem de base e, em seguida, utilizar o ACR Tasks para compilar a imagem de base. Quando a tarefa do ACR envia a nova imagem de base para o registo, aciona automaticamente uma compilação da imagem da aplicação. Opcionalmente, pode executar a imagem de contentor da aplicação localmente para ver as diferentes cadeias de versão nas imagens da compilação.

Neste tutorial, a sua tarefa do ACR cria e envia uma imagem de contentor de aplicação especificada num Dockerfile. As Tarefas do ACR também podem executar tarefas de vários passos, utilizando um ficheiro YAML para definir passos para criar, emitir e testar opcionalmente vários contentores.

Compilar a imagem de base

Comece por criar a imagem base com uma tarefa rápida tarefas do ACR Tasks, com az acr build. Tal como explicado no primeiro tutorial da série, este processo não só compila a imagem como a envia para o seu registo de contentor, caso a compilação seja concluída com êxito.

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

Criar 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. Dá instruções ao ACR Tasks para acionar uma compilação da imagem quando as consolidações são enviadas por push para o repositório especificado por --context. Enquanto o Dockerfile utilizado para criar a imagem no tutorial anterior especifica uma imagem de base pública (FROM node:15-alpine), o Dockerfile nesta tarefa, Dockerfile-app, especifica uma imagem base no mesmo registo:

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

Esta configuração facilita a simulação de um patch de arquitetura na imagem de base mais à frente neste tutorial.

Compilar o contentor de aplicação

Utilize az acr task run para acionar manualmente a tarefa e criar a imagem da aplicação. Este passo é necessário para que a tarefa acompanhe a dependência da imagem da aplicação na imagem de base.

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

Depois de concluída a tarefa, tome nota do ID de Execução (por exemplo, "da6") se quiser concluir o passo opcional seguinte.

Opcional: executar o contentor da aplicação localmente

Se estiver a trabalhar localmente (não estiver no Cloud Shell) e tiver o Docker instalado, execute o contentor para ver a aplicação composta num browser, antes de recompilar a imagem de base. Se estiver a utilizar o Cloud Shell, ignore esta secção (o Cloud Shell não suporta az acr login nem docker run).

Em primeiro lugar, autentique-se no seu registo de contentor com o início de sessão az acr:

az acr login --name $ACR_NAME

Agora, execute o contentor localmente com docker run. Substitua <run-id> pelo ID de Execução encontrado no resultado do passo anterior (por exemplo, "da6"). Este exemplo dá um nome ao contentor myapp e inclui o --rm parâmetro para remover o contentor quando o parar.

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

Navegue para http://localhost:8080 no browser, deverá ver o número de versão do Node.js composto na página Web, semelhante ao que se segue. Num passo posterior, pode efetuar o bump da versão ao adicionar um “a” na cadeia de versão.

Captura de ecrã da aplicação de exemplo no browser

Para parar e remover o contentor, execute o seguinte comando:

docker stop myapp

Listar as compilações

Em seguida, liste as execuções de tarefas que o ACR Tasks concluiu para o seu registo com o comando az acr task list-runs:

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

Se tiver concluído o tutorial anterior (e não tiver eliminado o registo), deverá ver um resultado semelhante ao seguinte. Tome nota do número de execuções da tarefa e do ID DE EXECUÇÃO mais recente para poder comparar o resultado depois de atualizar a imagem de base na próxima secçã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 de base

Nesta secção, vai simular uma correção da estrutura na imagem de base. Edite Dockerfile-base e 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 de base modificada. Tome nota do ID de Execução no resultado.

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

Depois de concluída a compilação e a nova imagem de base ter sido enviada para o registo, a tarefa do ACR aciona uma compilação da imagem da aplicação. Pode demorar algum tempo para que a tarefa criada anteriormente acione a compilação da imagem da aplicação, porque tem de detetar a imagem de base recentemente compilada e enviada.

Listar a compilação atualizada

Agora que atualizou a imagem de base, liste as execuções de tarefas novamente para compará-las à lista anterior. Se, à primeira, o resultado não for diferente, 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

O resultado é semelhante ao seguinte. O ACIONADOR da última compilação executada deve ser "Atualizar Imagem", que indica que a tarefa foi iniciada pela tarefa rápida da imagem de 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

Se quiser executar o seguinte passo opcional de execução do contentor recém-criado para ver o número da versão atualizada, tome nota do valor RUN ID da compilação acionada pela Atualização de Imagens (na saída anterior, é "ca11").

Opcional: executar a imagem recém-compilada

Se estiver a trabalhar localmente (não estiver no Cloud Shell) e tiver o Docker instalado, execute a nova imagem da aplicação depois de concluída a sua compilação. Substitua <run-id> pelo ID DE EXECUÇÃO que obteve no passo anterior. Se estiver a utilizar o Cloud Shell, ignore esta secção (o Cloud Shell não suporta docker run).

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

Navegue para http://localhost:8081 no browser, deverá ver o número de versão do Node.js atualizado (com o “a”) na página Web:

Captura de ecrã da aplicação de exemplo atualizada no browser

O que é importante ter em atenção é que atualizou a imagem de base com um novo número de versão, mas a imagem da aplicação da última compilação apresenta a nova versão. O ACR Tasks captou a alteração para a imagem de base e recompilou automaticamente a imagem da aplicação.