Consumo y mantenimiento de contenido público con Azure Container Registry Tasks

Artículo
10/31/2023

En este artículo se proporciona un flujo de trabajo de ejemplo de Azure Container Registry para ayudarlo a administrar el consumo y mantenimiento de contenido público:

Importar copias locales de imágenes públicas dependientes.
Validar las imágenes públicas a través de un examen de seguridad y pruebas funcionales.
Promover las imágenes a registros privados para uso interno.
Desencadenar actualizaciones de imagen base para aplicaciones que dependen del contenido público.
Usar Azure Container Registry Tasks para automatizar este flujo de trabajo.

El flujo de trabajo se resume en la imagen siguiente:

Flujo de trabajo del consumo de contenido público

El flujo de trabajo de importación controlado le permite administrar las dependencias de su organización con respecto a artefactos administrados de manera externa; por ejemplo, imágenes originadas a partir de registros públicos, incluidos Docker Hub, GCR, Quay, GitHub Container Registry, Microsoft Container Registry o, incluso, otras instancias de Azure Container Registry.

Para información sobre los riesgos que presentan las dependencias de contenido público y cómo usar Azure Container Registry para mitigarlos, consulte esta entrada del blog de OCI sobre el consumo de contenido público y el artículo Administración del contenido público con Azure Container Registry.

Puede usar Azure Cloud Shell o una instalación local de la CLI de Azure para completar este tutorial. Se recomienda la CLI de Azure versión 2.10 o posterior. Si necesita instalarla o actualizarla, vea Instalación de la CLI de Azure.

Información general de escenario

Componentes del flujo de trabajo de importación

En este tutorial se realiza la configuración de lo siguiente:

Tres registros de contenedor, que representan:
- Una instancia de Docker Hub (publicregistry) simulada para admitir el cambio de la imagen base.
- El registro de equipo (contoso) para compartir imágenes privadas.
- El registro compartido de la empresa o del equipo (baseartifacts) para el contenido público importado.
Una tarea de ACR en cada registro. Las tareas:
1. Crean una imagen node pública simulada.
2. Importan y validan la imagen node al registro compartido de la empresa o del equipo.
3. Crean e implementan la imagen hello-world.
Definiciones de las tareas de ACR, incluidas las configuraciones de:
Una colección de credenciales de registro, que son punteros a un almacén de claves.
Una colección de secretos, disponible dentro de un archivo acr-task.yaml, que son punteros a un almacén de claves.
Una colección de valores configurados que se usan dentro de un archivo acr-task.yaml.
Un almacén de claves de Azure para proteger todos los secretos.
Una instancia de contenedor de Azure, que hospeda la aplicación de compilación hello-world.

Requisitos previos

En los pasos siguientes se configuran los valores de los recursos que se crean y usan en el tutorial.

Establecimiento de variables de entorno

Configure variables únicas para su entorno. Seguimos los procedimientos recomendados para colocar recursos con contenido duradero en su propio grupo de recursos a fin de minimizar la eliminación accidental. Sin embargo, puede colocarlos en un solo grupo de recursos si así lo desea.

Los ejemplos que aparecen en este artículo tienen un formato para el 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

Tokens y repositorios de Git

Para simular su entorno, debe bifurcar cada uno de estos repositorios de Git en repositorios que pueda administrar.

Luego, actualice estas variables para los repositorios bifurcados.

El :main anexado al final de las direcciones URL de Git representa la rama predeterminada del repositorio.

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

Necesita un token de acceso de GitHub(PAT) para que ACR Tasks clone y establezca webhooks de Git. Para conocer los pasos que se siguen para crear un token con los permisos necesarios para un repositorio privado, consulte Creación de un token de acceso personal de GitHub.

GIT_TOKEN=<set-git-token-here>

Credenciales de Docker Hub

Para evitar las solicitudes de identidad y limitación al extraer imágenes de Docker Hub, cree un token de Docker Hub. Luego, agregue estas variables de entorno:

REGISTRY_DOCKERHUB_USER=<yourusername>
REGISTRY_DOCKERHUB_PASSWORD=<yourtoken>

Creación de registros

Use comandos de la CLI de Azure para crear tres registros de contenedor de nivel Premium, cada uno en su propio 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

Creación de un almacén de claves y establecimiento de secretos

Cree un almacén de claves:

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

Establezca el nombre de usuario y el token de Docker Hub en el almacén de claves:

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

Establezca y compruebe un PAT de Git en el almacén de claves:

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

Creación de un grupo de recursos para una instancia de contenedor de Azure

Este grupo de recursos se usa en una tarea posterior al implementar la imagen hello-world.

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

Creación de una imagen `node` base pública

Para simular la imagen node en Docker Hub, cree una tarea de ACR para crear y mantener la imagen pública. Esta configuración permite simular los cambios que realizan los mantenedores de la imagen 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 la limitación de Docker, agregue credenciales de Docker Hub a la tarea. Es posible usar el comando acr task credentials para pasar credenciales de Docker a cualquier registro, incluido 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 a la tarea acceso para leer los valores del almacén de claves:

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

Las tareas las pueden desencadenar confirmaciones de Git, actualizaciones de la imagen base, temporizadores o ejecuciones manuales.

Ejecute la tarea manualmente para generar la imagen node:

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

Muestre la imagen en el registro público simulado:

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

Creación de la imagen `hello-world`

Cree una imagen hello-world en función de la imagen node pública simulada.

Creación de un token para acceso de extracción en un registro público simulado

Cree un token de acceso al registro público simulado, limitado a pull. Luego, establézcalo en el almacén de claves:

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)

Creación de un token para acceso de extracción a través de Azure Container Instances

Cree un token de acceso al registro en que se hospeda la imagen hello-world, limitado a la extracción. Luego, establézcalo en el almacén de claves:

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)

Creación de una tarea para crear y mantener una imagen `hello-world`

El comando siguiente crea una tarea a partir de la definición que se encuentra en el archivo acr-tasks.yaml del repositorio hello-world. Los pasos de la tarea crean la imagen hello-world y, luego, la implementan en Azure Container Instances. El grupo de recursos para Azure Container Instances se creó en una sección anterior. Al llamar a az container create en la tarea con solo una diferencia en image:tag, la tarea se implementa en la misma instancia a lo largo de todo este tutorial.

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

Agregue las credenciales a la tarea para el 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 a la tarea acceso para leer los valores del almacén de claves:

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 a la tarea acceso para crear y administrar Azure Container Instances mediante la concesión de acceso al 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

Una vez creada y configurada la tarea, ejecútela para crear e implementar la imagen hello-world:

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

Una vez creada, obtenga la dirección IP del contenedor en el que se hospeda la imagen hello-world.

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

En el explorador, vaya a la dirección IP para ver la aplicación en ejecución.

Actualización de la imagen base con un cambio "cuestionable"

En esta sección se simula un cambio en la imagen base que podría causar problemas en el entorno.

Abra Dockerfile en el repositorio base-image-node bifurcado.
Cambie BACKGROUND_COLOR a Orange para simular el cambio.

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

Confirme el cambio y use un comando de inspección en ACR Tasks para empezar a hacer automáticamente la creación.

Ejecute un comando de inspección para ver cuando la tarea se empieza a ejecutar:

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

A la larga, debería ver el estado STATUS Succeeded en función de un desencadenador 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

Escriba Ctrl+C para salir del comando de inspección y consulte los registros de la ejecución más reciente:

az acr task logs -r $REGISTRY_PUBLIC

Una vez completada la imagen node, use el comando watch para que ACR Tasks empiece automáticamente a crear la imagen hello-world:

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

A la larga, debería ver el estado STATUS Succeeded en función de un desencadenador 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

Escriba Ctrl+C para salir del comando de inspección y consulte los registros de la ejecución más reciente:

az acr task logs -r $REGISTRY

Cuando termine, obtenga la dirección IP del sitio en el que se hospeda la imagen hello-world actualizada:

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

En el explorador, vaya al sitio, el que debería tener un fondo naranja (cuestionable).

Registro

En este punto, tiene creada una imagen hello-world que se genera automáticamente en las confirmaciones de Git y cambios en la imagen node base. En este ejemplo, la tarea se crea según una imagen base de Azure Container Registry, pero se podría usar cualquier registro compatible.

La actualización de la imagen base vuelve a desencadenar automáticamente la ejecución de la tarea cuando se actualiza la imagen node. Como se ve aquí, no todas las actualizaciones son deseadas.

Importaciones controladas de contenido público

Para evitar que los cambios ascendentes detengan las cargas de trabajo críticas, se pueden agregar exámenes de seguridad y pruebas funcionales.

En esta sección, creará una tarea de ACR para:

Crear una imagen de prueba.
Ejecutar un script de prueba funcional ./test.sh en la imagen de prueba.
Si la imagen se prueba correctamente, importe la imagen pública al registro baseimages.

Incorporación de pruebas de automatización

Para canalizar cualquier contenido ascendente, se implementan pruebas automatizadas. En este ejemplo, se proporciona un elemento test.sh que comprueba el elemento $BACKGROUND_COLOR. Si ocurre un error en la prueba, se devuelve un código EXIT_CODE de 1, lo que genera un error en el paso de la tarea de ACR y finaliza la ejecución de la tarea. Las pruebas se pueden expandir en cualquier forma de herramientas, incluidos resultados de registro. El mecanismo de control se administra mediante una respuesta de tipo "pasa/no pasa" en el script que se reproduce aquí:

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}

Código YAML para las tareas

Revise el archivo acr-task.yaml del repositorio import-baseimage-node, que lleva a cabo los pasos siguientes:

Compile la imagen base de prueba con el Dockerfile siguiente:

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

Al terminar, ejecute el contenedor, que ejecuta ./test.sh, para validar la imagen.
Solo si el proceso se completa correctamente, ejecute los pasos de importación, que se controlan con 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}}"

Creación de una tarea para importar y probar una imagen 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

Agregue las credenciales a la tarea para el 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 a la tarea acceso para leer los valores del almacén de claves:

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

Ejecute la tarea de importación:

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

Nota

Si se produce un error en la tarea debido a ./test.sh: Permission denied, asegúrese de que el script tenga permisos de ejecución y vuelva a confirmar con el repositorio de Git:

chmod +x ./test.sh

Actualización de la imagen `hello-world` para crear a partir de la imagen `node` controlada

Cree un token de acceso para acceder al registro de artefactos base, limitado a read desde el repositorio node. Luego, establézcalo en el almacén de claves:

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)

Agregue credenciales a la tarea hello-world correspondiente al registro 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]

Actualice la tarea para cambiar REGISTRY_FROM_URL para usar el 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

Ejecute la tarea hello-world para cambiar su dependencia de imagen base:

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

Actualización de la imagen base con un cambio "válido"

Abra Dockerfile en el repositorio base-image-node.
Cambie BACKGROUND_COLOR a Green para simular un cambio válido.

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

Confirme el cambio y supervise la secuencia de actualizaciones:

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

Una vez en ejecución, escriba Ctrl+C y supervise los registros:

az acr task logs -r $REGISTRY_PUBLIC

Al terminar, supervise la tarea base-image-import:

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

Una vez en ejecución, escriba Ctrl+C y supervise los registros:

az acr task logs -r $REGISTRY_BASE_ARTIFACTS

Al terminar, supervise la tarea hello-world:

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

Una vez en ejecución, escriba Ctrl+C y supervise los registros:

az acr task logs -r $REGISTRY

Cuando termine, obtenga la dirección IP del sitio en el que se hospeda la imagen hello-world actualizada:

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

En el explorador, vaya al sitio, que debe tener un fondo verde (válido).

Visualización del flujo de trabajo controlado

Repita los pasos de la sección anterior con un color de fondo rojo.

Abra Dockerfile en el repositorio base-image-node.
Cambie BACKGROUND_COLOR a Red para simular un cambio no válido.

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

Confirme el cambio y supervise la secuencia de actualizaciones:

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

Una vez en ejecución, escriba Ctrl+C y supervise los registros:

az acr task logs -r $REGISTRY_PUBLIC

Al terminar, supervise la tarea base-image-import:

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

Una vez en ejecución, escriba Ctrl+C y supervise los registros:

az acr task logs -r $REGISTRY_BASE_ARTIFACTS

En este punto, debería ver que la tarea base-import-node no pasa la validación y detiene la secuencia para publicar una actualización de hello-world. La salida es parecida a esta:

[...]
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

Publicación de una actualización de `hello-world`

Los cambios de la imagen hello-world seguirán usando la última imagen node validada.

Cualquier otro cambio en la imagen node base que pase las validaciones controladas desencadenará actualizaciones de imagen base de la imagen hello-world.

Limpieza

Cuando ya no los necesite, elimine los recursos que se usan en este artículo.

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

Pasos siguientes

En este artículo, usó tareas de ACR para crear un flujo de trabajo controlado automatizado para introducir en el entorno imágenes base actualizadas. Consulte la información relacionada para administrar las imágenes en Azure Container Registry.

Share via

Consumo y mantenimiento de contenido público con Azure Container Registry Tasks

Información general de escenario

Requisitos previos

Establecimiento de variables de entorno

Tokens y repositorios de Git

Credenciales de Docker Hub

Creación de registros

Creación de un almacén de claves y establecimiento de secretos

Creación de un grupo de recursos para una instancia de contenedor de Azure

Creación de una imagen `node` base pública

Creación de la imagen `hello-world`

Creación de un token para acceso de extracción en un registro público simulado

Creación de un token para acceso de extracción a través de Azure Container Instances

Creación de una tarea para crear y mantener una imagen `hello-world`

Actualización de la imagen base con un cambio "cuestionable"

Registro

Importaciones controladas de contenido público

Incorporación de pruebas de automatización

Código YAML para las tareas

Creación de una tarea para importar y probar una imagen base

Actualización de la imagen `hello-world` para crear a partir de la imagen `node` controlada

Actualización de la imagen base con un cambio "válido"

Visualización del flujo de trabajo controlado

Publicación de una actualización de `hello-world`

Limpieza

Pasos siguientes

Recursos adicionales

Share via

Consumo y mantenimiento de contenido público con Azure Container Registry Tasks

Información general de escenario

Requisitos previos

Establecimiento de variables de entorno

Tokens y repositorios de Git

Credenciales de Docker Hub

Creación de registros

Creación de un almacén de claves y establecimiento de secretos

Creación de un grupo de recursos para una instancia de contenedor de Azure

Creación de una imagen node base pública

Creación de la imagen hello-world

Creación de un token para acceso de extracción en un registro público simulado

Creación de un token para acceso de extracción a través de Azure Container Instances

Creación de una tarea para crear y mantener una imagen hello-world

Actualización de la imagen base con un cambio "cuestionable"

Registro

Importaciones controladas de contenido público

Incorporación de pruebas de automatización

Código YAML para las tareas

Creación de una tarea para importar y probar una imagen base

Actualización de la imagen hello-world para crear a partir de la imagen node controlada

Actualización de la imagen base con un cambio "válido"

Visualización del flujo de trabajo controlado

Publicación de una actualización de hello-world

Limpieza

Pasos siguientes

Recursos adicionales

Creación de una imagen `node` base pública

Creación de la imagen `hello-world`

Creación de una tarea para crear y mantener una imagen `hello-world`

Actualización de la imagen `hello-world` para crear a partir de la imagen `node` controlada

Publicación de una actualización de `hello-world`