Nota
O acesso a esta página requer autorização. Pode tentar iniciar sessão ou alterar os diretórios.
O acesso a esta página requer autorização. Pode tentar alterar os diretórios.
O ACR Tasks suporta compilações de imagem automatizadas quando a imagem base de um contêiner é atualizada, como quando você corrige o sistema operacional ou a estrutura do aplicativo em uma de suas imagens base.
Neste tutorial, você aprenderá a criar uma tarefa ACR que aciona uma compilação na nuvem quando a imagem base de um contêiner é enviada por push para outro registro de contêiner do Azure. Você também pode experimentar um tutorial para criar uma tarefa ACR que inicie a criação de uma imagem quando uma imagem base é carregada no mesmo registo do Azure Container.
Neste tutorial:
- Construir a imagem base em um registro base
- Criar uma tarefa de compilação de aplicativo em outro registro para controlar a imagem base
- Atualizar a imagem de base para acionar uma tarefa de imagem 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 você já configurou seu ambiente e concluiu as etapas 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 prosseguir:
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
Além do registro de contêiner criado para os tutoriais anteriores, você precisa criar um registro para armazenar as imagens base. Se desejar, crie o segundo registro em um local diferente do registro original.
Configurar o ambiente
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 você não preencher essas variáveis de ambiente, deverá substituir manualmente cada valor onde quer que ele apareça nos comandos de exemplo.
BASE_ACR=<base-registry-name> # The name of your Azure container registry for base images
ACR_NAME=<registry-name> # The name of your Azure container registry for application images
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 da imagem de base. Esse cenário reflete um fluxo de trabalho de desenvolvimento para gerenciar imagens de base em um registro de contêiner comum e privado ao criar imagens de aplicativo em outros registros. As imagens base podem especificar sistemas operacionais e estruturas comuns usados por uma equipe, ou até mesmo componentes de serviço comuns.
Por exemplo, os desenvolvedores que desenvolvem imagens de aplicativos em seus próprios registros podem acessar um conjunto de imagens base mantidas no registro base comum. O registro base pode estar em outra região ou até mesmo replicado geograficamente.
O exemplo de código inclui dois Dockerfiles: uma imagem da aplicação e uma imagem que é especificada como a sua base. Nas seções a seguir, você cria uma tarefa ACR que aciona automaticamente uma compilação da imagem do aplicativo quando uma nova versão da imagem base é enviada por push para um registro de contêiner do Azure diferente.
Dockerfile-app: uma pequena aplicação web Node.js que renderiza uma página web estática, mostrando a versão do Node.js em que 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-appespecifica como a sua base. Ela própria baseia-se numa imagem de Node e inclui a variável de ambienteNODE_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 do contentor da aplicação localmente para ver as diferentes versões nas imagens geradas.
Neste tutorial, sua tarefa ACR cria e envia por push uma imagem de contêiner de aplicativo especificada em um Dockerfile. As Tarefas ACR também podem executar tarefas de várias etapas, usando um arquivo YAML para definir etapas para criar, enviar por push e, opcionalmente, testar vários contêineres.
Compilar a imagem de base
Comece por construir a imagem base com uma tarefa rápida de ACR Tasks, usando 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. Neste exemplo, a imagem é enviada para o repositório de imagens base.
az acr build --registry $BASE_ACR --image baseimages/node:15-alpine --file Dockerfile-base .
Criar uma tarefa para monitorar a imagem base privada
Em seguida, crie uma tarefa no registro de imagem do aplicativo com az acr task create, habilitando uma identidade gerenciada. A identidade gerenciada é usada em etapas posteriores para que a tarefa seja autenticada com o registro de imagem base.
Este exemplo usa uma identidade atribuída ao sistema, mas você pode criar e habilitar uma identidade gerenciada atribuída pelo usuário para determinados cenários. Para obter detalhes, consulte Autenticação entre registros em uma tarefa ACR usando uma identidade gerenciada pelo Azure.
az acr task create \
--registry $ACR_NAME \
--name baseexample2 \
--image helloworld:{{.Run.ID}} \
--context https://github.com/$GIT_USER/acr-build-helloworld-node.git#main \
--file Dockerfile-app \
--git-access-token $GIT_PAT \
--arg REGISTRY_NAME=$BASE_ACR.azurecr.io \
--assign-identity
Esta tarefa é semelhante à tarefa criada no tutorial anterior. Dá instruções ao ACR Tasks para acionar um build da imagem quando os commits são enviados por push para o repositório especificado por --context. Enquanto o Dockerfile usado para criar a imagem no tutorial anterior especifica uma imagem base pública (FROM node:15-alpine), o Dockerfile nesta tarefa, Dockerfile-app, especifica uma imagem base no registro da imagem base:
FROM ${REGISTRY_NAME}/baseimages/node:15-alpine
Essa configuração facilita a simulação de um patch de estrutura na imagem base mais adiante neste tutorial.
Conceder permissões de pull de identidade ao repositório base
Para conceder permissões de identidade gerenciada da tarefa para extrair imagens do registro de imagem base, primeiro execute az acr task show para obter o ID da entidade de serviço da identidade. Em seguida, execute az acr show para obter o ID do recurso do registro base:
# Get service principal ID of the task
principalID=$(az acr task show --name baseexample2 --registry $ACR_NAME --query identity.principalId --output tsv)
# Get resource ID of the base registry
baseregID=$(az acr show --name $BASE_ACR --query id --output tsv)
Atribua as permissões de pull de identidade gerenciada ao registro executando az role assignment create. A função correta a ser usada na atribuição de função depende se o registro está habilitado para ABAC ou não.
ROLE="Container Registry Repository Reader" # For ABAC-enabled registries. For non-ABAC registries, use AcrPull.
az role assignment create \
--assignee $principalID \
--scope $baseregID --role "$ROLE"
Adicionar credenciais do registo de destino na tarefa
Execute az acr task credential add para adicionar credenciais à tarefa. Passe o --use-identity [system] parâmetro para indicar que a identidade gerenciada atribuída ao sistema da tarefa pode acessar as credenciais.
az acr task credential add \
--name baseexample2 \
--registry $ACR_NAME \
--login-server $BASE_ACR.azurecr.io \
--use-identity [system]
Executar manualmente a tarefa
Use az acr task run para acionar manualmente a tarefa e criar a imagem do aplicativo. Esta etapa é necessária para que a tarefa rastreie a dependência da imagem do aplicativo na imagem base.
az acr task run --registry $ACR_NAME --name baseexample2
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).
Primeiro, autentique-se em seu registro de contêiner com az acr login:
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 nomeia o contêiner myapp e inclui o --rm parâmetro para removê-lo quando você o para.
docker run -d -p 8080:80 --name myapp --rm $ACR_NAME.azurecr.io/helloworld:<run-id>
Navegue para http://localhost:8080 no seu navegador, e deverá ver o número de versão do Node.js apresentado na página web, semelhante ao que segue. Num passo posterior, pode aumentar a versão ao adicionar um "a" à cadeia de versão.
Para parar e remover o contêiner, 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.
az acr task list-runs --registry $ACR_NAME --output table
UN ID TASK PLATFORM STATUS TRIGGER STARTED DURATION
-------- -------------- ---------- --------- ------------ -------------------- ----------
ca12 baseexample2 linux Succeeded Manual 2020-11-21T00:00:56Z 00:00:36
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
Atualizar a imagem de base
Nesta secção, irá simular uma correção do framework 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 na saída.
az acr build --registry $BASE_ACR --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 "Atualização da Imagem", indicando que a tarefa foi iniciada pela execução rápida da imagem de base.
az acr task list-runs --registry $ACR_NAME --output table
PLATFORM STATUS TRIGGER STARTED DURATION
-------- -------------- ---------- --------- ------------ -------------------- ----------
ca13 baseexample2 linux Succeeded Image Update 2020-11-21T00:06:00Z 00:00:43
ca12 baseexample2 linux Succeeded Manual 2020-11-21T00:00:56Z 00:00:36
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
Se você quiser executar a seguinte etapa opcional de executar o contêiner recém-criado para ver o número da versão atualizada, anote o valor RUN ID para a compilação acionada pela Atualização de Imagem (na saída anterior, é "ca13").
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 na etapa 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:
O que é importante ter em atenção é que atualizou a sua imagem de base com um novo número de versão, mas a imagem de aplicação da última compilação já apresenta essa nova versão. ACR Tasks detetou a alteração na imagem de base e reconstruiu automaticamente a imagem da aplicação.
Para parar e remover o contêiner, execute o seguinte comando:
docker stop updatedapp
Próximos passos
Neste tutorial, aprendeu a utilizar uma tarefa para desencadear automaticamente construções da imagem de contentor quando a imagem base for atualizada. Agora, passe para o próximo tutorial para aprender a acionar tarefas em um cronograma definido.