Come usare e gestire il contenuto pubblico con le attività del Registro Azure Container

Articolo
10/16/2024

Questo articolo fornisce un flusso di lavoro di esempio in Registro Azure Container che consente di gestire l'utilizzo e la gestione del contenuto pubblico:

Importare copie locali di immagini pubbliche dipendenti.
Convalidare le immagini pubbliche tramite l'analisi della sicurezza e i test funzionali.
Alzare di livello le immagini ai registri privati per l'utilizzo interno.
Attivare gli aggiornamenti delle immagini di base per le applicazioni dipendenti dal contenuto pubblico.
Usare attività del Registro Azure Container per automatizzare questo flusso di lavoro.

Il flusso di lavoro è riepilogato nell'immagine seguente:

Utilizzo del flusso di lavoro del contenuto pubblico

Il flusso di lavoro di importazione controllata consente di gestire le dipendenze dell'organizzazione su artefatti gestiti esternamente, ad esempio immagini provenienti da registri pubblici, tra cui Docker Hub, GCR, Quay, Registro contenitori GitHub, Registro Contenitori Microsoft o anche altri registri contenitori di Azure.

Per informazioni sui rischi introdotti dalle dipendenze dal contenuto pubblico e su come usare Registro Azure Container per attenuarli, vedere il post di blog OCI Uso di contenuti pubblici OCI e Gestire il contenuto pubblico con Registro Azure Container.

Per completare questa procedura dettagliata, è possibile usare Azure Cloud Shell o un'installazione locale dell'interfaccia della riga di comando di Azure. È consigliabile usare l'interfaccia della riga di comando di Azure versione 2.10 o successiva. Se è necessario eseguire l'installazione o l'aggiornamento, vedere Installare l'interfaccia della riga di comando di Azure.

Panoramica dello scenario

importare i componenti del flusso di lavoro

Questa procedura dettagliata configura:

Tre registri contenitori, che rappresentano:
- Un Hub Docker simulato (publicregistry) per supportare la modifica dell'immagine di base
- Registro del team (contoso) per condividere immagini private
- Registro condiviso società/team (baseartifacts) per il contenuto pubblico importato
Attività del Registro Azure Container in ogni Registro di sistema. Attività:
1. Creare un'immagine node pubblica simulata
2. Importare e convalidare l'immagine node nel registro condiviso aziendale/team
3. Compilare e distribuire l'immagine hello-world
Definizioni di attività del Registro Azure Container, incluse le configurazioni per:
- Raccolta di credenziali del Registro di sistema, che sono puntatori a un insieme di credenziali delle chiavi
- Raccolta di segreti, disponibile in un acr-task.yaml, che sono puntatori a un insieme di credenziali delle chiavi
- Raccolta di valori configurati usati all'interno di un acr-task.yaml
Insieme di credenziali delle chiavi di Azure per proteggere tutti i segreti
Istanza del contenitore di Azure, che ospita l'applicazione di compilazione hello-world

Prerequisiti

La procedura seguente consente di configurare i valori per le risorse create e usate nella procedura dettagliata.

Impostare le variabili di ambiente

Configurare variabili univoche per l'ambiente. Vengono seguite le procedure consigliate per inserire le risorse con contenuto durevole nel proprio gruppo di risorse per ridurre al minimo l'eliminazione accidentale. Tuttavia, è possibile inserire queste variabili in un singolo gruppo di risorse, se necessario.

Gli esempi di questo articolo sono formattati per la shell 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

Repository e token Git

Per simulare l'ambiente, creare una copia tramite fork di ognuno dei repository Git seguenti nei repository che è possibile gestire.

Aggiornare quindi le variabili seguenti per i repository con fork.

L'oggetto :main aggiunto alla fine degli URL Git rappresenta il ramo del repository predefinito.

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

Per clonare e stabilire webhook Git, è necessario un token di accesso GitHub (PAT) per attività del Registro Azure Container. Per la procedura per creare un token con le autorizzazioni necessarie per un repository privato, vedere Creare un token di accesso GitHub.

GIT_TOKEN=<set-git-token-here>

Credenziali dell'hub Docker

Per evitare richieste di limitazione e identità durante il pull delle immagini dall'hub Docker, creare un token dell'hub Docker. Impostare quindi le variabili di ambiente seguenti:

REGISTRY_DOCKERHUB_USER=<yourusername>
REGISTRY_DOCKERHUB_PASSWORD=<yourtoken>

Creare registri

Usando i comandi dell'interfaccia della riga di comando di Azure, creare tre registri contenitori di livello Premium, ognuno nel proprio gruppo di risorse:

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

Creare un insieme di credenziali delle chiavi e impostare i segreti

Crea un Key Vault:

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

Impostare il nome utente e il token dell'hub Docker nell'insieme di credenziali delle chiavi:

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

Impostare e verificare un token di accesso personale Git nell'insieme di credenziali delle chiavi:

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

Creare un gruppo di risorse per un'istanza di Contenitore di Azure

Questo gruppo di risorse viene usato in un'attività successiva durante la distribuzione dell'immagine hello-world.

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

Creare un'immagine di base pubblica `node`

Per simulare l'immagine node nell'hub Docker, creare un'attività registro Azure Container per compilare e gestire l'immagine pubblica. Questa configurazione consente di simulare le modifiche da parte dei gestori di immagini 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

Per evitare la limitazione di Docker, aggiungere le credenziali dell'hub Docker all'attività. Il comando credenziali dell'attività acr può essere usato per passare le credenziali Docker a qualsiasi registro, incluso l'hub Docker.

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]

Concedere all'attività l'accesso per leggere i valori dall'insieme di credenziali delle chiavi:

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

Le attività possono essere attivate da commit Git, aggiornamenti delle immagini di base, timer o esecuzioni manuali.

Eseguire l'attività manualmente per generare l'immagine node:

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

Elencare l'immagine nel registro pubblico simulato:

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

Creare l'immagine `hello-world`

In base all'immagine node pubblica simulata, creare un'immagine hello-world.

Creare un token per l'accesso pull al registro pubblico simulato

Creare un token di accesso al Registro di sistema pubblico simulato, con ambito pull. Impostarlo quindi nell'insieme di credenziali delle chiavi:

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)

Creare un token per l'accesso pull da istanze di Azure Container

Creare un token di accesso al Registro di sistema che ospita l'immagine hello-world, con ambito pull. Impostarlo quindi nell'insieme di credenziali delle chiavi:

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)

Creare un'attività per compilare e gestire l'immagine `hello-world`

Il comando seguente crea un'attività dalla definizione in acr-tasks.yaml nel repository hello-world. I passaggi dell'attività compilano l'immagine hello-world e quindi la distribuiscono in Istanze di Azure Container. Il gruppo di risorse per Istanze di Azure Container è stato creato in una sezione precedente. Chiamando az container create nell'attività con solo una differenza nell’oggetto image:tag, l'attività viene distribuita nella stessa istanza in questa procedura dettagliata.

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

Aggiungere credenziali all'attività per il registro pubblico simulato:

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]

Concedere all'attività l'accesso per leggere i valori dall'insieme di credenziali delle chiavi:

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

Concedere all'attività l'accesso per creare e gestire istanze di Azure Container concedendole l'accesso al gruppo di risorse:

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

Dopo aver creato e configurato l'attività, eseguire l'attività per compilare e distribuire l'immagine hello-world:

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

Una volta creato, ottenere l'indirizzo IP del contenitore che ospita l'immagine hello-world.

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

Nel browser passare all'indirizzo IP per visualizzare l'applicazione in esecuzione.

Aggiornare l'immagine di base con una modifica "discutibile"

Questa sezione simula una modifica all'immagine di base che potrebbe causare problemi nell'ambiente.

Aprire Dockerfile nel repository base-image-node con fork.
Modificare BACKGROUND_COLOR in Orange per simulare la modifica.

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

Eseguire il commit della modifica e controllare l'avvio automatico della compilazione delle attività del Registro Azure Container.

Controllare che l'attività inizi l'esecuzione:

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

Alla fine dovrebbe essere visualizzato lo STATO Succeeded in base a un TRIGGER di Commit:

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

Digitare CTRL+C per uscire dal comando espressione di controllo, quindi visualizzare i log per l'esecuzione più recente:

az acr task logs -r $REGISTRY_PUBLIC

Una volta completata l'immagine node, watch per attività del Registro Azure Container avviare automaticamente la compilazione dell'immagine hello-world:

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

Alla fine dovrebbe essere visualizzato lo STATO Succeeded in base a un TRIGGER di 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

Digitare CTRL+C per uscire dal comando espressione di controllo, quindi visualizzare i log per l'esecuzione più recente:

az acr task logs -r $REGISTRY

Al termine, ottenere l'indirizzo IP del sito che ospita l'immagine hello-world aggiornata:

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

Nel browser passare al sito, che dovrebbe avere uno sfondo arancione (discutibile).

Archiviazione in corso

A questo punto, è stata creata un'immagine hello-world basata automaticamente sui commit Git e sulle modifiche apportate all'immagine node di base. In questo esempio l'attività viene compilata in base a un'immagine di base in Registro Azure Container, ma è possibile usare qualsiasi registro supportato.

L'aggiornamento dell'immagine di base ritenta automaticamente l'esecuzione dell'attività quando l'immagine node viene aggiornata. Come illustrato qui, non tutti gli aggiornamenti sono desiderati.

Importazioni gestite di contenuti pubblici

Per evitare che le modifiche upstream causino l'interruzione dei carichi di lavoro critici, è possibile aggiungere l'analisi della sicurezza e i test funzionali.

In questa sezione viene creata un'attività registro Azure Container per:

Creare un'immagine di test
Eseguire uno script di test funzionale ./test.sh sull'immagine di test
Se l'immagine viene verificata correttamente, importare l'immagine pubblica nel registro di baseimages

Aggiungere test di automazione

Per controllare qualsiasi contenuto upstream, vengono implementati dei test automatizzati. In questo esempio viene fornito un oggetto test.sh che controlla l'oggetto $BACKGROUND_COLOR. Se il test ha esito negativo, viene restituito un EXIT_CODE di 1 che causa l'esito negativo del passaggio dell'attività registro Azure Container, terminando l'esecuzione dell'attività. I test possono essere espansi in qualsiasi forma di strumenti, inclusi i risultati della registrazione. Il gate è gestito da una risposta esito positivo/esito negativo nello script, riprodotta qui:

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 attività

Esaminare il acr-task.yaml nel repository import-baseimage-node, che esegue i passaggi seguenti:

Compilare l'immagine di base di test usando il Dockerfile seguente:

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

Al termine, convalidare l'immagine eseguendo il contenitore, che viene eseguito ./test.sh
Solo se è stato completato correttamente, eseguire i passaggi di importazione, che vengono gestiti con 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}}"

Creare un'attività per importare e testare l'immagine di base

  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

Aggiungere credenziali all'attività per il registro pubblico simulato:

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]

Concedere all'attività l'accesso per leggere i valori dall'insieme di credenziali delle chiavi:

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

Eseguire l'attività di importazione:

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

Nota

Se l'attività non riesce a causa di ./test.sh: Permission denied, assicurarsi che lo script disponga delle autorizzazioni di esecuzione, ed eseguire il commit nel repository Git:

chmod +x ./test.sh

Aggiornare l'immagine `hello-world` per la compilazione da un'immagine `node` controllata

Creare un token di accesso per accedere al registro degli artefatti di base, con ambito read dal repository node. Impostare, quindi, nell'insieme di credenziali delle chiavi:

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)

Aggiungere credenziali all'attività hello-world per il registro degli artefatti di base:

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]

Aggiornare l'attività per modificare il REGISTRY_FROM_URL per usare il Registro di sistema BASE_ARTIFACTS

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

Eseguire l'attività hello-world per modificare la dipendenza dell'immagine di base:

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

Aggiornare l'immagine di base con una modifica "valida"

Aprire Dockerfile nel repository base-image-node.
Modificare BACKGROUND_COLOR in Green per simulare una modifica valida.

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

Eseguire il commit della modifica e monitorare la sequenza di aggiornamenti:

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

Dopo l'esecuzione, digitare CTRL+C e monitorare i log:

az acr task logs -r $REGISTRY_PUBLIC

Al termine, monitorare l'attività base-image-import:

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

Dopo l'esecuzione, digitare CTRL+C e monitorare i log:

az acr task logs -r $REGISTRY_BASE_ARTIFACTS

Al termine, monitorare l'attività hello-world:

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

Dopo l'esecuzione, digitare CTRL+C e monitorare i log:

az acr task logs -r $REGISTRY

Al termine, ottenere l'indirizzo IP del sito che ospita l'immagine hello-world aggiornata:

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

Nel browser passare al sito, che deve avere uno sfondo verde (valido).

Visualizzare il flusso di lavoro gestito

Eseguire di nuovo i passaggi nella sezione precedente, con un colore di sfondo rosso.

Aprire Dockerfile nel repository base-image-node
Modificare BACKGROUND_COLOR in Red per simulare una modifica non valida.

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

Eseguire il commit della modifica e monitorare la sequenza di aggiornamenti:

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

Dopo l'esecuzione, digitare CTRL+C e monitorare i log:

az acr task logs -r $REGISTRY_PUBLIC

Al termine, monitorare l'attività base-image-import:

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

Dopo l'esecuzione, digitare CTRL+C e monitorare i log:

az acr task logs -r $REGISTRY_BASE_ARTIFACTS

A questo punto, si noterà che la convalida dell'attività base-import-node non riesce e arresta la sequenza per pubblicare un aggiornamento hello-world. L'output è simile a:

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

Pubblicare un aggiornamento per `hello-world`

Le modifiche apportate all'immagine hello-world continueranno a usare l'ultima immagine node convalidata.

Eventuali modifiche aggiuntive all'immagine node di base che superano le convalide gestite attiveranno gli aggiornamenti delle immagini di base all'immagine hello-world.

Pulizia

Quando non sono più necessarie, eliminare le risorse usate in questo articolo.

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

Passaggi successivi

In questo articolo sono state usate attività del Registro Azure Container per creare un flusso di lavoro di controllo automatizzato per introdurre immagini di base aggiornate all'ambiente. Vedere le informazioni correlate per gestire le immagini in Registro Azure Container.

Condividi tramite

Come usare e gestire il contenuto pubblico con le attività del Registro Azure Container

Panoramica dello scenario

Prerequisiti

Impostare le variabili di ambiente

Repository e token Git

Credenziali dell'hub Docker

Creare registri

Creare un insieme di credenziali delle chiavi e impostare i segreti

Creare un gruppo di risorse per un'istanza di Contenitore di Azure

Creare un'immagine di base pubblica `node`

Creare l'immagine `hello-world`

Creare un token per l'accesso pull al registro pubblico simulato

Creare un token per l'accesso pull da istanze di Azure Container

Creare un'attività per compilare e gestire l'immagine `hello-world`

Aggiornare l'immagine di base con una modifica "discutibile"

Archiviazione in corso

Importazioni gestite di contenuti pubblici

Aggiungere test di automazione

YAML attività

Creare un'attività per importare e testare l'immagine di base

Aggiornare l'immagine `hello-world` per la compilazione da un'immagine `node` controllata

Aggiornare l'immagine di base con una modifica "valida"

Visualizzare il flusso di lavoro gestito

Pubblicare un aggiornamento per `hello-world`

Pulizia

Passaggi successivi

Commenti e suggerimenti

Risorse aggiuntive

Condividi tramite

Come usare e gestire il contenuto pubblico con le attività del Registro Azure Container

Panoramica dello scenario

Prerequisiti

Impostare le variabili di ambiente

Repository e token Git

Credenziali dell'hub Docker

Creare registri

Creare un insieme di credenziali delle chiavi e impostare i segreti

Creare un gruppo di risorse per un'istanza di Contenitore di Azure

Creare un'immagine di base pubblica node

Creare l'immagine hello-world

Creare un token per l'accesso pull al registro pubblico simulato

Creare un token per l'accesso pull da istanze di Azure Container

Creare un'attività per compilare e gestire l'immagine hello-world

Aggiornare l'immagine di base con una modifica "discutibile"

Archiviazione in corso

Importazioni gestite di contenuti pubblici

Aggiungere test di automazione

YAML attività

Creare un'attività per importare e testare l'immagine di base

Aggiornare l'immagine hello-world per la compilazione da un'immagine node controllata

Aggiornare l'immagine di base con una modifica "valida"

Visualizzare il flusso di lavoro gestito

Pubblicare un aggiornamento per hello-world

Pulizia

Passaggi successivi

Commenti e suggerimenti

Risorse aggiuntive

Creare un'immagine di base pubblica `node`

Creare l'immagine `hello-world`

Creare un'attività per compilare e gestire l'immagine `hello-world`

Aggiornare l'immagine `hello-world` per la compilazione da un'immagine `node` controllata

Pubblicare un aggiornamento per `hello-world`