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

2025-04-02

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:

Importera lokala kopior av beroende offentliga bilder.
Verifiera offentliga avbildningar genom säkerhetsgenomsökning och funktionell testning.
Flytta upp avbildningarna till privata register för intern användning.
Utlösa basavbildningsuppdateringar för program som är beroende av offentligt innehåll.
Använd Azure Container Registry Tasks för att automatisera det här arbetsflödet.

Arbetsflödet sammanfattas i följande bild:

Arbetsflöde för konsumtion av offentligt innehåll

Arbetsflödet för gated import hjälper dig att hantera organisationens beroenden för externt hanterade artefakter – till exempel avbildningar som hämtats 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 för 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.

Scenarioöversikt

importera arbetsflödeskomponenter

Den här genomgången konfigurerar:

Tre containerregister, som representerar:
- En simulerad Docker Hub (publicregistry) som stöder ändring av basavbildningen
- Teamregister (contoso) för att dela privata avbildningar
- Företags-/teamdelade register (baseartifacts) för importerat offentligt innehåll
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
ACR-uppgiftsdefinitioner, inklusive konfigurationer för:
- En samling registerautentiseringsuppgifter, som är pekare till ett nyckelvalv
- En samling hemligheter som är tillgängliga i en acr-task.yaml och som fungerar som pekare till ett nyckelvalv.
- En samling konfigurerade värden som används i en acr-task.yaml
Ett Azure-nyckelvalv för att skydda alla hemligheter
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 skapas 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 beständigt innehåll i en egen resursgrupp för att minimera oavsiktlig borttagning. Du kan dock placera dessa variabler 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-uppgifter 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 avbildningar 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 en 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 Användarnamn och token för Docker Hub 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 node på Docker Hub skapar du en ACR-uppgift för att skapa och underhålla den offentliga avbildningen. Den här konfigurationen möjliggör simulering av ändringar av node avbildningsunderhållarna.

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 begränsningar från Docker lägger du till Docker Hub-inloggningsuppgifter 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, basavbildningsuppdateringar, 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

Lista avbildningen i det simulerade offentliga registret.

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

Skapa avbildningen `hello-world`

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

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

Skapa en åtkomsttoken till det simulerade offentliga registret, begränsat till pull. Placera 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 av Azure Container Instances

Skapa en åtkomsttoken till registret som är värd för avbildningen hello-world , som ska hämtas. Placera 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 att konstruera och underhålla avbild `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 uppgiften med bara en skillnad i image:tag distribueras uppgiften 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 för 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

Bevilja 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 programmet 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.

Öppna Dockerfile i den förgrenade lagringsplatsen base-image-node .
Ändra BACKGROUND_COLOR till Orange för att simulera ändringen.

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

Genomför ändringen och håll utkik efter att ACR-uppgifter automatiskt börjar bygga.

Vänta på att uppgiften ska börja köras:

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

Du bör så småningom se STATUS Succeeded baserat på en TRIGGEr av 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 är klar 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 TRIGGEr av 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 webbplats 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 (tvivelaktig) 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.

Uppdatering av basbild utlöser automatiskt aktivitetskörningen igen när avbildningen node uppdateras. Som vi ser här är inte alla uppdateringar önskade.

Kontrollerad 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 framgångsrikt, importerar du den offentliga avbildningen till baseimages-registret

Lägga till automatiseringstestning

Automatiserad testning implementeras för att begränsa åtkomsten till uppströmsinnehåll. I det här exemplet anges en test.sh som kontrollerar $BACKGROUND_COLOR. Om testet misslyckas returneras en EXIT_CODE av 1, vilket gör att ACR-arbetsuppgiftssteget misslyckas och avslutar arbetsuppgiftskö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}

Aktivitets-YAML

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

Skapa testbasavbildningen med hjälp av följande Dockerfile:

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

När du är klar verifierar du avbildningen genom att köra containern som kör ./test.sh
Kör importstegen endast om de har slutförts framgångsrikt, vilka ä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 basavbildningen

  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 för 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

Kommentar

Om uppgiften misslyckas på grund av ./test.sh: Permission denied, kontrollera att skriptet har körningsbehörigheter och återställ till Git-lagringsplatsen.

chmod +x ./test.sh

Uppdatera `hello-world` avbildningen för att bygga från den begränsade `node` avbildningen

Skapa en åtkomsttoken för att komma åt base-artifacts-registret, som är 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 för hello-world-uppgiften i basartifaktregistret.

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 till att använda BASE_ARTIFACTS-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 basavbildningsberoendet:

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

Uppdatera basavbildningen med en "giltig" ändring

Öppna Dockerfile i base-image-node repo.
Ändra BACKGROUND_COLOR till Green för 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 webbplats 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 avgränsade arbetsflödet

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

Öppna Dockerfile i base-image-node-lagringsplatsen
Ändra BACKGROUND_COLOR till Red för 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

Vid det här laget bör du se att uppgiften base-import-node misslyckas i valideringen och att sekvensen stoppas för att publicera en hello-world uppdatering. Utdata ser ut som 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 i basavbildningen node som passerar de gated valideringarna uppdaterar basavbildningen 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 använde du ACR-tasker för att skapa ett automatiserat regleringsarbetsflöde för att introducera uppdaterade basbilder i din miljö. Se relaterad information för att hantera avbildningar i Azure Container Registry.

Feedback

Var den här sidan till hjälp?

Dela via

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

Scenarioöversikt

Förutsättningar

Ange miljövariabler

Git-lagringsplatser och -token

Docker Hub-autentiseringsuppgifter

Skapa register

Skapa nyckelvalv och ange hemligheter

Skapa resursgrupp för en Azure-containerinstans

Skapa en offentlig node basavbildning

Skapa avbildningen hello-world

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

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

Skapa uppgift att konstruera och underhålla avbild hello-world

Uppdatera basavbildningen med en "tvivelaktig" ändring

Checka in

Kontrollerad import av offentligt innehåll

Lägga till automatiseringstestning

Aktivitets-YAML

Skapa uppgift för att importera och testa basavbildningen

Uppdatera hello-world avbildningen för att bygga från den begränsade node avbildningen

Uppdatera basavbildningen med en "giltig" ändring

Visa det avgränsade arbetsflödet

Publicera en uppdatering till hello-world

Rensning

Nästa steg

Feedback

Ytterligare resurser

Skapa en offentlig `node` basavbildning

Skapa avbildningen `hello-world`

Skapa uppgift att konstruera och underhålla avbild `hello-world`

Uppdatera `hello-world` avbildningen för att bygga från den begränsade `node` avbildningen

Publicera en uppdatering till `hello-world`