Como consumir e manter conteúdo público com as 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 ajudá-lo 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 através de verificação de segurança e testes funcionais.
Promova as imagens para registos privados para uso interno.
Acione 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 é resumido na imagem a seguir:

Consumindo conteúdo público Fluxo de trabalho

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

Para obter informações básicas sobre os riscos introduzidos pelas dependências em conteúdo público e como usar o Registro de Contêiner do Azure para mitigá-los, consulte a postagem do Blog de Consumo de Conteúdo Público da 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 este passo a passo. A CLI do Azure versão 2.10 ou posterior é recomendada. Se precisar de instalar ou atualizar, veja Install Azure CLI (Instalar o Azure CLI).

Descrição geral do cenário

Importar componentes do fluxo de trabalho

Este passo a passo configura:

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

Pré-requisitos

As etapas a seguir configuram valores para recursos criados e usados no passo a passo.

Definir variáveis de ambiente

Configure variáveis exclusivas para o 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 um único grupo de recursos, se desejar.

Os exemplos neste artigo são formatados para o shell 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 e tokens Git

Para simular seu ambiente, bifurque cada um dos seguintes repositórios Git em repositórios que você pode gerenciar.

Em seguida, atualize as seguintes variáveis para seus repositórios bifurcados.

O :main anexado ao final das URLs do git representa a ramificação padrão do repositório.

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 (PAT) do GitHub para que as tarefas ACR clonem e estabeleçam webhooks do 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 limitações e solicitações de identidade ao extrair imagens do Docker Hub, crie um token do Docker Hub. Em seguida, defina as seguintes variáveis de ambiente:

REGISTRY_DOCKERHUB_USER=<yourusername>
REGISTRY_DOCKERHUB_PASSWORD=<yourtoken>

Criar registos

Usando comandos da CLI do Azure, crie três registros de contêiner de camada Premium, cada um 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 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 uma PAT Git 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 hello-world imagem.

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

Criar imagem de base pública `node`

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

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, adicione credenciais do Docker Hub à tarefa. O comando acr task credentials pode ser usado para passar 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

As tarefas podem ser acionadas por confirmações Git, atualizações de imagem base, temporizadores ou execuções manuais.

Execute a tarefa manualmente para gerar a node imagem:

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 `hello-world` imagem

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

Criar token para acesso pull ao registro público simulado

Crie um token de acesso ao 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 acesso pull por instâncias de contêiner do Azure

Crie um token de acesso ao registro que hospeda a hello-world imagem, com escopo para 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 `hello-world` imagem

O comando a seguir cria uma tarefa a partir da definição no acr-tasks.yaml hello-world repositório. As etapas da tarefa criam a hello-world imagem e a implantam nas 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 a tarefa com apenas uma diferença no image:tag, a tarefa é implantada na mesma instância ao longo deste 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 hello-world imagem:

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

Uma vez criado, obtenha o endereço IP do contêiner que hospeda a hello-world imagem.

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

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

Atualize 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 o 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 se as Tarefas ACR começam a ser criadas automaticamente.

Fique atento para que a tarefa comece a ser executada:

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

Você deve eventualmente ver STATUS Succeeded com base em um GATILHO 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 de observação e visualize os logs da execução mais recente:

az acr task logs -r $REGISTRY_PUBLIC

Quando a imagem estiver concluída, watch para que as node Tarefas ACR comecem automaticamente a criar a hello-world imagem:

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

Você deve eventualmente ver STATUS Succeeded com base em um GATILHO 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 de observação e visualize os logs da execução mais recente:

az acr task logs -r $REGISTRY

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

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

No seu navegador, vá para o site, que deve ter um fundo laranja (questionável).

Fazer check-in

Neste ponto, você criou uma hello-world imagem que é criada automaticamente em confirmações do Git e alterações na imagem base node . Neste exemplo, a tarefa é criada em relação a uma imagem base no Registro de Contêiner do Azure, mas qualquer registro com suporte pode ser usado.

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

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

Para evitar que as alterações upstream quebrem 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:

Criar uma imagem de teste
Executar um script ./test.sh de teste funcional 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 bloquear qualquer conteúdo upstream, testes automatizados são implementados. Neste exemplo, é fornecido um test.sh que verifica o $BACKGROUND_COLOR. Se o teste falhar, um EXIT_CODE dos será retornado, o que faz com que a etapa da 1 tarefa ACR falhe, encerrando a execução da tarefa. Os testes podem ser expandidos em qualquer forma de ferramentas, incluindo o registro de resultados. O 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}

Tarefa YAML

Analise o acr-task.yaml import-baseimage-node no repo, que executa as seguintes etapas:

Crie a imagem da base de teste usando o seguinte Dockerfile:

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 é executado ./test.sh
Somente se concluído com êxito, execute as etapas de importação, que são fechadas 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

Nota

Se a tarefa falhar devido ao ./test.sh: Permission denied, certifique-se de que o script tenha permissões de execução e confirme novamente para o repositório Git:

chmod +x ./test.sh

Atualizar `hello-world` imagem para construir a partir de imagem fechada `node`

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

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 o REGISTRY_FROM_URL para usar o BASE_ARTIFACTS registro

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 sua dependência de imagem base:

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

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

Abra o Dockerfile in base-image-node repo.
Altere o 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 de atualizações:

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

Depois de executar, digite Ctrl+C e monitore os logs:

az acr task logs -r $REGISTRY_PUBLIC

Depois de concluído, monitore a tarefa de importação de imagem base:

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

Depois de executar, digite Ctrl+C e monitore os logs:

az acr task logs -r $REGISTRY_BASE_ARTIFACTS

Uma vez concluído, monitore a tarefa hello-world :

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

Depois de executar, digite Ctrl+C e monitore os logs:

az acr task logs -r $REGISTRY

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

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

No seu browser, aceda ao site, que deverá ter um fundo verde (válido).

Exibir o fluxo de trabalho fechado

Execute as etapas na seção anterior novamente, com uma cor de plano de fundo vermelha.

Abra o Dockerfile base-image-node no repositório
Altere o 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 de atualizações:

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

Depois de executar, digite Ctrl+C e monitore os logs:

az acr task logs -r $REGISTRY_PUBLIC

Depois de concluído, monitore a tarefa de importação de imagem base:

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

Depois de executar, digite Ctrl+C e monitore os logs:

az acr task logs -r $REGISTRY_BASE_ARTIFACTS

Neste ponto, você verá a tarefa base-import-node falhar na validação e interromper a sequência para publicar uma hello-world atualização. 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 hello-world imagem continuarão usando a última imagem validada node .

Quaisquer alterações adicionais na imagem base node que passarem nas validações fechadas acionarão atualizações de imagem base para a hello-world imagem.

Limpeza

Quando não for mais necessário, exclua os recursos usados neste artigo.

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óximos passos

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

Partilhar via

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

Descrição geral do cenário

Pré-requisitos

Definir variáveis de ambiente

Repositórios e tokens Git

Credenciais do Docker Hub

Criar registos

Criar cofre de chaves e definir segredos

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

Criar imagem de base pública `node`

Criar a `hello-world` imagem

Criar token para acesso pull ao registro público simulado

Criar token para acesso pull por instâncias de contêiner do Azure

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

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

Fazer check-in

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

Adicionar testes de automação

Tarefa YAML

Criar tarefa para importar e testar a imagem base

Atualizar `hello-world` imagem para construir a partir de imagem fechada `node`

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

Exibir o fluxo de trabalho fechado

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

Limpeza

Próximos passos

Comentários

Recursos adicionais

Partilhar via

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

Descrição geral do cenário

Pré-requisitos

Definir variáveis de ambiente

Repositórios e tokens Git

Credenciais do Docker Hub

Criar registos

Criar cofre de chaves e definir segredos

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

Criar imagem de base pública node

Criar a hello-world imagem

Criar token para acesso pull ao registro público simulado

Criar token para acesso pull por instâncias de contêiner do Azure

Criar tarefa para criar e manter hello-world imagem

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

Fazer check-in

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

Adicionar testes de automação

Tarefa YAML

Criar tarefa para importar e testar a imagem base

Atualizar hello-world imagem para construir a partir de imagem fechada node

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

Exibir o fluxo de trabalho fechado

Publicar uma atualização para hello-world

Limpeza

Próximos passos

Comentários

Recursos adicionais

Criar imagem de base pública `node`

Criar a `hello-world` imagem

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

Atualizar `hello-world` imagem para construir a partir de imagem fechada `node`

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