Consumo y mantenimiento de contenido público con Azure Container Registry Tasks
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:
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.
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 instancia de Docker Hub (
- Una tarea de ACR en cada registro. Las tareas:
- Crean una imagen
node
pública simulada. - Importan y validan la imagen
node
al registro compartido de la empresa o del equipo. - Crean e implementan la imagen
hello-world
.
- Crean una imagen
- 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
.
En los pasos siguientes se configuran los valores de los recursos que se crean y usan en el tutorial.
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 colocar estas variables en un único grupo de recursos si 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
Para simular su entorno, debe bifurcar cada uno de estos repositorios de Git en repositorios que pueda administrar.
- https://github.com/importing-public-content/base-image-node.git
- https://github.com/importing-public-content/import-baseimage-node.git
- https://github.com/importing-public-content/hello-world.git
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>
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>
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
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
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
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
Cree una imagen hello-world
en función de la imagen node
pública simulada.
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)
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)
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.
En esta sección se simula un cambio en la imagen base que podría causar problemas en el entorno.
- Abra
Dockerfile
en el repositoriobase-image-node
bifurcado. - Cambie
BACKGROUND_COLOR
aOrange
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).
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.
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.
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}
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}}"
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
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
- Abra
Dockerfile
en el repositoriobase-image-node
. - Cambie
BACKGROUND_COLOR
aGreen
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).
Repita los pasos de la sección anterior con un color de fondo rojo.
- Abra
Dockerfile
en el repositoriobase-image-node
. - Cambie
BACKGROUND_COLOR
aRed
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
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
.
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
En este artículo, ha usado tareas de ACR para crear un flujo de trabajo de acceso automatizado para introducir imágenes base actualizadas en su entorno. Consulte la información relacionada para administrar las imágenes en Azure Container Registry.