Så här använder och underhåller du offentligt innehåll med Azure Container Registry uppgifter

  • Artikel

Den här artikeln innehåller ett exempelarbetsflöde i Azure Container Registry som hjälper dig att hantera användning och underhåll av offentligt innehåll:

  1. Importera lokala kopior av beroende offentliga avbildningar.
  2. Verifiera offentliga avbildningar genom säkerhetsgenomsökning och funktionstestning.
  3. Höj upp avbildningarna till privata register för intern användning.
  4. Utlösa basavbildningsuppdateringar för program som är beroende av offentligt innehåll.
  5. Använd Azure Container Registry Uppgifter för att automatisera det här arbetsflödet.

Arbetsflödet sammanfattas i följande bild:

Använda arbetsflöde för offentligt innehåll

Arbetsflödet för gated import hjälper dig att hantera organisationens beroenden för externt hanterade artefakter, till exempel avbildningar från offentliga register, inklusive Docker Hub, GCR, Quay, GitHub Container Registry, Microsoft Container Registry eller till och med andra Azure-containerregister.

Bakgrund om riskerna med beroenden av offentligt innehåll och hur du använder Azure Container Registry för att minimera dem finns i blogginlägget om OCI-användning av offentligt innehåll och Hantera offentligt innehåll med Azure Container Registry.

Du kan använda Azure Cloud Shell eller en lokal installation av Azure CLI för att slutföra den här genomgången. Azure CLI version 2.10 eller senare rekommenderas. Om du behöver installera eller uppgradera kan du läsa Installera Azure CLI.

Översikt över scenario

importera arbetsflödeskomponenter

Den här genomgången konfigurerar:

  1. Tre containerregister, som representerar:
    • En simulerad Docker Hub (publicregistry) som stöder ändring av basavbildningen
    • Teamregister (contoso) för att dela privata avbildningar
    • Delat register för företag/team (baseartifacts) för importerat offentligt innehåll
  2. En ACR-uppgift i varje register. Uppgifterna:
    1. Skapa en simulerad offentlig node avbildning
    2. Importera och verifiera avbildningen node till det delade registret för företag/team
    3. Skapa och distribuera avbildningen hello-world
  3. ACR-uppgiftsdefinitioner, inklusive konfigurationer för:
  4. En samling registerautentiseringsuppgifter, som är pekare till ett nyckelvalv
  5. En samling hemligheter som är tillgängliga i en acr-task.yaml, som är pekare till ett nyckelvalv
  6. En samling konfigurerade värden som används i en acr-task.yaml
  7. Ett Azure-nyckelvalv för att skydda alla hemligheter
  8. En Azure-containerinstans som är värd för hello-world byggprogrammet

Förutsättningar

Följande steg konfigurerar värden för resurser som skapats och används i genomgången.

Ange miljövariabler

Konfigurera variabler som är unika för din miljö. Vi följer metodtipsen för att placera resurser med varaktigt innehåll i sin egen resursgrupp för att minimera oavsiktlig borttagning. Du kan dock placera dessa i en enda resursgrupp om du vill.

Exemplen i den här artikeln är formaterade för bash-gränssnittet.

# 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

Git-lagringsplatser och -token

Om du vill simulera din miljö förgrenar du var och en av följande Git-lagringsplatser till lagringsplatser som du kan hantera.

Uppdatera sedan följande variabler för dina förgrenade lagringsplatser.

Den :main som läggs till i slutet av git-URL:erna representerar standardlagringsplatsgrenen.

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

Du behöver en GitHub-åtkomsttoken (PAT) för ACR Tasks för att klona och upprätta Git-webhooks. Anvisningar för hur du skapar en token med de behörigheter som krävs för en privat lagringsplats finns i Skapa en GitHub-åtkomsttoken.

GIT_TOKEN=<set-git-token-here>

Docker Hub autentiseringsuppgifter

Skapa en Docker Hub token för att undvika begränsningar och identitetsbegäranden när du hämtar bilder från Docker Hub. Ange sedan följande miljövariabler:

REGISTRY_DOCKERHUB_USER=<yourusername>
REGISTRY_DOCKERHUB_PASSWORD=<yourtoken>

Skapa register

Använd Azure CLI-kommandon och skapa tre containerregister på Premium-nivå, var och en i sin egen resursgrupp:

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

Skapa nyckelvalv och ange hemligheter

Skapa ett nyckelvalv:

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

Ange Docker Hub användarnamn och token i nyckelvalvet:

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

Ange och verifiera en Git PAT i nyckelvalvet:

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

Skapa resursgrupp för en Azure-containerinstans

Den här resursgruppen används i en senare aktivitet när avbildningen distribueras hello-world .

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

Skapa en offentlig node basavbildning

Om du vill simulera avbildningen på node Docker Hub skapar du en ACR-uppgift för att skapa och underhålla den offentliga avbildningen. Den här konfigurationen gör det möjligt att simulera ändringar av avbildningsunderhållarna 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

För att undvika Docker-begränsning lägger du till Docker Hub autentiseringsuppgifter i uppgiften. Kommandot acr task credentials kan användas för att skicka Docker-autentiseringsuppgifter till alla register, inklusive 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]

Ge uppgiften åtkomst till läsvärden från nyckelvalvet:

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

Aktiviteter kan utlösas av Git-incheckningar, uppdateringar av basavbildningar, timers eller manuella körningar.

Kör uppgiften manuellt för att generera avbildningen node :

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

Visa en lista över avbildningen i det simulerade offentliga registret:

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

Skapa avbildningen hello-world

Skapa en hello-world avbildning baserat på den simulerade offentliga node avbildningen.

Skapa token för pull-åtkomst till simulerat offentligt register

Skapa en åtkomsttoken till det simulerade offentliga registret, begränsat till pull. Ange den sedan i nyckelvalvet:

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)

Skapa token för pull-åtkomst via Azure Container Instances

Skapa en åtkomsttoken till registret som är värd för avbildningen hello-world och som ska hämtas. Ange den sedan i nyckelvalvet:

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)

Skapa uppgift för att skapa och underhålla avbildning hello-world

Följande kommando skapar en uppgift från definitionen i acr-tasks.yaml på lagringsplatsen hello-world . Aktivitetsstegen skapar avbildningen hello-world och distribuerar den sedan till Azure Container Instances. Resursgruppen för Azure Container Instances skapades i ett tidigare avsnitt. Genom att anropa az container create i aktiviteten med bara en skillnad i image:tagdistribueras aktiviteten till samma instans under den här genomgången.

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

Lägg till autentiseringsuppgifter i uppgiften för det simulerade offentliga registret:

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]

Ge uppgiften åtkomst till läsvärden från nyckelvalvet:

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

Ge uppgiften åtkomst för att skapa och hantera Azure Container Instances genom att ge åtkomst till resursgruppen:

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

När uppgiften har skapats och konfigurerats kör du uppgiften för att skapa och distribuera avbildningen hello-world :

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

När du har skapat den hämtar du IP-adressen för containern som är värd för avbildningen hello-world .

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

I webbläsaren går du till IP-adressen för att se det program som körs.

Uppdatera basavbildningen med en "tvivelaktig" ändring

Det här avsnittet simulerar en ändring av basavbildningen som kan orsaka problem i miljön.

  1. Öppna Dockerfile i den förgrenade lagringsplatsen base-image-node .
  2. BACKGROUND_COLOR Ändra till för Orange att simulera ändringen.
ARG REGISTRY_NAME=
FROM ${REGISTRY_NAME}node:15-alpine
ENV NODE_VERSION 15-alpine
ENV BACKGROUND_COLOR Orange

Checka in ändringen och håll utkik efter att ACR-uppgifter ska börja byggas automatiskt.

Se upp för uppgiften att börja köra:

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

Du bör så småningom se STATUS Succeeded baserat på en UTLÖSARE för Commit:

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

Skriv Ctrl+C för att avsluta klockkommandot och visa sedan loggarna för den senaste körningen:

az acr task logs -r $REGISTRY_PUBLIC

När avbildningen node har slutförts watch kan ACR Tasks automatiskt börja skapa avbildningen hello-world :

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

Du bör så småningom se STATUS Succeeded baserat på en UTLÖSARE för 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

Skriv Ctrl+C för att avsluta klockkommandot och visa sedan loggarna för den senaste körningen:

az acr task logs -r $REGISTRY

När du är klar hämtar du IP-adressen för den plats som är värd för den uppdaterade hello-world avbildningen:

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

I webbläsaren går du till webbplatsen, som ska ha en orange (tveksam) bakgrund.

Checka in

Nu har du skapat en hello-world avbildning som automatiskt bygger på Git-incheckningar och ändringar i basavbildningen node . I det här exemplet skapas uppgiften mot en basavbildning i Azure Container Registry, men alla register som stöds kan användas.

Basavbildningsuppdateringen återaktiverar automatiskt aktiviteten när avbildningen node uppdateras. Som vi ser här är inte alla uppdateringar önskade.

Gated import av offentligt innehåll

För att förhindra att överordnade ändringar bryter mot kritiska arbetsbelastningar kan säkerhetsgenomsökning och funktionstester läggas till.

I det här avsnittet skapar du en ACR-uppgift för att:

  • Skapa en testbild
  • Köra ett funktionellt testskript ./test.sh mot testbilden
  • Om avbildningen testas korrekt importerar du den offentliga avbildningen till baseimages-registret

Lägga till automatiseringstestning

Automatiserad testning implementeras för att gate allt uppströmsinnehåll. I det här exemplet tillhandahålls en test.sh som kontrollerar $BACKGROUND_COLOR. Om testet misslyckas returneras en EXIT_CODE av 1 som gör att ACR-aktivitetssteget misslyckas, vilket avslutar aktivitetskörningen. Testerna kan utökas i valfri form av verktyg, inklusive loggningsresultat. Grinden hanteras av ett pass/fail-svar i skriptet, som återges här:

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}

Uppgift YAML

acr-task.yaml Granska i import-baseimage-node lagringsplatsen, som utför följande steg:

  1. Skapa testbasavbildningen med följande Dockerfile:
    ARG REGISTRY_FROM_URL=
FROM ${REGISTRY_FROM_URL}node:15-alpine
WORKDIR /test
COPY ./test.sh .
CMD ./test.sh
  2. När du är klar verifierar du avbildningen genom att köra containern, som körs ./test.sh
  3. Kör endast importstegen, som är gated med 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}}"

Skapa uppgift för att importera och testa basavbildning

  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

Lägg till autentiseringsuppgifter i uppgiften för det simulerade offentliga registret:

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]

Ge uppgiften åtkomst till läsvärden från nyckelvalvet:

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

Kör importaktiviteten:

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

Anteckning

Om uppgiften misslyckas på grund av ./test.sh: Permission deniedkontrollerar du att skriptet har körningsbehörigheter och checkar tillbaka till Git-lagringsplatsen:

chmod +x ./test.sh

Uppdatera hello-world avbildningen för att skapa från gated node image

Skapa en åtkomsttoken för att komma åt base-artifacts-registret, begränsat till read från lagringsplatsen node . Ange sedan i nyckelvalvet:

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)

Lägg till autentiseringsuppgifter i hello-world-uppgiften för basartefaktregistret:

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]

Uppdatera uppgiften för att ändra REGISTRY_FROM_URL så att den BASE_ARTIFACTS använder registret

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

Kör hello-world-uppgiften för att ändra dess basavbildningsberoende:

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

Uppdatera basavbildningen med en "giltig" ändring

  1. Öppna lagringsplatsen Dockerfilebase-image-node .
  2. BACKGROUND_COLOR Ändra till för Green att simulera en giltig ändring.
ARG REGISTRY_NAME=
FROM ${REGISTRY_NAME}node:15-alpine
ENV NODE_VERSION 15-alpine
ENV BACKGROUND_COLOR Green

Genomför ändringen och övervaka uppdateringssekvensen:

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

När du har kört skriver du Ctrl+C och övervakar loggarna:

az acr task logs -r $REGISTRY_PUBLIC

När du är klar övervakar du uppgiften base-image-import :

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

När du har kört skriver du Ctrl+C och övervakar loggarna:

az acr task logs -r $REGISTRY_BASE_ARTIFACTS

När du är klar övervakar du hello-world-uppgiften :

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

När du har kört skriver du Ctrl+C och övervakar loggarna:

az acr task logs -r $REGISTRY

När du är klar hämtar du IP-adressen för den plats som är värd för den uppdaterade hello-world avbildningen:

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

I webbläsaren går du till webbplatsen, som ska ha en grön (giltig) bakgrund.

Visa det gated workflow

Utför stegen i föregående avsnitt igen med bakgrundsfärgen röd.

  1. Dockerfile Öppna i lagringsplatsen base-image-node
  2. BACKGROUND_COLOR Ändra till för Red att simulera en ogiltig ändring.
ARG REGISTRY_NAME=
FROM ${REGISTRY_NAME}node:15-alpine
ENV NODE_VERSION 15-alpine
ENV BACKGROUND_COLOR Red

Genomför ändringen och övervaka uppdateringssekvensen:

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

När du har kört skriver du Ctrl+C och övervakar loggarna:

az acr task logs -r $REGISTRY_PUBLIC

När du är klar övervakar du uppgiften base-image-import :

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

När du har kört skriver du Ctrl+C och övervakar loggarna:

az acr task logs -r $REGISTRY_BASE_ARTIFACTS

Nu bör du se att aktiviteten base-import-node misslyckas och stoppa sekvensen för att publicera en hello-world uppdatering. Utdata liknar följande:

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

Publicera en uppdatering till hello-world

Ändringar i avbildningen hello-world fortsätter att använda den senast verifierade node avbildningen.

Eventuella ytterligare ändringar av basavbildningen node som skickar gated validations utlöser basavbildningsuppdateringar till avbildningen hello-world .

Rensning

Ta bort de resurser som används i den här artikeln när de inte längre behövs.

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

Nästa steg

I den här artikeln. du använde ACR-uppgifter för att skapa ett automatiserat gating-arbetsflöde för att introducera uppdaterade basavbildningar i din miljö. Se relaterad information för att hantera bilder i Azure Container Registry.