Jak využívat a udržovat veřejný obsah pomocí úloh služby Azure Container Registry

Tento článek obsahuje ukázkový pracovní postup ve službě 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 obrázků.
Ověření veřejných imagí prostřednictvím kontroly zabezpečení a funkčního testování
Publikujte obrázky do soukromých registrů pro interní použití.
Spusťte aktualizace základní image pro aplikace, které závisejí na veřejném obsahu.
K automatizaci tohoto pracovního postupu použijte úlohy služby Azure Container Registry.

Pracovní postup je shrnutý na následujícím obrázku:

Využívání pracovního postupu veřejného obsahu

Vrátný pracovní postup importu pomáhá spravovat závislosti vaší organizace na externě spravovaných artefaktech – například image zdrojové z veřejných registrů, včetně Docker Hubu, GCR, Quay, GitHub Container Registry, Microsoft Container Registry nebo dokonce jiných registrů kontejnerů Azure.

Základní informace o rizicích zavedených závislostmi na veřejném obsahu a o tom, jak je pomocí služby Azure Container Registry zmírnit, najdete v příspěvku na blogu o využití veřejného obsahu OCI a správu veřejného obsahu pomocí služby 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

import komponent pracovního postupu

Tento názorný postup nastavuje:

Tři registry kontejnerů představující:
- 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
Úloha ACR v každém registru. Úkoly:
1. Vytvořte simulovaný veřejný snímek node
2. Importujte a ověřte obraz node ve sdíleném registru společnosti nebo týmu
3. Sestavení a nasazení hello-world obrazu
Definice úloh ACR, včetně konfigurací pro:
- Kolekce přihlašovacích údajů registru, což jsou ukazatele na trezor klíčů
- Kolekce tajemství, která jsou k dispozici uvnitř acr-task.yaml, což jsou ukazatele 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á hostuje aplikaci pro vytváření

Požadavky

Následující kroky nakonfigurují hodnoty pro prostředky vytvořené a používané 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 vlastní skupiny prostředků, abychom minimalizovali náhodné odstranění. Pokud ale chcete, můžete tyto proměnné umístit do jedné skupiny prostředků.

Příklady v tomto článku jsou formátovány 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 Gitu

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

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

Připojený :main 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

K klonování a vytváření webhooků Gitu potřebujete přístupový token GitHubu (PAT) 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>

Přihlašovací údaje docker Hubu

Pokud se chcete vyhnout omezování požadavků a žádostí o identitu při načítání obrázků z Docker Hubu, 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, z nichž každá je 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 Hubu 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

Nastavte a ověřte osobní přístupový token Git v klíčovém trezoru.

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řte skupinu prostředků pro instanci kontejneru Azure

Tato skupina prostředků se používá 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 obraz na node Docker Hubu, vytvořte úlohu ACR pro sestavení a údržbu veřejného obrazu. Toto nastavení umožňuje simulovat změny provedené udržovateli obrazu node.

az acr task create \
  --name node-public \
  -r $REGISTRY_PUBLIC \
  -f acr-task.yaml \
  --context $GIT_BASE_IMAGE_NODE \
  --git-access-token $(az keyvault secret show \
                        --vault-name $AKV \
                        --name github-token \
                        --query value -o tsv) \
  --set REGISTRY_FROM_URL=${REGISTRY_DOCKERHUB_URL}/ \
  --assign-identity

Abyste se vyhnuli omezování Dockeru, přidejte do úlohy přihlašovací údaje Docker Hubu. Příkaz přihlašovacích údajů úlohy acr se může použít k předání přihlašovacích údajů Dockeru do libovolného registru, včetně Docker Hubu.

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 úkolu 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 můžou aktivovat potvrzení Gitu, aktualizace základní image, časovače nebo ruční spuštění.

Spusťte úlohu ručně a vygenerujte node image:

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

Výpis image v simulovaném veřejném registru:

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

`hello-world` Vytvořte obraz

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

Vytvoření tokenu pro získání přístupu k simulovanému veřejnému registru

Vytvořte přístupový token pro simulovaný veřejný registr s vymezeným 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 získání přístupu službou Azure Container Instances

Vytvořte přístupový token pro registr hostující obraz s omezením pro stažení. 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řte úlohu 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 služby Azure Container Instances. Skupina prostředků pro službu Azure Container Instances byla vytvořena v předchozí části. Voláním az container create v úloze s jediným rozdílem v image:tag se úloha nasadí do stejné instance po celou dobu tohoto návodu.

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 úkolu 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ů zajistíte úloze možnost vytvářet a spravovat 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

Když je úloha vytvořená a nakonfigurovaná, spusťte úlohu, která sestaví a nasadí 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.

Aktualizovat základní obraz s "pochybnou" změnou

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

Otevřete Dockerfile v rozvětveném base-image-node úložišti.
Změňte BACKGROUND_COLOR na Orange pro 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, jak úkoly ACR automaticky začnou kompilovat.

Sledujte, jak se má úkol spustit:

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

Nakonec by se měl zobrazit stav Succeeded na základě triggeru Commit:

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

Stiskněte Ctrl+C pro ukončení příkazu watch a poté zobrazte protokoly pro poslední spuštění:

az acr task logs -r $REGISTRY_PUBLIC

node Jakmile je obraz dokončen, watch služba ACR Tasks začne automaticky vytvářet hello-world obraz:

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

Nakonec by se měl zobrazit stav Succeeded na základě triggeru 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

Stiskněte Ctrl+C pro ukončení příkazu watch a poté zobrazte protokoly pro poslední 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é (pochybovatelné) pozadí.

Přihlášení

V tuto chvíli jste vytvořili hello-world obraz, který je automaticky sestavován na základě commitů Gitu a změn základního node obrazu. V tomto příkladu se úloha sestaví na základním obrazu ve službě Azure Container Registry, ale lze použít jakýkoli podporovaný registr.

Aktualizace základního obrazu automaticky znovu spustí běh úlohy při aktualizaci node image. Jak je zde vidět, nejsou všechny aktualizace žádané.

Hradené importy veřejného obsahu

Aby se zabránilo nadřazených změnám způsobujícím zásadní úlohy, může být přidáno prohledávání zabezpečení a funkční testy.

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

Sestavit testovací obraz
Spusťte funkční testovací skript ./test.sh na testovací obraz
Pokud obraz úspěšně projde testy, naimportujte veřejný obraz do registru baseimages.

Přidání testování automatizace

Aby bylo možné řídit jakýkoliv zdrojový obsah, implementuje se automatizované testování. V tomto příkladu je k dispozici test.sh, který kontroluje $BACKGROUND_COLOR. Pokud test selže, vrátí se hodnota EXIT_CODE z 1, což způsobí selhání kroku úlohy ACR a ukončí spuštění úlohy. Testy lze rozšířit v libovolné formě nástrojů, včetně výsledků protokolování. Brána je spravována na základě úspěšné/neúspěšné odpovědi ve skriptu, který je zde reprodukován:

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}

Úkol YAML

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

Sestavte testovací základní image 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ý běží ./test.sh.
Pouze pokud se úspěšně dokončilo, spusťte kroky importu, které jsou zamknuty pomocí 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 úkolu 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 z důvodu ./test.sh: Permission denied, ujistěte se, ž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

Aktualizovat `hello-world` obraz pro sestavení z omezeného `node` obrazu

Vytvořte přístupový token pro přístup k registru base-artifacts s rozsahem omezeným na read z úložiště node. Poté nastavte v úložišti klíčů:

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 k úloze 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 změnou použití REGISTRY_FROM_URL na BASE_ARTIFACTS registr.

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ákladní závislost image:

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

Aktualizujte základní obraz platnou změnou

Otevřete Dockerfile v úložišti base-image-node.
Změňte BACKGROUND_COLOR na Green k simulaci platné změny.

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 sledujte protokoly:

az acr task logs -r $REGISTRY_PUBLIC

Po dokončení monitorujte úlohu importu základního obrazu.

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

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

az acr task logs -r $REGISTRY_BASE_ARTIFACTS

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

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

Po spuštění zadejte Ctrl+C a sledujte 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í zamkovaného pracovního postupu

Opakujte kroky v předchozí části s červenou barvou pozadí.

Otevřete Dockerfile v úložišti base-image-node
Změňte BACKGROUND_COLOR na Red pro simulaci neplatné změny.

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 sledujte protokoly:

az acr task logs -r $REGISTRY_PUBLIC

Po dokončení monitorujte úlohu importu základního obrazu.

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

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

az acr task logs -r $REGISTRY_BASE_ARTIFACTS

V tomto okamžiku byste měli vidět, že úloha base-import-node selhala při ověřování a zastavila sekvenci pro publikování 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

Publikuj aktualizaci na `hello-world`

Změny obrázku hello-world budou nadále používat poslední ověřenou node image.

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

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 jste použili úlohy ACR k vytvoření automatizovaného řídicího pracovního postupu k zavedení aktualizované základní image do vašeho prostředí. Viz související informace o správě imagí ve službě Azure Container Registry.

Váš názor

Byla tato stránka užitečná?

Last updated on 2025-04-04

Sdílet prostřednictvím

Jak využívat a udržovat veřejný obsah pomocí úloh služby Azure Container Registry

Přehled scénáře

Požadavky

Nastavení proměnných prostředí

Úložiště a tokeny Gitu

Přihlašovací údaje docker Hubu

Vytváření registrů

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

Vytvořte skupinu prostředků pro instanci kontejneru Azure

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

hello-world Vytvořte obraz

Vytvoření tokenu pro získání přístupu k simulovanému veřejnému registru

Vytvoření tokenu pro získání přístupu službou Azure Container Instances

Vytvořte úlohu pro sestavení a údržbu hello-world Image

Aktualizovat základní obraz s "pochybnou" změnou

Přihlášení

Hradené importy veřejného obsahu

Přidání testování automatizace

Úkol YAML

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

Aktualizovat hello-world obraz pro sestavení z omezeného node obrazu

Aktualizujte základní obraz platnou změnou

Zobrazení zamkovaného pracovního postupu

Publikuj aktualizaci na hello-world

Vyčištění

Další kroky

Váš názor

Další materiály

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

`hello-world` Vytvořte obraz

Vytvořte úlohu pro sestavení a údržbu `hello-world` Image

Aktualizovat `hello-world` obraz pro sestavení z omezeného `node` obrazu

Publikuj aktualizaci na `hello-world`