Openbare inhoud gebruiken en onderhouden met Azure Container Registry-taken

Artikel
10/24/2024

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

Lokale kopieën van afhankelijke openbare installatiekopieën importeren.
Valideer openbare installatiekopieën via beveiligingsscans en functionele tests.
Promoot de installatiekopieën naar privéregisters voor intern gebruik.
Trigger updates voor basisinstallatiekopieën voor toepassingen die afhankelijk zijn van openbare inhoud.
Gebruik Azure Container Registry-taken om deze werkstroom te automatiseren.

De werkstroom wordt samengevat in de volgende afbeelding:

Werkstroom voor openbare inhoud gebruiken

Met de werkstroom voor gated import kunt u de afhankelijkheden van externe beheerde artefacten van uw organisatie beheren, bijvoorbeeld installatiekopieën die afkomstig zijn van 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 geïntroduceerd door afhankelijkheden van openbare inhoud en het gebruik van Azure Container Registry om deze te beperken, raadpleegt u het blogbericht OCI-verbruikende 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. Als u Azure CLI 2.0 wilt installeren of upgraden, raadpleegt u Azure CLI 2.0 installeren.

Overzicht van scenario

werkstroomonderdelen importeren

In dit scenario wordt het volgende ingesteld:

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
Een ACR-taak in elk register. De taken:
1. Een gesimuleerde openbare node installatiekopieën bouwen
2. De installatiekopieën importeren en valideren node in het gedeelde bedrijfs-/teamregister
3. De installatiekopieën bouwen en implementeren hello-world
ACR-taakdefinities, waaronder configuraties voor:
- Een verzameling registerreferenties, die verwijzen naar een sleutelkluis
- Een verzameling geheimen, beschikbaar binnen een acr-task.yaml, die verwijzen naar een sleutelkluis
- Een verzameling geconfigureerde waarden die worden gebruikt in een acr-task.yaml
Een Azure-sleutelkluis om alle geheimen te beveiligen
Een Azure-containerinstantie die als host fungeert voor de hello-world build-toepassing

Vereisten

Met de volgende stappen configureert u waarden voor resources die in het scenario 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 variabelen 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, moet u elk van de volgende Git-opslagplaatsen in opslagplaatsen versplitsen die u kunt beheren.

Werk vervolgens de volgende variabelen voor uw geforkte opslagplaatsen bij.

De :main toegevoegde 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

Als u beperkings- en identiteitsaanvragen wilt voorkomen bij het ophalen van installatiekopieën uit Docker Hub, maakt u een Docker Hub-token. 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 in 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 de gebruikersnaam en het token van Docker Hub 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

Een Git PAT instellen en verifiëren in de sleutelkluis:

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 node installatiekopieën in Docker Hub wilt simuleren, maakt u een ACR-taak om de openbare installatiekopieën te bouwen en te onderhouden. Met deze installatie kunt u wijzigingen simuleren door de onderhouders van de node installatiekopieën.

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

Om beperking van Docker te 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]

Verdeel de taak toegang tot leeswaarden 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 node installatiekopieën te genereren:

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

Geef de installatiekopieën weer in het gesimuleerde openbare register:

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

`hello-world` De installatiekopieën maken

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

Token maken voor pull-toegang tot gesimuleerd openbaar register

Maak een toegangstoken voor het gesimuleerde openbare register met het bereik .pull 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 door Azure Container Instances

Maak een toegangstoken voor het register dat als host fungeert voor de hello-world installatiekopie, met het bereik dat moet worden opgehaald. 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 voor het bouwen en onderhouden van installatiekopieën `hello-world`

Met de volgende opdracht maakt u een taak op basis van de definitie in acr-tasks.yaml de hello-world opslagplaats. De taakstappen bouwen de hello-world installatiekopieën en implementeren deze vervolgens in Azure Container Instances. De resourcegroep voor Azure Container Instances is gemaakt in een vorige sectie. Door de taak aan te roepen az container create met slechts een verschil in de image:tagtaak, 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

Referenties toevoegen 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]

Verdeel de taak toegang tot leeswaarden 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

Verdeel de taak toegang om Azure Container Instances te maken en te beheren 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

Wanneer 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 u de installatiekopie hebt 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 kunnen veroorzaken.

Open Dockerfile de vervalste base-image-node opslagplaats.
Wijzig het BACKGROUND_COLOR om de wijziging te Orange 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 Tasks automatisch wordt gebouwd.

Controleer of de taak 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 controleopdracht 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 start 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 controleopdracht 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 hello-world installatiekopie gemaakt die automatisch wordt gebouwd op Git-doorvoeringen en wijzigingen in de basisinstallatiekopie 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 te zien is, zijn niet alle updates gewenst.

Beperkte import van openbare inhoud

Om te voorkomen dat upstream-wijzigingen 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 uitvoeren ./test.sh op basis van de testafbeelding
Als de installatiekopie is getest, importeert u de openbare installatiekopie in het register met baseimages

Automatiseringstests toevoegen

Geautomatiseerde tests worden geïmplementeerd om alle upstream-inhoud te gateen. In dit voorbeeld wordt een test.sh opgegeven waarmee de $BACKGROUND_COLOR. Als de test mislukt, wordt er 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, waaronder 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 import-baseimage-node opslagplaats, die de volgende stappen uitvoert:

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

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

Referenties toevoegen 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]

Verdeel de taak toegang tot leeswaarden 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 ./test.sh: Permission deniedvanwege, controleert u of het script uitvoeringsmachtigingen heeft en voert u deze door naar de Git-opslagplaats:

chmod +x ./test.sh

Installatiekopieën bijwerken `hello-world` om te bouwen vanaf een gated `node` image

Maak een toegangstoken voor toegang tot het register met basisartefacten, met het bereik van read de node opslagplaats. Stel vervolgens in de sleutelkluis 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)

Referenties toevoegen aan de hallo wereld-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]

Werk de taak bij om het REGISTRY_FROM_URL te wijzigen voor het gebruik van het BASE_ARTIFACTS register

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 hallo wereld-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

Open de Dockerfile opslagplaats base-image-node .
Wijzig het BACKGROUND_COLOR om Green 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

Typ Ctrl+C en bewaak de logboeken als u het volgende hebt uitgevoerd:

az acr task logs -r $REGISTRY_PUBLIC

Als u klaar bent, controleert u de importtaak basisinstallatiekopieën :

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

Typ Ctrl+C en bewaak de logboeken als u het volgende hebt uitgevoerd:

az acr task logs -r $REGISTRY_BASE_ARTIFACTS

Als u klaar bent, controleert u de hallo wereldtaak :

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

Typ Ctrl+C en bewaak de logboeken als u het volgende hebt uitgevoerd:

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 gated workflow weergeven

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

Open de Dockerfile opslagplaats base-image-node
Wijzig het BACKGROUND_COLOR 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

Typ Ctrl+C en bewaak de logboeken als u het volgende hebt uitgevoerd:

az acr task logs -r $REGISTRY_PUBLIC

Als u klaar bent, controleert u de importtaak basisinstallatiekopieën :

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

Typ Ctrl+C en bewaak de logboeken als u het volgende hebt uitgevoerd:

az acr task logs -r $REGISTRY_BASE_ARTIFACTS

Op dit moment ziet u dat de taak base-import-node mislukt en de reeks stopt om een hello-world update te publiceren. 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 hello-world installatiekopieën blijven de laatst gevalideerde node installatiekopieën gebruiken.

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

Opschonen

Wanneer u deze niet meer nodig hebt, verwijdert u de resources die in dit artikel worden gebruikt.

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 hebt u ACR-taken gebruikt om een geautomatiseerde gating-werkstroom te maken om bijgewerkte basisinstallatiekopieën in uw omgeving te introduceren. Zie gerelateerde informatie voor het beheren van installatiekopieën in Azure Container Registry.

Delen via

Openbare inhoud gebruiken en onderhouden met Azure Container Registry-taken

Overzicht van scenario

Vereisten

Omgevingsvariabelen instellen

Git-opslagplaatsen en -tokens

Docker Hub-referenties

Registers maken

Sleutelkluis maken en geheimen instellen

Resourcegroep maken voor een Azure-containerinstantie

`node` Openbare basisinstallatiekopieën maken

`hello-world` De installatiekopieën maken

Token maken voor pull-toegang tot gesimuleerd openbaar register

Token maken voor pull-toegang door Azure Container Instances

Taak maken voor het bouwen en onderhouden van installatiekopieën `hello-world`

De basisinstallatiekopieën bijwerken met een 'twijfelachtige' wijziging

Inchecken

Beperkte import van openbare inhoud

Automatiseringstests toevoegen

TAAK-YAML

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

Installatiekopieën bijwerken `hello-world` om te bouwen vanaf een gated `node` image

De basisinstallatiekopieën bijwerken met een 'geldige' wijziging

De gated workflow weergeven

Een update publiceren naar `hello-world`

Opschonen

Volgende stappen

Feedback

Aanvullende resources

Delen via

Openbare inhoud gebruiken en onderhouden met Azure Container Registry-taken

Overzicht van scenario

Vereisten

Omgevingsvariabelen instellen

Git-opslagplaatsen en -tokens

Docker Hub-referenties

Registers maken

Sleutelkluis maken en geheimen instellen

Resourcegroep maken voor een Azure-containerinstantie

node Openbare basisinstallatiekopieën maken

hello-world De installatiekopieën maken

Token maken voor pull-toegang tot gesimuleerd openbaar register

Token maken voor pull-toegang door Azure Container Instances

Taak maken voor het bouwen en onderhouden van installatiekopieën hello-world

De basisinstallatiekopieën bijwerken met een 'twijfelachtige' wijziging

Inchecken

Beperkte import van openbare inhoud

Automatiseringstests toevoegen

TAAK-YAML

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

Installatiekopieën bijwerken hello-world om te bouwen vanaf een gated node image

De basisinstallatiekopieën bijwerken met een 'geldige' wijziging

De gated workflow weergeven

Een update publiceren naar hello-world

Opschonen

Volgende stappen

Feedback

Aanvullende resources

`node` Openbare basisinstallatiekopieën maken

`hello-world` De installatiekopieën maken

Taak maken voor het bouwen en onderhouden van installatiekopieën `hello-world`

Installatiekopieën bijwerken `hello-world` om te bouwen vanaf een gated `node` image

Een update publiceren naar `hello-world`