Openbare inhoud gebruiken en onderhouden met Azure Container Registry-taken

Dit artikel bevat een voorbeeldwerkstroom in Azure Container Registry om u te helpen bij het beheren van het gebruik en onderhoud van openbare inhoud:

1. Lokale kopieën van afhankelijke openbare installatiekopieën importeren.
2. Valideer openbare installatiekopieën door middel van beveiligingsscans en functionele tests.
3. De installatiekopieën promoveren naar privéregisters voor intern gebruik.
4. Updates van basisinstallatiekopieën activeren voor toepassingen die afhankelijk zijn van openbare inhoud.
5. Gebruik Azure Container Registry Tasks om deze werkstroom te automatiseren.

De werkstroom wordt samengevat in de volgende afbeelding:

De gated importwerkstroom helpt bij het beheren van de afhankelijkheden van uw organisatie op extern beheerde artefacten, bijvoorbeeld installatiekopieën die afkomstig zijn uit openbare registers, waaronder Docker Hub, GCR, Quay, GitHub Container Registry, Microsoft Container Registry of zelfs andere Azure-containerregisters.

Voor achtergrondinformatie over de risico's die worden veroorzaakt door afhankelijkheden van openbare inhoud en hoe u Azure Container Registry kunt gebruiken om deze te beperken, raadpleegt u het blogbericht OCI-verbruiken van openbare inhoud en Openbare inhoud beheren met Azure Container Registry.

U kunt de Azure Cloud Shell of een lokale installatie van de Azure CLI gebruiken om dit scenario te voltooien. Azure CLI versie 2.10 of hoger wordt aanbevolen. Zie Azure CLI installeren als u de CLI wilt installeren of een upgrade wilt uitvoeren.

Overzicht van scenario's

In dit scenario wordt het volgende ingesteld:

1. Drie containerregisters, die het volgende vertegenwoordigen:
   • Een gesimuleerde Docker Hub (publicregistry) ter ondersteuning van het wijzigen van de basisinstallatiekopieën
   • Teamregister (contoso) om persoonlijke installatiekopieën te delen
   • Gedeeld bedrijfs-/teamregister (baseartifacts) voor geïmporteerde openbare inhoud
2. Een ACR-taak in elk register. De taken:
   1. Een gesimuleerde openbare node installatiekopieën bouwen
   2. De installatiekopieën node importeren en valideren in het gedeelde bedrijfs-/teamregister
   3. De installatiekopieën hello-world bouwen en implementeren
3. ACR-taakdefinities, inclusief configuraties voor:
4. Een verzameling registerreferenties, die verwijzen naar een sleutelkluis
5. Een verzameling geheimen, beschikbaar in een acr-task.yaml, die verwijzen naar een sleutelkluis
6. Een verzameling geconfigureerde waarden die worden gebruikt in een acr-task.yaml
7. Een Azure-sleutelkluis om alle geheimen te beveiligen
8. Een Azure-containerinstantie die als host fungeert voor de hello-world buildtoepassing

Vereisten

Met de volgende stappen worden waarden geconfigureerd voor resources die in het overzicht zijn gemaakt en gebruikt.

Omgevingsvariabelen instellen

Configureer variabelen die uniek zijn voor uw omgeving. We volgen aanbevolen procedures voor het plaatsen van resources met duurzame inhoud in hun eigen resourcegroep om onbedoeld verwijderen te minimaliseren. U kunt deze echter desgewenst in één resourcegroep plaatsen.

De voorbeelden in dit artikel zijn opgemaakt voor de bash-shell.

# 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-opslagplaatsen en -tokens

Als u uw omgeving wilt simuleren, forkt u elk van de volgende Git-opslagplaatsen in opslagplaatsen die u kunt beheren.

• 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

Werk vervolgens de volgende variabelen bij voor uw gevorkte opslagplaatsen.

De :main toegevoegd aan het einde van de git-URL's vertegenwoordigt de standaardopslagplaatsbranch.

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

U hebt een GitHub-toegangstoken (PAT) nodig voor ACR Tasks om Git-webhooks te klonen en tot stand te brengen. Zie Een GitHub-toegangstoken maken voor stappen voor het maken van een token met de vereiste machtigingen voor een privéopslagplaats.

GIT_TOKEN=<set-git-token-here>

Docker Hub referenties

Maak een Docker Hub-token om beperking en identiteitsaanvragen te voorkomen bij het ophalen van installatiekopieën uit Docker Hub. Stel vervolgens de volgende omgevingsvariabelen in:

REGISTRY_DOCKERHUB_USER=<yourusername>
REGISTRY_DOCKERHUB_PASSWORD=<yourtoken>

Registers maken

Maak met behulp van Azure CLI-opdrachten drie containerregisters van de Premium-laag, elk in een eigen resourcegroep:

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

Sleutelkluis maken en geheimen instellen

Een sleutelkluis maken:

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

Stel Docker Hub gebruikersnaam en token in de sleutelkluis in:

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

Stel een Git PAT in de sleutelkluis in en controleer deze:

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

Resourcegroep maken voor een Azure-containerinstantie

Deze resourcegroep wordt gebruikt in een latere taak bij het implementeren van de hello-world installatiekopieën.

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

node Openbare basisinstallatiekopieën maken

Als u de installatiekopieën node op Docker Hub wilt simuleren, maakt u een ACR-taak om de openbare installatiekopieën te bouwen en te onderhouden. Met deze instelling kunt u wijzigingen door de onderhouders van de node installatiekopieën simuleren.

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

Als u Docker-beperking wilt voorkomen, voegt u Docker Hub referenties toe aan de taak. De opdracht acr-taakreferenties kan worden gebruikt om Docker-referenties door te geven aan elk register, inclusief 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]

De taak toegang verlenen tot het lezen van waarden uit de sleutelkluis:

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

Taken kunnen worden geactiveerd door Git-doorvoeringen, updates van basisinstallatiekopieën, timers of handmatige uitvoeringen.

Voer de taak handmatig uit om de installatiekopieën node te genereren:

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

Vermeld de installatiekopieën in het gesimuleerde openbare register:

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

De installatiekopieën maken hello-world

Maak een installatiekopieën op basis van de gesimuleerde openbare node installatiekopieën hello-world .

Token maken voor pull-toegang tot gesimuleerd openbaar register

Maak een toegangstoken voor het gesimuleerde openbare register, met pullals bereik . Stel deze vervolgens in de sleutelkluis in:

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)

Token maken voor pull-toegang per Azure Container Instances

Maak een toegangstoken voor het register dat als host fungeert voor de hello-world installatiekopie, binnen het bereik van pull. Stel deze vervolgens in de sleutelkluis in:

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)

Taak maken om installatiekopieën te bouwen en te onderhouden hello-world

Met de volgende opdracht maakt u een taak op basis van de definitie in acr-tasks.yaml de hello-world opslagplaats. Met de taakstappen wordt de hello-world installatiekopieën gebouwd en vervolgens geïmplementeerd in Azure Container Instances. De resourcegroep voor Azure Container Instances is in een vorige sectie gemaakt. Door de taak aan te roepen az container create met slechts een verschil in de image:tag, wordt de taak in dit scenario geïmplementeerd op hetzelfde exemplaar.

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

Voeg referenties toe aan de taak voor het gesimuleerde openbare register:

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]

De taak toegang verlenen tot het lezen van waarden uit de sleutelkluis:

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

Geef de taak toegang tot het maken en beheren van Azure Container Instances door toegang te verlenen tot de resourcegroep:

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

Terwijl de taak is gemaakt en geconfigureerd, voert u de taak uit om de hello-world installatiekopieën te bouwen en te implementeren:

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

Nadat de installatiekopie is gemaakt, haalt u het IP-adres op van de container die als host fungeert voor de hello-world installatiekopie.

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

Ga in uw browser naar het IP-adres om de actieve toepassing te zien.

De basisinstallatiekopieën bijwerken met een 'twijfelachtige' wijziging

In deze sectie wordt een wijziging in de basisinstallatiekopieën gesimuleerd die problemen in de omgeving kan veroorzaken.

1. Open Dockerfile in de gevorkte base-image-node opslagplaats.
2. Wijzig de BACKGROUND_COLOR in Orange om de wijziging te simuleren.

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

Voer de wijziging door en kijk of ACR-taken automatisch beginnen met bouwen.

Let op de taak die moet worden uitgevoerd:

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

Uiteindelijk ziet u status Succeeded op basis van een TRIGGER van Commit:

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

Typ Ctrl+C om de opdracht watch af te sluiten en bekijk vervolgens de logboeken voor de meest recente uitvoering:

az acr task logs -r $REGISTRY_PUBLIC

Zodra de node installatiekopieën zijn voltooid, watch begint ACR Tasks automatisch met het bouwen van de hello-world installatiekopieën:

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

Uiteindelijk ziet u status Succeeded op basis van een TRIGGER van 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

Typ Ctrl+C om de opdracht watch af te sluiten en bekijk vervolgens de logboeken voor de meest recente uitvoering:

az acr task logs -r $REGISTRY

Zodra dit is voltooid, haalt u het IP-adres op van de site die als host fungeert voor de bijgewerkte hello-world installatiekopie:

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

Ga in uw browser naar de site, die een oranje (twijfelachtige) achtergrond moet hebben.

Inchecken

Op dit moment hebt u een installatiekopieën hello-world gemaakt die automatisch wordt gebouwd op Git-doorvoeringen en wijzigingen in de basisinstallatiekopieën node . In dit voorbeeld wordt de taak gebouwd op basis van een basisinstallatiekopieën in Azure Container Registry, maar elk ondersteund register kan worden gebruikt.

Met de update van de basisinstallatiekopie wordt de taak automatisch opnieuw geactiveerd wanneer de node installatiekopie wordt bijgewerkt. Zoals hier wordt weergegeven, zijn niet alle updates gewenst.

Beperkte import van openbare inhoud

Om te voorkomen dat upstreamwijzigingen kritieke workloads breken, kunnen beveiligingsscans en functionele tests worden toegevoegd.

In deze sectie maakt u een ACR-taak voor het volgende:

• Een testinstallatiekopieën bouwen
• Een functioneel testscript ./test.sh uitvoeren op basis van de testafbeelding
• Als de installatiekopie is getest, importeert u de openbare installatiekopie in het baseimages-register

Automatiseringstests toevoegen

Om upstream-inhoud te gateen, worden geautomatiseerde tests geïmplementeerd. In dit voorbeeld wordt een test.sh opgegeven waarmee de $BACKGROUND_COLORwordt gecontroleerd. Als de test mislukt, wordt een EXIT_CODE van 1 geretourneerd, waardoor de ACR-taakstap mislukt, waardoor de taakuitvoering wordt beëindigd. De tests kunnen worden uitgebreid in elke vorm van hulpprogramma's, inclusief logboekregistratieresultaten. De poort wordt beheerd door een pass/fail-antwoord in het script, dat hier wordt gereproduceerd:

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}

Taak-YAML

Controleer de acr-task.yaml in de import-baseimage-node opslagplaats, die de volgende stappen uitvoert:

1. Bouw de testbasisinstallatiekopieën met behulp van het volgende Dockerfile:

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

2. Wanneer u klaar bent, valideert u de installatiekopieën door de container uit te voeren, die wordt uitgevoerd ./test.sh
3. Alleen als dit is voltooid, voert u de importstappen uit, die zijn gegateerd met 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}}"

Een taak maken om de basisinstallatiekopieën te importeren en te testen

  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

Voeg referenties toe aan de taak voor het gesimuleerde openbare register:

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]

De taak toegang verlenen tot het lezen van waarden uit de sleutelkluis:

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

Voer de importtaak uit:

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

Notitie

Als de taak mislukt vanwege ./test.sh: Permission denied, zorgt u ervoor dat het script uitvoeringsmachtigingen heeft en voert u deze terug naar de Git-opslagplaats:

chmod +x ./test.sh

Installatiekopieën hello-world bijwerken om te bouwen op basis van gated node image

Maak een toegangstoken voor toegang tot het register met basisartefacten vanuit read de node opslagplaats. Stel vervolgens in de sleutelkluis het volgende in:

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)

Voeg referenties toe aan de hello-world-taak voor het register met basisartefacten:

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]

De taak bijwerken om de REGISTRY_FROM_URL te wijzigen zodat het BASE_ARTIFACTS register wordt gebruikt

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

Voer de hello-world-taak uit om de afhankelijkheid van de basisinstallatiekopie te wijzigen:

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

De basisinstallatiekopieën bijwerken met een 'geldige' wijziging

1. Open de Dockerfile in base-image-node de opslagplaats.
2. Wijzig de BACKGROUND_COLOR in Green om een geldige wijziging te simuleren.

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

Voer de wijziging door en bewaak de volgorde van updates:

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

Wanneer u dit uitvoert, typt u Ctrl+C en controleert u de logboeken:

az acr task logs -r $REGISTRY_PUBLIC

Zodra dit is voltooid, controleert u de taak base-image-import :

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

Wanneer u dit uitvoert, typt u Ctrl+C en controleert u de logboeken:

az acr task logs -r $REGISTRY_BASE_ARTIFACTS

Wanneer u klaar bent, controleert u de hallo wereldtaak :

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

Wanneer u dit uitvoert, typt u Ctrl+C en controleert u de logboeken:

az acr task logs -r $REGISTRY

Zodra dit is voltooid, haalt u het IP-adres op van de site die als host fungeert voor de bijgewerkte hello-world installatiekopie:

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

Ga in uw browser naar de site, die een groene (geldige) achtergrond moet hebben.

De beperkte werkstroom weergeven

Voer de stappen in de vorige sectie opnieuw uit, met een rode achtergrondkleur.

1. Open de Dockerfile in de base-image-node opslagplaats
2. Wijzig de BACKGROUND_COLOR in om Red een ongeldige wijziging te simuleren.

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

Voer de wijziging door en bewaak de volgorde van updates:

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

Wanneer u dit uitvoert, typt u Ctrl+C en controleert u de logboeken:

az acr task logs -r $REGISTRY_PUBLIC

Zodra dit is voltooid, controleert u de taak base-image-import :

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

Wanneer u dit uitvoert, typt u Ctrl+C en controleert u de logboeken:

az acr task logs -r $REGISTRY_BASE_ARTIFACTS

Op dit moment ziet u dat de validatie van de taak base-import-node mislukt en de reeks voor het publiceren van een hello-world update stopt. De uitvoer ziet er ongeveer zo uit:

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

Een update publiceren naar hello-world

Wijzigingen in de installatiekopieën hello-world blijven de laatst gevalideerde node installatiekopieën gebruiken.

Eventuele aanvullende wijzigingen in de basisinstallatiekopieën node die de gated-validaties passeren, activeren updates van de basisinstallatiekopieën voor de hello-world installatiekopieën.

Opschonen

Verwijder de resources die in dit artikel worden gebruikt wanneer u deze niet meer nodig hebt.

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

Volgende stappen

In dit artikel. U hebt ACR-taken gebruikt om een geautomatiseerde beperkingswerkstroom te maken om bijgewerkte basisinstallatiekopieën in uw omgeving te introduceren. Zie gerelateerde informatie voor het beheren van afbeeldingen in Azure Container Registry.

• Aanbevelingen voor het taggen en versiebeheer van containerinstallatiekopieën
• Een containerinstallatiekopieën in een Azure-containerregister vergrendelen