Jak využívat a udržovat veřejný obsah pomocí Azure Container Registry Tasks

Tento článek obsahuje ukázkový pracovní postup v Azure Container Registry, který vám pomůže spravovat využívání a údržbu veřejného obsahu:

1. Importujte místní kopie závislých veřejných imagí.
2. Ověřte veřejné image prostřednictvím kontroly zabezpečení a funkčního testování.
3. Zvyšte úroveň imagí na soukromé registry pro interní použití.
4. Aktivace aktualizací základní image pro aplikace závislé na veřejném obsahu
5. K automatizaci tohoto pracovního postupu použijte Azure Container Registry Úkoly.

Souhrn pracovního postupu najdete na následujícím obrázku:

Pracovní postup chráněného importu pomáhá spravovat závislosti vaší organizace na externě spravovaných artefaktech – například image z veřejných registrů, jako jsou Docker Hub, GCR, Quay, GitHub Container Registry, Microsoft Container Registry nebo dokonce jiné registry kontejnerů Azure.

Informace o rizicích, která s sebou nese závislosti na veřejném obsahu, a o tom, jak je pomocí Azure Container Registry zmírnit, najdete v blogovém příspěvku o využívání veřejného obsahu OCI a v článku Správa veřejného obsahu pomocí Azure Container Registry.

K dokončení tohoto návodu můžete použít Azure Cloud Shell nebo místní instalaci Azure CLI. Doporučuje se Azure CLI verze 2.10 nebo novější. Pokud potřebujete instalaci nebo upgrade, přečtěte si téma Instalace Azure CLI.

Přehled scénáře

Tento názorný postup nastaví:

1. Tři registry kontejnerů, které představují:
   • Simulovaná Docker Hub (publicregistry) pro podporu změny základní image
   • Týmový registr (contoso) pro sdílení privátních imagí
   • Sdílený registr společnosti nebo týmu (baseartifacts) pro importovaný veřejný obsah
2. Úloha ACR v každém registru. Úkoly:
   1. Vytvoření simulované veřejné node image
   2. Import a ověření node image do sdíleného registru společnosti nebo týmu
   3. Sestavení a nasazení hello-world image
3. Definice úloh ACR, včetně konfigurací pro:
4. Kolekce přihlašovacích údajů registru, které jsou ukazateli na trezor klíčů
5. Kolekce tajných kódů, které jsou k dispozici v rámci objektu acr-task.yaml, které jsou ukazateli na trezor klíčů
6. Kolekce nakonfigurovaných hodnot používaných v rámci acr-task.yaml
7. Trezor klíčů Azure pro zabezpečení všech tajných kódů
8. Instance kontejneru Azure, která je hostitelem hello-world aplikace sestavení

Požadavky

Následující postup nakonfiguruje hodnoty pro prostředky vytvořené a použité v návodu.

Nastavení proměnných prostředí

Nakonfigurujte proměnné jedinečné pro vaše prostředí. Dodržujeme osvědčené postupy pro umístění prostředků s trvalým obsahem do jejich vlastní skupiny prostředků, abychom minimalizovali náhodné odstranění. V případě potřeby je ale můžete umístit do jedné skupiny prostředků.

Příklady v tomto článku jsou formátované pro prostředí 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

Úložiště a tokeny Git

Pokud chcete simulovat prostředí, roz forkujte všechna následující úložiště Git do úložišť, která můžete spravovat.

• 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

Pak aktualizujte následující proměnné pro vaše forková úložiště.

Řetězec :main připojený na konec adres URL gitu představuje výchozí větev úložiště.

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

Ke klonování a vytváření webhooků Git potřebujete přístupový token (PAT) gitHubu pro ACR Tasks. Postup vytvoření tokenu s požadovanými oprávněními k privátnímu úložišti najdete v tématu Vytvoření přístupového tokenu GitHubu.

GIT_TOKEN=<set-git-token-here>

Docker Hub přihlašovacích údajů

Pokud chcete zabránit omezování a žádostem o identitu při načítání imagí z Docker Hub, vytvořte token Docker Hub. Pak nastavte následující proměnné prostředí:

REGISTRY_DOCKERHUB_USER=<yourusername>
REGISTRY_DOCKERHUB_PASSWORD=<yourtoken>

Vytváření registrů

Pomocí příkazů Azure CLI vytvořte tři registry kontejnerů úrovně Premium, každý ve vlastní skupině prostředků:

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

Vytvoření trezoru klíčů a nastavení tajných kódů

Vytvoření trezoru klíčů:

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

Nastavte uživatelské jméno a token Docker Hub v trezoru klíčů:

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

Nastavení a ověření tokenu PAT Gitu v trezoru klíčů:

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

Vytvoření skupiny prostředků pro instanci kontejneru Azure

Tato skupina prostředků se použije v pozdější úloze při nasazování hello-world image.

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

Vytvoření veřejné node základní image

Pokud chcete simulovat image na node Docker Hub, vytvořte úlohu ACR pro sestavení a údržbu veřejné image. Toto nastavení umožňuje simulovat změny ze strany node uživatelů, kteří image spravují.

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

Abyste zabránili omezování Dockeru, přidejte do úlohy Docker Hub přihlašovací údaje. Příkaz acr task credentials můžete použít k předání přihlašovacích údajů Dockeru do libovolného registru, včetně 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]

Udělte úloze přístup ke čtení hodnot z trezoru klíčů:

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

Úlohy se můžou aktivovat potvrzením Gitu, aktualizacemi základní image, časovači nebo ručními spuštěními.

Ručním spuštěním úlohy vygenerujte node image:

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

Vypište image v simulovaném veřejném registru:

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

hello-world Vytvoření image

Na základě simulované veřejné node image sestavte hello-world image.

Vytvoření tokenu pro přístup pro vyžádání změn k simulovanému veřejnému registru

Vytvořte přístupový token pro simulovaný veřejný registr s oborem pull. Pak ho nastavte v trezoru klíčů:

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)

Vytvoření tokenu pro přístup k vyžádání pomocí Azure Container Instances

Vytvořte přístupový token k registru, který je hostitelem hello-world image, s vymezeným oborem pro vyžádání. Pak ho nastavte v trezoru klíčů:

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)

Vytvoření úlohy pro sestavení a údržbu hello-world image

Následující příkaz vytvoří úlohu z definice v acr-tasks.yaml úložišti hello-world . Kroky úlohy sestaví hello-world image a pak ji nasadí do Azure Container Instances. Skupina prostředků pro Azure Container Instances byla vytvořena v předchozí části. az container create Voláním úlohy pouze s rozdílem v image:tag, úloha se nasadí do stejné instance v rámci tohoto názorného postupu.

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

Přidejte přihlašovací údaje k úloze pro simulovaný veřejný registr:

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]

Udělte úloze přístup ke čtení hodnot z trezoru klíčů:

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

Udělením přístupu ke skupině prostředků udělte úloze přístup k vytváření a správě Azure Container Instances:

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

Po vytvoření a konfiguraci úlohy spusťte úlohu a sestavte a nasaďte hello-world image:

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

Po vytvoření získejte IP adresu kontejneru hostujícího hello-world image.

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

V prohlížeči přejděte na IP adresu a zobrazte spuštěnou aplikaci.

Aktualizace základní image pomocí "sporné" změny

Tato část simuluje změnu základní image, která by mohla způsobit problémy v prostředí.

1. Otevřete Dockerfile ve forku base-image-node úložiště.
2. Změňte na BACKGROUND_COLOR pro Orange simulaci změny.

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

Potvrďte změnu a sledujte, jestli služba ACR Tasks automaticky začne sestavovat.

Sledujte, až se spustí úloha:

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

Nakonec byste měli vidět STAV Succeeded na základě aktivační události Commit:

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

Stisknutím Ctrl+C ukončete příkaz kukátku a pak zobrazte protokoly posledního spuštění:

az acr task logs -r $REGISTRY_PUBLIC

node Po dokončení watch image služba ACR Tasks automaticky spustí vytváření hello-world image:

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

Nakonec byste měli vidět STAV Succeeded na základě aktivační události 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

Stisknutím Ctrl+C ukončete příkaz kukátku a pak zobrazte protokoly posledního spuštění:

az acr task logs -r $REGISTRY

Po dokončení získejte IP adresu webu, který je hostitelem aktualizované hello-world image:

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

V prohlížeči přejděte na web, který by měl mít oranžové (pochybné) pozadí.

Vrácení se sem

V tomto okamžiku hello-world jste vytvořili image, která je automaticky sestavená na základě potvrzení Gitu a změn v základní node imagi. V tomto příkladu se úloha sestaví proti základní imagi v Azure Container Registry, ale dá se použít jakýkoli podporovaný registr.

Aktualizace základní image automaticky znovu spustí úlohu při node aktualizaci image. Jak je vidět tady, ne všechny aktualizace se hledají.

Chráněné importy veřejného obsahu

Pokud chcete zabránit tomu, aby nadřazené změny narušily kritické úlohy, je možné přidat kontrolu zabezpečení a funkční testy.

V této části vytvoříte úlohu ACR pro:

• Sestavení testovacího obrázku
• Spuštění funkčního testovacího skriptu ./test.sh na testovací imagi
• Pokud se image úspěšně testuje, importujte veřejnou image do registru baseimages .

Přidání testování automatizace

Aby bylo možné ohlídnout jakýkoli nadřazený obsah, implementuje se automatizované testování. V tomto příkladu je k dispozici hodnota , test.sh která kontroluje $BACKGROUND_COLOR. Pokud se test nezdaří, vrátí se hodnota , EXIT_CODE1 která způsobí, že krok úlohy ACR selže a ukončí spuštění úlohy. Testy lze rozšířit v libovolné formě nástrojů, včetně protokolování výsledků. Brána se spravuje pomocí odpovědi typu pass/fail ve skriptu, která je zde reprodukována:

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}

YAML úkolu

acr-task.yaml Zkontrolujte v úložištiimport-baseimage-node, který provádí následující kroky:

1. Sestavte image testovací základny pomocí následujícího souboru Dockerfile:

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

2. Po dokončení ověřte image spuštěním kontejneru, který se spustí. ./test.sh
3. Pouze v případě úspěšného dokončení spusťte kroky importu, které jsou chráněné 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}}"

Vytvoření úlohy pro import a testování základní image

  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

Přidejte přihlašovací údaje k úloze pro simulovaný veřejný registr:

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]

Udělte úloze přístup ke čtení hodnot z trezoru klíčů:

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

Spusťte úlohu importu:

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

Poznámka

Pokud úloha selže kvůli chybě , ujistěte se ./test.sh: Permission denied, že skript má oprávnění ke spuštění, a potvrďte ho zpět do úložiště Git:

chmod +x ./test.sh

Aktualizace hello-world image pro sestavení z chráněné node image

Vytvořte přístupový token pro přístup k registru základních artefaktů s oborem read z node úložiště. Pak v trezoru klíčů nastavte:

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)

Přidejte přihlašovací údaje do úlohy hello-world pro registr základních artefaktů:

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]

Aktualizujte úlohu tak, aby se používal registrBASE_ARTIFACTS.REGISTRY_FROM_URL

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

Spusťte úlohu hello-world a změňte její závislost na základní imagi:

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

Aktualizace základní image platnou změnou

1. Otevřete v base-image-node úložištiDockerfile.
2. Změnou na BACKGROUND_COLORGreen simulujte platnou změnu.

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

Potvrďte změnu a sledujte posloupnost aktualizací:

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

Po spuštění zadejte Ctrl+C a monitorujte protokoly:

az acr task logs -r $REGISTRY_PUBLIC

Po dokončení monitorujte úlohu base-image-import :

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

Po spuštění zadejte Ctrl+C a monitorujte protokoly:

az acr task logs -r $REGISTRY_BASE_ARTIFACTS

Po dokončení monitorujte úlohu hello-world :

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

Po spuštění zadejte Ctrl+C a monitorujte protokoly:

az acr task logs -r $REGISTRY

Po dokončení získejte IP adresu webu, který je hostitelem aktualizované hello-world image:

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

V prohlížeči přejděte na web, který by měl mít zelené (platné) pozadí.

Zobrazení chráněného pracovního postupu

Znovu proveďte kroky v předchozí části s červenou barvou pozadí.

1. Otevření v úložišti Dockerfilebase-image-node
2. Změnou na BACKGROUND_COLORRed simulujte neplatnou změnu.

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

Potvrďte změnu a sledujte posloupnost aktualizací:

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

Po spuštění zadejte Ctrl+C a monitorujte protokoly:

az acr task logs -r $REGISTRY_PUBLIC

Po dokončení monitorujte úlohu base-image-import :

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

Po spuštění zadejte Ctrl+C a monitorujte protokoly:

az acr task logs -r $REGISTRY_BASE_ARTIFACTS

V tomto okamžiku byste měli vidět selhání ověření úlohy base-import-node a zastavit posloupnost publikování hello-world aktualizace. Výstup se podobá tomuto:

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

Publikování aktualizace do hello-world

Změny image hello-world budou dál používat poslední ověřenou node image.

Jakékoli další změny základní node image, které projdou ověřenými ověřeními, aktivují aktualizace hello-world základní image.

Vyčištění

Pokud už je nepotřebujete, odstraňte prostředky použité v tomto článku.

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

Další kroky

V tomto článku. použili jste úlohy ACR k vytvoření automatizovaného pracovního postupu pro zavedení aktualizovaných základních imagí do vašeho prostředí. Projděte si související informace o správě imagí v Azure Container Registry.

• Doporučení pro označování a správu verzí imagí kontejnerů
• Uzamčení image kontejneru v registru kontejneru Azure