Como consumir e manter conteúdo público com Tarefas do Registro de Contêiner do Azure

Artigo
10/16/2024

Este artigo fornece um fluxo de trabalho de exemplo no Registro de Contêiner do Azure para ajudar a gerenciar o consumo e a manutenção de conteúdo público:

Importe cópias locais de imagens públicas dependentes.
Valide imagens públicas por meio de verificação de segurança e teste funcional.
Promova as imagens para registros privados de uso interno.
Dispare atualizações de imagem base para aplicativos dependentes de conteúdo público.
Use as Tarefas do Registro de Contêiner do Azure para automatizar esse fluxo de trabalho.

O fluxo de trabalho está resumido na imagem a seguir:

Fluxo de trabalho de consumo de conteúdo público

O fluxo de trabalho de importação restrito ajuda a gerenciar as dependências de sua organização em artefatos gerenciados externamente, como por exemplo, imagens originadas de registros públicos, incluindo o Docker Hub, GCR, Quay, Registro de Contêiner do GitHub, Microsoft Container Registry, ou até mesmo outros registros de contêiner do Azure.

Para obter informações sobre os riscos introduzidos por dependências de conteúdo público e como usar o Registro de Contêiner do Azure para mitigá-los, consulte a postagem no Blog de Conteúdo Público de Consumo OCI e Gerenciar conteúdo público com o Registro de Contêiner do Azure.

Você pode usar o Azure Cloud Shell ou uma instalação local da CLI do Azure para concluir esta explicação passo a passo. A CLI do Azure versão 2.10 ou posterior é recomendada. Se você precisa instalar ou atualizar, consulte Instalar a CLI do Azure.

Visão geral do cenário

importar componentes do fluxo de trabalho

Esta explicação passo a passo configura:

Três registros de contêiner, representando:
- Um Hub do Docker Hub simulado (publicregistry) para dar suporte à alteração da imagem base
- Registro de equipe (contoso) para compartilhar imagens privadas
- Registro compartilhado da empresa/equipe (baseartifacts) para conteúdo público importado
Uma tarefa ACR em cada registro. As tarefas:
1. Compilar uma imagem pública simulada node
2. Importar e validar a imagem node para o registro compartilhado da empresa/equipe
3. Compilar e implantar a imagem hello-world
Definições da tarefa ACR, incluindo configurações para:
- Uma coleção de credenciais de registro, que são ponteiros para um cofre de chaves
- Uma coleção de segredos, disponível em um acr-task.yaml, que são ponteiros para um cofre de chaves
- Uma coleção de valores configurados usados em um acr-task.yaml
Um cofre de chaves do Azure para proteger todos os segredos
Uma instância de contêiner do Azure, que hospeda o aplicativo de compilação hello-world

Pré-requisitos

As etapas a seguir configuram os valores para os recursos criados e usados na explicação passo a passo.

Definir variáveis de ambiente

Configure variáveis exclusivas para seu ambiente. Seguimos as melhores práticas para colocar recursos com conteúdo durável em seu próprio grupo de recursos para minimizar a exclusão acidental. No entanto, você pode colocar essas variáveis em apenas um grupo de recursos, se quiser.

Os exemplos neste artigo são formatados para o shell do bash.

# Set the three registry names, must be globally unique:
REGISTRY_PUBLIC=publicregistry
REGISTRY_BASE_ARTIFACTS=contosobaseartifacts
REGISTRY=contoso

# set the location all resources will be created in:
RESOURCE_GROUP_LOCATION=eastus

# default resource groups
REGISTRY_PUBLIC_RG=${REGISTRY_PUBLIC}-rg
REGISTRY_BASE_ARTIFACTS_RG=${REGISTRY_BASE_ARTIFACTS}-rg
REGISTRY_RG=${REGISTRY}-rg

# fully qualified registry urls
REGISTRY_DOCKERHUB_URL=docker.io
REGISTRY_PUBLIC_URL=${REGISTRY_PUBLIC}.azurecr.io
REGISTRY_BASE_ARTIFACTS_URL=${REGISTRY_BASE_ARTIFACTS}.azurecr.io
REGISTRY_URL=${REGISTRY}.azurecr.io

# Azure key vault for storing secrets, name must be globally unique
AKV=acr-task-credentials
AKV_RG=${AKV}-rg

# ACI for hosting the deployed application
ACI=hello-world-aci
ACI_RG=${ACI}-rg

Repositórios Git e tokens

Para simular seu ambiente, crie um fork de cada um dos repositórios Git a seguir em repositórios que você pode gerenciar.

Em seguida, atualize as variáveis a seguir para os repositórios bifurcados.

A :main acrescentada ao final das URLs do Git representa o branch do repositório padrão.

GIT_BASE_IMAGE_NODE=https://github.com/<your-fork>/base-image-node.git#main
GIT_NODE_IMPORT=https://github.com/<your-fork>/import-baseimage-node.git#main
GIT_HELLO_WORLD=https://github.com/<your-fork>/hello-world.git#main

Você precisa de um token de acesso do GitHub (PAT) para Tarefas do ACR para clonar e estabelecer webhooks Git. Para conhecer as etapas para criar um token com as permissões necessárias para um repositório privado, consulte Criar um token de acesso do GitHub.

GIT_TOKEN=<set-git-token-here>

Credenciais do Docker Hub

Para evitar a limitação e solicitações de identidade ao extrair imagens do Docker Hub, crie um token do Docker Hub. Em seguida, defina as variáveis de ambiente a seguir:

REGISTRY_DOCKERHUB_USER=<yourusername>
REGISTRY_DOCKERHUB_PASSWORD=<yourtoken>

Criar registros

Usando comandos da CLI do Azure, crie três registros de contêiner de camada Premium, cada qual em seu próprio grupo de recursos:

az group create --name $REGISTRY_PUBLIC_RG --location $RESOURCE_GROUP_LOCATION
az acr create --resource-group $REGISTRY_PUBLIC_RG --name $REGISTRY_PUBLIC --sku Premium

az group create --name $REGISTRY_BASE_ARTIFACTS_RG --location $RESOURCE_GROUP_LOCATION
az acr create --resource-group $REGISTRY_BASE_ARTIFACTS_RG --name $REGISTRY_BASE_ARTIFACTS --sku Premium

az group create --name $REGISTRY_RG --location $RESOURCE_GROUP_LOCATION
az acr create --resource-group $REGISTRY_RG --name $REGISTRY --sku Premium

Criar um cofre de chaves e definir segredos

Crie um cofre de chaves:

az group create --name $AKV_RG --location $RESOURCE_GROUP_LOCATION
az keyvault create --resource-group $AKV_RG --name $AKV

Defina o nome de usuário e o token do Docker Hub no cofre de chaves:

az keyvault secret set \
--vault-name $AKV \
--name registry-dockerhub-user \
--value $REGISTRY_DOCKERHUB_USER

az keyvault secret set \
--vault-name $AKV \
--name registry-dockerhub-password \
--value $REGISTRY_DOCKERHUB_PASSWORD

Defina e verifique um Git PAT no cofre de chaves:

az keyvault secret set --vault-name $AKV --name github-token --value $GIT_TOKEN

az keyvault secret show --vault-name $AKV --name github-token --query value -o tsv

Criar grupo de recursos para uma instância de contêiner do Azure

Esse grupo de recursos é usado em uma tarefa posterior ao implantar a imagem hello-world.

az group create --name $ACI_RG --location $RESOURCE_GROUP_LOCATION

Criar imagem base pública `node`

Para simular a imagem node no Docker Hub, crie uma tarefa ACR para compilar e manter a imagem pública. Essa configuração permite simular alterações feitas pelos mantenedores da imagem node.

az acr task create \
  --name node-public \
  -r $REGISTRY_PUBLIC \
  -f acr-task.yaml \
  --context $GIT_BASE_IMAGE_NODE \
  --git-access-token $(az keyvault secret show \
                        --vault-name $AKV \
                        --name github-token \
                        --query value -o tsv) \
  --set REGISTRY_FROM_URL=${REGISTRY_DOCKERHUB_URL}/ \
  --assign-identity

Para evitar a limitação do Docker Hub, adicione as credenciais do Docker Hub à tarefa. O comando acr task credentials pode ser usado para passar as credenciais do Docker para qualquer registro, incluindo o Docker Hub.

az acr task credential add \
  -n node-public \
  -r $REGISTRY_PUBLIC \
  --login-server $REGISTRY_DOCKERHUB_URL \
  -u https://${AKV}.vault.azure.net/secrets/registry-dockerhub-user \
  -p https://${AKV}.vault.azure.net/secrets/registry-dockerhub-password \
  --use-identity [system]

Conceda à tarefa acesso para ler valores do cofre de chaves:

az keyvault set-policy \
  --name $AKV \
  --resource-group $AKV_RG \
  --object-id $(az acr task show \
                  --name node-public \
                  --registry $REGISTRY_PUBLIC \
                  --query identity.principalId --output tsv) \
  --secret-permissions get

Tarefas podem ser disparadas por confirmações Git, atualizações de imagem base, temporizadores ou execuções manuais.

Execute a tarefa manualmente para gerar a imagem node:

az acr task run -r $REGISTRY_PUBLIC -n node-public

Liste a imagem no registro público simulado:

az acr repository show-tags -n $REGISTRY_PUBLIC --repository node

Criar a imagem `hello-world`

Com base na imagem pública simulada node, compile uma imagem hello-world.

Criar token para efetuar pull de acesso ao registro público simulado

Crie um token de acesso para o registro público simulado, com escopo para pull. Em seguida, defina-o no cofre de chaves:

az keyvault secret set \
  --vault-name $AKV \
  --name "registry-${REGISTRY_PUBLIC}-user" \
  --value "registry-${REGISTRY_PUBLIC}-user"

az keyvault secret set \
  --vault-name $AKV \
  --name "registry-${REGISTRY_PUBLIC}-password" \
  --value $(az acr token create \
              --name "registry-${REGISTRY_PUBLIC}-user" \
              --registry $REGISTRY_PUBLIC \
              --scope-map _repositories_pull \
              -o tsv \
              --query credentials.passwords[0].value)

Criar token para efetuar pull de acesso por Instâncias de Contêiner do Azure

Crie um token de acesso para o registro que hospeda a imagem hello-world, com escopo para efetuar pull. Em seguida, defina-o no cofre de chaves:

az keyvault secret set \
  --vault-name $AKV \
  --name "registry-${REGISTRY}-user" \
  --value "registry-${REGISTRY}-user"

az keyvault secret set \
  --vault-name $AKV \
  --name "registry-${REGISTRY}-password" \
  --value $(az acr token create \
              --name "registry-${REGISTRY}-user" \
              --registry $REGISTRY \
              --repository hello-world content/read \
              -o tsv \
              --query credentials.passwords[0].value)

Criar tarefa para criar e manter a imagem `hello-world`

O comando a seguir cria uma tarefa da definição em acr-tasks.yaml no hello-world repositório. As etapas da tarefa compilam a imagem hello-world e depois a implantam em Instâncias de Contêiner do Azure. O grupo de recursos para Instâncias de Contêiner do Azure foi criado em uma seção anterior. Ao chamar az container create na tarefa com apenas uma diferença no image:tag, a tarefa é implantada na mesma instância em toda esta explicação passo a passo.

az acr task create \
  -n hello-world \
  -r $REGISTRY \
  -f acr-task.yaml \
  --context $GIT_HELLO_WORLD \
  --git-access-token $(az keyvault secret show \
                        --vault-name $AKV \
                        --name github-token \
                        --query value -o tsv) \
  --set REGISTRY_FROM_URL=${REGISTRY_PUBLIC_URL}/ \
  --set KEYVAULT=$AKV \
  --set ACI=$ACI \
  --set ACI_RG=$ACI_RG \
  --assign-identity

Adicione credenciais à tarefa para o registro público simulado:

az acr task credential add \
  -n hello-world \
  -r $REGISTRY \
  --login-server $REGISTRY_PUBLIC_URL \
  -u https://${AKV}.vault.azure.net/secrets/registry-${REGISTRY_PUBLIC}-user \
  -p https://${AKV}.vault.azure.net/secrets/registry-${REGISTRY_PUBLIC}-password \
  --use-identity [system]

Conceda à tarefa acesso para ler valores do cofre de chaves:

az keyvault set-policy \
  --name $AKV \
  --resource-group $AKV_RG \
  --object-id $(az acr task show \
                  --name hello-world \
                  --registry $REGISTRY \
                  --query identity.principalId --output tsv) \
  --secret-permissions get

Conceda à tarefa acesso para criar e gerenciar Instâncias de Contêiner do Azure concedendo acesso ao grupo de recursos:

az role assignment create \
  --assignee $(az acr task show \
  --name hello-world \
  --registry $REGISTRY \
  --query identity.principalId --output tsv) \
  --scope $(az group show -n $ACI_RG --query id -o tsv) \
  --role owner

Com a tarefa criada e configurada, execute a tarefa para criar e implantar a imagem hello-world:

az acr task run -r $REGISTRY -n hello-world

Depois de criada, obtenha o endereço IP do contêiner que hospeda a imagem hello-world.

az container show \
  --resource-group $ACI_RG \
  --name ${ACI} \
  --query ipAddress.ip \
  --out tsv

No navegador, vá até o endereço IP para ver o aplicativo em execução.

Atualizar a imagem base com uma alteração "questionável"

Esta seção simula uma alteração na imagem base que pode causar problemas no ambiente.

Abra Dockerfile no repositório bifurcado base-image-node.
Altere BACKGROUND_COLOR para Orange para simular a alteração.

ARG REGISTRY_NAME=
FROM ${REGISTRY_NAME}node:15-alpine
ENV NODE_VERSION 15-alpine
ENV BACKGROUND_COLOR Orange

Confirme a alteração e observe as Tarefas do ACR para iniciar a compilação automaticamente.

Observe a tarefa para iniciar a execução:

watch -n1 az acr task list-runs -r $REGISTRY_PUBLIC -o table

Eventualmente, você deve ver o STATUS Succeeded com base em um TRIGGER de Commit:

RUN ID    TASK      PLATFORM    STATUS     TRIGGER    STARTED               DURATION
--------  --------  ----------  ---------  ---------  --------------------  ----------
ca4       hub-node  linux       Succeeded  Commit     2020-10-24T05:02:29Z  00:00:22

Digite Ctrl+C para sair do comando watch e, em seguida, exiba os logs para a execução mais recente:

az acr task logs -r $REGISTRY_PUBLIC

Depois que a imagem node for concluída, watch para Tarefas do ACR iniciarem automaticamente a compilação da imagem hello-world:

watch -n1 az acr task list-runs -r $REGISTRY -o table

Eventualmente, você deve ver o STATUS Succeeded com base em um TRIGGER de Image Update:

RUN ID    TASK         PLATFORM    STATUS     TRIGGER       STARTED               DURATION
--------  -----------  ----------  ---------  ------------  --------------------  ----------
dau       hello-world  linux       Succeeded  Image Update  2020-10-24T05:08:45Z  00:00:31

Digite Ctrl+C para sair do comando watch e, em seguida, exiba os logs para a execução mais recente:

az acr task logs -r $REGISTRY

Depois de concluído, obtenha o endereço IP do site que hospeda a imagem hello-world atualizada:

az container show \
  --resource-group $ACI_RG \
  --name ${ACI} \
  --query ipAddress.ip \
  --out tsv

No navegador, vá para o site, que deve ter uma tela de fundo laranja (questionável).

Fazer check-in

Neste ponto, você criou uma imagem hello-world que é compilada automaticamente em commits Git e é alterada para a imagem base node. Neste exemplo, a tarefa é compilada em uma imagem base no Registro de Contêiner do Azure, mas qualquer registro com suporte pode ser usado.

A atualização da imagem de base aciona automaticamente a execução da tarefa quando a imagem node é atualizada. Como visto aqui, nem todas as atualizações são desejadas.

Importações restritas de conteúdo público

Para prevenir que alterações de upstream interrompam cargas de trabalho críticas, a verificação de segurança e os testes funcionais podem ser adicionados.

Nesta seção, você cria uma tarefa ACR para:

Compilar uma imagem de teste
Executar um script de teste funcional ./test.sh na imagem de teste
Se a imagem for testada com êxito, importe a imagem pública para o registro baseimages

Adicionar testes de automação

Para restringir qualquer conteúdo de upstream, o teste automatizado é implementado. Neste exemplo, o test.sh é fornecido, o qual verifica o $BACKGROUND_COLOR. Se o teste falhar, um EXIT_CODE de 1 será retornado, o que faz com que a etapa da tarefa ACR falhe, encerrando a execução da tarefa. Os testes podem ser expandidos em qualquer forma de ferramentas, incluindo os resultados de registro em log. A portão é gerenciado por uma resposta de aprovação/reprovação no script, reproduzida aqui:

if [ ""$(echo $BACKGROUND_COLOR | tr '[:lower:]' '[:upper:]') = 'RED' ]; then
    echo -e "\e[31mERROR: Invalid Color:\e[0m" ${BACKGROUND_COLOR}
    EXIT_CODE=1
else
  echo -e "\e[32mValidation Complete - No Known Errors\e[0m"
fi
exit ${EXIT_CODE}

YAML da tarefa

Examine o acr-task.yaml no repositório import-baseimage-node, que executa as seguintes etapas:

Crie a imagem base de teste usando o Dockerfile a seguir:

ARG REGISTRY_FROM_URL=
FROM ${REGISTRY_FROM_URL}node:15-alpine
WORKDIR /test
COPY ./test.sh .
CMD ./test.sh

Quando concluído, valide a imagem executando o contêiner, que executa ./test.sh
Somente se for concluído com êxito, execute as etapas de importação, que são restringidas com when: ['validate-base-image']

version: v1.1.0
steps:
  - id: build-test-base-image
    # Build off the base image we'll track
    # Add a test script to do unit test validations
    # Note: the test validation image isn't saved to the registry
    # but the task logs captures log validation results
    build: >
      --build-arg REGISTRY_FROM_URL={{.Values.REGISTRY_FROM_URL}}
      -f ./Dockerfile
      -t {{.Run.Registry}}/node-import:test
      .
  - id: validate-base-image
    # only continues if node-import:test returns a non-zero code
    when: ['build-test-base-image']
    cmd: "{{.Run.Registry}}/node-import:test"
  - id: pull-base-image
    # import the public image to base-artifacts
    # Override the stable tag,
    # and create a unique tag to enable rollback
    # to a previously working image
    when: ['validate-base-image']
    cmd: >
        docker pull {{.Values.REGISTRY_FROM_URL}}node:15-alpine
  - id: retag-base-image
    when: ['pull-base-image']
    cmd: docker tag {{.Values.REGISTRY_FROM_URL}}node:15-alpine {{.Run.Registry}}/node:15-alpine
  - id: retag-base-image-unique-tag
    when: ['pull-base-image']
    cmd: docker tag {{.Values.REGISTRY_FROM_URL}}node:15-alpine {{.Run.Registry}}/node:15-alpine-{{.Run.ID}}
  - id: push-base-image
    when: ['retag-base-image', 'retag-base-image-unique-tag']
    push:
    - "{{.Run.Registry}}/node:15-alpine"
    - "{{.Run.Registry}}/node:15-alpine-{{.Run.ID}}"

Criar tarefa para importar e testar a imagem base

  az acr task create \
  --name base-import-node \
  -f acr-task.yaml \
  -r $REGISTRY_BASE_ARTIFACTS \
  --context $GIT_NODE_IMPORT \
  --git-access-token $(az keyvault secret show \
                        --vault-name $AKV \
                        --name github-token \
                        --query value -o tsv) \
  --set REGISTRY_FROM_URL=${REGISTRY_PUBLIC_URL}/ \
  --assign-identity

Adicione credenciais à tarefa para o registro público simulado:

az acr task credential add \
  -n base-import-node \
  -r $REGISTRY_BASE_ARTIFACTS \
  --login-server $REGISTRY_PUBLIC_URL \
  -u https://${AKV}.vault.azure.net/secrets/registry-${REGISTRY_PUBLIC}-user \
  -p https://${AKV}.vault.azure.net/secrets/registry-${REGISTRY_PUBLIC}-password \
  --use-identity [system]

Conceda à tarefa acesso para ler valores do cofre de chaves:

az keyvault set-policy \
  --name $AKV \
  --resource-group $AKV_RG \
  --object-id $(az acr task show \
                  --name base-import-node \
                  --registry $REGISTRY_BASE_ARTIFACTS \
                  --query identity.principalId --output tsv) \
  --secret-permissions get

Execute a tarefa de importação:

az acr task run -n base-import-node -r $REGISTRY_BASE_ARTIFACTS

Observação

Se a tarefa falhar devido a ./test.sh: Permission denied, verifique se o script tem permissões de execução e confirme de volta no repositório Git:

chmod +x ./test.sh

Atualizar a imagem `hello-world` para compilar a partir da imagem `node` restrita

Crie um token de acesso para acessar o registro de artefatos base, com escopo read do repositório node. Em seguida, defina no cofre de chaves:

az keyvault secret set \
  --vault-name $AKV \
  --name "registry-${REGISTRY_BASE_ARTIFACTS}-user" \
  --value "registry-${REGISTRY_BASE_ARTIFACTS}-user"

az keyvault secret set \
  --vault-name $AKV \
  --name "registry-${REGISTRY_BASE_ARTIFACTS}-password" \
  --value $(az acr token create \
              --name "registry-${REGISTRY_BASE_ARTIFACTS}-user" \
              --registry $REGISTRY_BASE_ARTIFACTS \
              --repository node content/read \
              -o tsv \
              --query credentials.passwords[0].value)

Adicione credenciais à tarefa hello-world para o registro de artefatos base:

az acr task credential add \
  -n hello-world \
  -r $REGISTRY \
  --login-server $REGISTRY_BASE_ARTIFACTS_URL \
  -u https://${AKV}.vault.azure.net/secrets/registry-${REGISTRY_BASE_ARTIFACTS}-user \
  -p https://${AKV}.vault.azure.net/secrets/registry-${REGISTRY_BASE_ARTIFACTS}-password \
  --use-identity [system]

Atualizar a tarefa para alterar REGISTRY_FROM_URL para usar o registro BASE_ARTIFACTS

az acr task update \
  -n hello-world \
  -r $REGISTRY \
  --set KEYVAULT=$AKV \
  --set REGISTRY_FROM_URL=${REGISTRY_BASE_ARTIFACTS_URL}/ \
  --set ACI=$ACI \
  --set ACI_RG=$ACI_RG

Execute a tarefa hello-world para alterar a dependência da imagem base:

az acr task run -r $REGISTRY -n hello-world

Atualizar a imagem base com uma alteração "válida"

Abra Dockerfile no repositório base-image-node.
Altere BACKGROUND_COLOR para Green para simular uma alteração válida.

ARG REGISTRY_NAME=
FROM ${REGISTRY_NAME}node:15-alpine
ENV NODE_VERSION 15-alpine
ENV BACKGROUND_COLOR Green

Confirme a alteração e monitore a sequência das atualizações:

watch -n1 az acr task list-runs -r $REGISTRY_PUBLIC -o table

Uma vez em execução, digite Ctrl+C e monitore os logs:

az acr task logs -r $REGISTRY_PUBLIC

Após a conclusão, monitore a tarefa base-image-import:

watch -n1 az acr task list-runs -r $REGISTRY_BASE_ARTIFACTS -o table

Uma vez em execução, digite Ctrl+C e monitore os logs:

az acr task logs -r $REGISTRY_BASE_ARTIFACTS

Depois de concluir, monitore a tarefa hello-world:

watch -n1 az acr task list-runs -r $REGISTRY -o table

Uma vez em execução, digite Ctrl+C e monitore os logs:

az acr task logs -r $REGISTRY

Depois de concluído, obtenha o endereço IP do site que hospeda a imagem hello-world atualizada:

az container show \
  --resource-group $ACI_RG \
  --name ${ACI} \
  --query ipAddress.ip \
  --out tsv

No navegador, vá para o site, que deve ter uma tela de fundo verde (válido).

Visualizar o fluxo de trabalho restrito

Execute as etapas na seção anterior novamente, com uma cor da tela de fundo em vermelho.

Abrir Dockerfile no repositório base-image-node
Altere BACKGROUND_COLOR para Red para simular uma alteração inválida.

ARG REGISTRY_NAME=
FROM ${REGISTRY_NAME}node:15-alpine
ENV NODE_VERSION 15-alpine
ENV BACKGROUND_COLOR Red

Confirme a alteração e monitore a sequência das atualizações:

watch -n1 az acr task list-runs -r $REGISTRY_PUBLIC -o table

Uma vez em execução, digite Ctrl+C e monitore os logs:

az acr task logs -r $REGISTRY_PUBLIC

Após a conclusão, monitore a tarefa base-image-import:

watch -n1 az acr task list-runs -r $REGISTRY_BASE_ARTIFACTS -o table

Uma vez em execução, digite Ctrl+C e monitore os logs:

az acr task logs -r $REGISTRY_BASE_ARTIFACTS

Neste ponto, você deverá ver a tarefa base-import-node falhar na validação e interromper a sequência para publicar uma atualização hello-world. A saída é semelhante a:

[...]
2020/10/30 03:57:39 Launching container with name: validate-base-image
Validating Image
NODE_VERSION: 15-alpine
BACKGROUND_COLOR: Red
ERROR: Invalid Color: Red
2020/10/30 03:57:40 Container failed during run: validate-base-image. No retries remaining.
failed to run step ID: validate-base-image: exit status 1

Publicar uma atualização para `hello-world`

As alterações na imagem hello-world continuarão usando a última imagem node validada.

Qualquer alteração adicional na imagem base node que passar pelas validações restritas irá disparar as atualizações da imagem base para a imagem hello-world.

Limpeza

Exclua os recursos criados neste artigo quando não forem mais necessários.

az group delete -n $REGISTRY_RG --no-wait -y
az group delete -n $REGISTRY_PUBLIC_RG --no-wait -y
az group delete -n $REGISTRY_BASE_ARTIFACTS_RG --no-wait -y
az group delete -n $AKV_RG --no-wait -y
az group delete -n $ACI_RG --no-wait -y

Próximas etapas

Neste artigo, você usou tarefas ACR para criar um fluxo de trabalho de restrição automatizado para introduzir imagens base atualizadas ao seu ambiente. Consulte as informações relacionadas para gerenciar imagens no Registro de Contêiner do Azure.

Compartilhar via

Como consumir e manter conteúdo público com Tarefas do Registro de Contêiner do Azure

Visão geral do cenário

Pré-requisitos

Definir variáveis de ambiente

Repositórios Git e tokens

Credenciais do Docker Hub

Criar registros

Criar um cofre de chaves e definir segredos

Criar grupo de recursos para uma instância de contêiner do Azure

Criar imagem base pública `node`

Criar a imagem `hello-world`

Criar token para efetuar pull de acesso ao registro público simulado

Criar token para efetuar pull de acesso por Instâncias de Contêiner do Azure

Criar tarefa para criar e manter a imagem `hello-world`

Atualizar a imagem base com uma alteração "questionável"

Fazer check-in

Importações restritas de conteúdo público

Adicionar testes de automação

YAML da tarefa

Criar tarefa para importar e testar a imagem base

Atualizar a imagem `hello-world` para compilar a partir da imagem `node` restrita

Atualizar a imagem base com uma alteração "válida"

Visualizar o fluxo de trabalho restrito

Publicar uma atualização para `hello-world`

Limpeza

Próximas etapas

Comentários

Recursos adicionais

Compartilhar via

Como consumir e manter conteúdo público com Tarefas do Registro de Contêiner do Azure

Visão geral do cenário

Pré-requisitos

Definir variáveis de ambiente

Repositórios Git e tokens

Credenciais do Docker Hub

Criar registros

Criar um cofre de chaves e definir segredos

Criar grupo de recursos para uma instância de contêiner do Azure

Criar imagem base pública node

Criar a imagem hello-world

Criar token para efetuar pull de acesso ao registro público simulado

Criar token para efetuar pull de acesso por Instâncias de Contêiner do Azure

Criar tarefa para criar e manter a imagem hello-world

Atualizar a imagem base com uma alteração "questionável"

Fazer check-in

Importações restritas de conteúdo público

Adicionar testes de automação

YAML da tarefa

Criar tarefa para importar e testar a imagem base

Atualizar a imagem hello-world para compilar a partir da imagem node restrita

Atualizar a imagem base com uma alteração "válida"

Visualizar o fluxo de trabalho restrito

Publicar uma atualização para hello-world

Limpeza

Próximas etapas

Comentários

Recursos adicionais

Criar imagem base pública `node`

Criar a imagem `hello-world`

Criar tarefa para criar e manter a imagem `hello-world`

Atualizar a imagem `hello-world` para compilar a partir da imagem `node` restrita

Publicar uma atualização para `hello-world`