Como consumir e manter conteúdo público com Azure Container Registry Tarefas

Artigo
10/31/2023

Este artigo fornece um fluxo de trabalho de exemplo no Azure Container Registry para o ajudar a gerir o consumo e a manutenção de conteúdos públicos:

Importar cópias locais de imagens públicas dependentes.
Valide imagens públicas através da análise de segurança e dos testes funcionais.
Promova as imagens para registos privados para utilização interna.
Acionar atualizações de imagem base para aplicações dependentes de conteúdo público.
Utilize Azure Container Registry Tarefas para automatizar este fluxo de trabalho.

O fluxo de trabalho é resumido na imagem seguinte:

Consumo de conteúdo público Fluxo de Trabalho

O fluxo de trabalho de importação fechado ajuda a gerir as dependências da sua organização em artefactos geridos externamente , por exemplo, imagens provenientes de registos públicos, incluindo Docker Hub, GCR, Quay, GitHub Container Registry, Microsoft Container Registry ou até mesmo outros registos de contentores do Azure.

Para obter informações sobre os riscos introduzidos pelas dependências de conteúdo público e como utilizar Azure Container Registry para os mitigar, veja a publicação blogue OCI Consuming Public Content Blog (OCI Consuming Public Content Blog) e Manage public content with Azure Container Registry (Gerir conteúdo público com Azure Container Registry).

Pode utilizar a Cloud Shell do Azure ou uma instalação local da CLI do Azure para concluir estas instruções. Recomenda-se a versão 2.10 ou posterior da CLI do Azure. Se precisar de instalar ou atualizar, veja Install Azure CLI (Instalar o Azure CLI).

Scenario overview (Descrição geral do cenário)

importar componentes do fluxo de trabalho

Estas instruções são configuradas:

Três registos de contentores, que representam:
- Uma Docker Hub simulada (publicregistry) para suportar a alteração da imagem de base
- Registo de equipa (contoso) para partilhar imagens privadas
- Registo partilhado da empresa/equipa (baseartifacts) para conteúdo público importado
Uma tarefa do ACR em cada registo. As tarefas:
1. Criar uma imagem pública node simulada
2. Importar e validar a node imagem para o registo partilhado da empresa/equipa
3. Criar e implementar a hello-world imagem
Definições de tarefas do ACR, incluindo configurações para:
Uma coleção de credenciais de registo, que são ponteiros para um cofre de chaves
Uma coleção de segredos, disponível num acr-task.yaml, que são ponteiros para um cofre de chaves
Uma coleção de valores configurados utilizados num acr-task.yaml
Um cofre de chaves do Azure para proteger todos os segredos
Uma instância de contentor do Azure, que aloja a aplicação hello-world de compilação

Pré-requisitos

Os passos seguintes configuram valores para recursos criados e utilizados nas instruções.

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 no seu próprio grupo de recursos para minimizar a eliminação acidental. No entanto, pode colocá-los num único grupo de recursos, se assim o desejar.

Os exemplos neste artigo estão formatados para a shell de 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 do Git

Para simular o seu ambiente, fork cada um dos seguintes repositórios git em repositórios que pode gerir.

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

O :main anexado ao fim dos URLs do git representa o ramo de repositório predefinido.

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

Precisa de um token de acesso do GitHub (PAT) para tarefas do ACR para clonar e estabelecer webhooks do Git. Para obter os passos 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 de Docker Hub

Para evitar limitações e pedidos de identidade ao extrair imagens de Docker Hub, crie um token de Docker Hub. Em seguida, defina as seguintes variáveis de ambiente:

REGISTRY_DOCKERHUB_USER=<yourusername>
REGISTRY_DOCKERHUB_PASSWORD=<yourtoken>

Criar registos

Com os comandos da CLI do Azure, crie três registos de contentores de escalão Premium, cada um no 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

Criar um cofre de chaves:

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

Defina Docker Hub nome de utilizador e token 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 um grupo de recursos para uma instância de contentor do Azure

Este grupo de recursos é utilizado numa tarefa posterior ao implementar 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 do ACR para compilar e manter a imagem pública. Esta configuração permite simular alterações por parte dos responsáveis pela manutenção da 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 Docker Hub credenciais à tarefa. O comando acr task credentials pode ser utilizado para transmitir credenciais do Docker para qualquer registo, incluindo 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 aos valores de leitura a partir 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 consolidações do Git, atualizações de imagens de 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 registo 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, crie uma hello-world imagem.

Criar token para acesso pull ao registo público simulado

Crie um token de acesso para o registo público simulado, no âmbito do 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 Azure Container Instances

Crie um token de acesso para o registo que aloja a hello-world imagem, com âmbito para solicitar. 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` a imagem

O comando seguinte cria uma tarefa a partir da definição no acr-tasks.yamlhello-world repositório. Os passos de tarefa criam a hello-world imagem e, em seguida, implementam-na no Azure Container Instances. O grupo de recursos para Azure Container Instances foi criado numa secção anterior. Ao chamar az container create a tarefa com apenas uma diferença no image:tag, a tarefa é implementada na mesma instância ao longo destas instruções.

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 do registo 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 aos valores de leitura a partir 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 gerir Azure Container Instances ao conceder 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 implementar a hello-world imagem:

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

Depois de criado, obtenha o endereço IP do contentor que aloja a hello-world imagem.

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

No browser, aceda ao endereço IP para ver a aplicação em execução.

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

Esta secção simula uma alteração à imagem de 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

Consolide a alteração e aguarde que as Tarefas do ACR comecem a criar automaticamente.

Tenha em atenção que a tarefa começa a ser executada:

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

Deverá eventualmente ver STATUS Succeeded com base num Acionador de Commit:

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

Escreva Ctrl+C para sair do comando do relógio e, em seguida, veja os registos da execução mais recente:

az acr task logs -r $REGISTRY_PUBLIC

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

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

Deverá eventualmente ver STATUS Succeeded com base num Acionador 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

Escreva Ctrl+C para sair do comando do relógio e, em seguida, veja os registos da execução mais recente:

az acr task logs -r $REGISTRY

Depois de concluído, obtenha o endereço IP do site que aloja 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 laranja (questionável).

Dar entrada

Neste momento, criou uma hello-world imagem que é criada automaticamente em consolidações do Git e alterações à imagem base node . Neste exemplo, a tarefa é compilada numa imagem de base no Azure Container Registry, mas qualquer registo suportado pode ser utilizado.

A atualização da imagem de base repõe automaticamente a execução da tarefa quando a node imagem é atualizada. Como se pode ver aqui, nem todas as atualizações são pretendidas.

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

Para impedir que as alterações a montante que quebram cargas de trabalho críticas, podem ser adicionados testes funcionais e de análise de segurança.

Nesta secção, vai criar uma tarefa do 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 registo de imagens base

Adicionar testes de automatização

Para controlar qualquer conteúdo a montante, é implementado um teste automatizado. Neste exemplo, é fornecido um test.sh que verifica o $BACKGROUND_COLOR. Se o teste falhar, é devolvido um EXIT_CODE de 1 que faz com que o passo da tarefa do ACR falhe, terminando a execução da tarefa. Os testes podem ser expandidos em qualquer forma de ferramentas, incluindo resultados de registo. A porta é gerida por uma resposta pass/fail 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

Reveja o acr-task.yamlimport-baseimage-node no repositório, que executa os seguintes passos:

Crie a imagem de base de teste com o seguinte Dockerfile:

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

Quando concluída, valide a imagem ao executar o contentor, que é executado ./test.sh
Apenas se tiver sido concluída com êxito, execute os passos de importação, que estão fechados 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 de 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 do registo 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 aos valores de leitura a partir 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 a ./test.sh: Permission denied, certifique-se de que o script tem permissões de execução e volte a consolidar para o repositório git:

chmod +x ./test.sh

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

Crie um token de acesso para aceder ao registo de artefactos base, no read âmbito do node repositório. 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 registo de artefactos 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 utilizar o BASE_ARTIFACTS registo

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 de base:

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

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

Abra o Dockerfile repositório in base-image-node .
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

Consolide a alteração e monitorize a sequência de atualizações:

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

Depois de executar, escreva Ctrl+C e monitorize os registos:

az acr task logs -r $REGISTRY_PUBLIC

Depois de concluída, monitorize a tarefa de importação de imagens de base :

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

Depois de executar, escreva Ctrl+C e monitorize os registos:

az acr task logs -r $REGISTRY_BASE_ARTIFACTS

Depois de concluída, monitorize a tarefa hello-world :

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

Depois de executar, escreva Ctrl+C e monitorize os registos:

az acr task logs -r $REGISTRY

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

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

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

Ver o fluxo de trabalho fechado

Execute novamente os passos na secção anterior, com uma cor de fundo de vermelho.

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

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

Consolide a alteração e monitorize a sequência de atualizações:

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

Depois de executar, escreva Ctrl+C e monitorize os registos:

az acr task logs -r $REGISTRY_PUBLIC

Depois de concluída, monitorize a tarefa de importação de imagens de base :

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

Depois de executar, escreva Ctrl+C e monitorize os registos:

az acr task logs -r $REGISTRY_BASE_ARTIFACTS

Neste momento, deverá ver a validação da tarefa de importação-nó de base e parar 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 em `hello-world`

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

Quaisquer alterações adicionais à imagem de base node que transmitam as validações fechadas irão acionar atualizações de imagem de base para a hello-world imagem.

Limpeza

Quando já não for necessário, elimine os recursos utilizados 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

Passos seguintes

Neste artigo. utilizou tarefas do ACR para criar um fluxo de trabalho de gating automatizado para introduzir imagens de base atualizadas no seu ambiente. Veja informações relacionadas para gerir imagens no Azure Container Registry.

Como consumir e manter conteúdo público com Azure Container Registry Tarefas

Scenario overview (Descrição geral do cenário)

Pré-requisitos

Definir variáveis de ambiente

Repositórios e tokens do Git

credenciais de Docker Hub

Criar registos

Criar cofre de chaves e definir segredos

Criar um grupo de recursos para uma instância de contentor do Azure

Criar imagem de base pública node

Criar a hello-world imagem

Criar token para acesso pull ao registo público simulado

Criar token para acesso pull por Azure Container Instances

Criar tarefa para criar e manter hello-world a imagem

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

Dar entrada

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

Adicionar testes de automatização

TAREFA YAML

Criar tarefa para importar e testar a imagem de base

Atualizar hello-world imagem para compilar a partir de uma imagem fechada node

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

Ver o fluxo de trabalho fechado

Publicar uma atualização em hello-world

Limpeza

Passos seguintes

Recursos adicionais

Criar imagem de base pública `node`

Criar a `hello-world` imagem

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

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

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