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:
- Importujte místní kopie závislých veřejných imagí.
- Ověřte veřejné image prostřednictvím kontroly zabezpečení a funkčního testování.
- Zvyšte úroveň imagí na soukromé registry pro interní použití.
- Aktivace aktualizací základní image pro aplikace závislé na veřejném obsahu
- 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í:
- 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
- Simulovaná Docker Hub (
- Úloha ACR v každém registru. Úkoly:
- Vytvoření simulované veřejné
node
image - Import a ověření
node
image do sdíleného registru společnosti nebo týmu - Sestavení a nasazení
hello-world
image
- Vytvoření simulované veřejné
- Definice úloh ACR, včetně konfigurací pro:
- Kolekce přihlašovacích údajů registru, které jsou ukazateli na trezor klíčů
- Kolekce tajných kódů, které jsou k dispozici v rámci objektu
acr-task.yaml
, které jsou ukazateli na trezor klíčů - Kolekce nakonfigurovaných hodnot používaných v rámci
acr-task.yaml
- Trezor klíčů Azure pro zabezpečení všech tajných kódů
- 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í.
- Otevřete
Dockerfile
ve forkubase-image-node
úložiště. - Změňte na
BACKGROUND_COLOR
proOrange
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_CODE
1
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:
- 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
- Po dokončení ověřte image spuštěním kontejneru, který se spustí.
./test.sh
- 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
- Otevřete v
base-image-node
úložištiDockerfile
. - Změnou na
BACKGROUND_COLOR
Green
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í.
- Otevření v úložišti
Dockerfile
base-image-node
- Změnou na
BACKGROUND_COLOR
Red
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.