Esercitazione: Automatizzare le compilazioni di immagini dei contenitori quando viene aggiornata un'immagine di base in un altro registro contenitori privato

Articolo
09/26/2024

Attività del Registro Azure Container supporta le compilazioni di immagini automatizzate quando viene aggiornata l'immagine di base di un contenitore, ad esempio per applicare patch al sistema operativo o al framework applicazioni in una delle immagini di base.

Questa esercitazione illustra come creare un'attività del Registro Azure Container che attiva una compilazione nel cloud in seguito al push dell'immagine di base del contenitore in un altro Registro Azure Container. È anche possibile provare un'esercitazione per creare un'attività del Registro Azure Container che attiva una compilazione dell'immagine quando viene eseguito il push di un'immagine di base nello stesso Registro Azure Container.

Contenuto dell'esercitazione:

Compilare l'immagine di base in un registro di base
Creare un'attività di compilazione dell'applicazione in un altro registro per tenere traccia dell'immagine di base
Aggiornare l'immagine di base per attivare un'attività dell'immagine dell'applicazione
Visualizzare l'attività attivata
Verificare l'immagine dell'applicazione aggiornata

Prerequisiti

Completare le esercitazioni precedenti

Questa esercitazione presuppone che l'ambiente sia già stato configurato e che siano già state completate le procedure delle prime due esercitazioni della serie, in cui viene illustrato come:

Creare un'istanza di Registro Azure Container
Creare una copia tramite fork del repository di esempio
Clonare il repository di esempio
Creare un token di accesso personale GitHub

Se non è già stato fatto, prima di procedere completare le esercitazioni seguenti:

Compilare immagini dei contenitori nel cloud con Attività del Registro Azure Container

Automatizzare la compilazione di immagini dei contenitori con Attività del Registro Azure Container

Oltre al registro contenitori creato per le esercitazioni precedenti, è necessario creare un registro per archiviare le immagini di base. Se si desidera, creare il secondo registro in una località diversa rispetto a quella del registro originale.

Configurare l'ambiente

Popolare queste variabili di ambiente della shell con i valori appropriati per l'ambiente in uso. Questo passaggio non è obbligatorio, ma semplifica in parte l'esecuzione dei comandi su più righe dell'interfaccia della riga di comando di Azure. Se non si popolano queste variabili di ambiente, sarà necessario sostituire manualmente ogni valore in ogni occorrenza nei comandi di esempio.

BASE_ACR=<base-registry-name>   # The name of your Azure container registry for base images
ACR_NAME=<registry-name>        # The name of your Azure container registry for application images
GIT_USER=<github-username>      # Your GitHub user account name
GIT_PAT=<personal-access-token> # The PAT you generated in the second tutorial

Scenario di aggiornamento dell'immagine di base

Questa esercitazione illustra uno scenario di aggiornamento dell'immagine di base. Questo scenario riflette un flusso di lavoro di sviluppo per gestire le immagini di base in un registro contenitori privato comune durante la creazione di immagini dell'applicazione in altri registri. Le immagini di base possono specificare i sistemi operativi e i framework comuni usati da un team o anche componenti del servizio comuni.

Gli sviluppatori che sviluppano immagini di applicazioni in registri personali possono ad esempio accedere a un set di immagini di base gestite nel registro di base comune. Il registro di base può risiedere in un'altra area o essere replicato in più aree geografiche.

L'esempio di codice include due documenti Dockerfile: un'immagine dell'applicazione e un'immagine specificata come immagine di base. Nelle sezioni seguenti viene creata un'attività del Registro Azure Container che attiva automaticamente una compilazione dell'immagine dell'applicazione quando viene eseguito il push di una nuova versione dell'immagine di base in un Registro Azure Container diverso.

Dockerfile-app: applicazione Web Node.js di piccole dimensioni che esegue il rendering di una pagina Web statica in cui viene visualizzata la versione di Node.js su cui è basata. La stringa della versione è simulata, perché mostra il contenuto della variabile di ambiente NODE_VERSION definita nell'immagine di base.
Dockerfile-base: immagine specificata da Dockerfile-app come base. È a sua volta basata su un'immagine Node e include la variabile di ambiente NODE_VERSION.

Nelle sezioni seguenti si crea un'attività, si aggiorna il valore di NODE_VERSION nel documento Dockerfile dell'immagine di base e quindi si usa ACR Tasks per compilare l'immagine di base. Quando l'attività di ACR Tasks esegue il push della nuova immagine di base nel registro, attiva automaticamente una compilazione dell'immagine dell'applicazione. Facoltativamente, si esegue l'immagine del contenitore dell'applicazione in locale per verificare le diverse stringhe della versione nelle immagini compilate.

In questa esercitazione l'attività di Registro Azure Container crea un'immagine del contenitore dell'applicazione specificata in un documento Dockerfile e ne esegue il push. Le funzionalità di Attività del Registro Azure Container consentono anche di eseguire attività in più passi, usando un file YAML per definire i passaggi per creare, eseguire il push e facoltativamente testare più contenitori.

Compilare l'immagine di base

Per iniziare, compilare l'immagine di base con un'attività rapida di Attività del Registro Azure Container usando il comando az acr build. Come illustrato nella prima esercitazione della serie, questo processo non solo compila l'immagine, ma ne esegue anche il push nel registro contenitori, se la compilazione viene completata correttamente. In questo esempio viene eseguito il push dell'immagine nel registro immagini di base.

az acr build --registry $BASE_ACR --image baseimages/node:15-alpine --file Dockerfile-base .

Creare un'attività per tenere traccia dell'immagine di base privata

Verrà creata un'attività nel registro delle immagini dell'applicazione con il comando az acr task create, abilitando un'identità gestita. L'identità gestita verrà usata nei passaggi successivi per consentire all'attività di eseguire l'autenticazione con il registro immagini di base.

Questo esempio usa un'identità assegnata dal sistema, ma per determinati scenari è possibile creare e abilitare un'identità gestita assegnata dall'utente. Per informazioni dettagliate, vedere Autenticazione tra più registri in un'attività del Registro Azure Container usando un'identità gestita da Azure.

az acr task create \
    --registry $ACR_NAME \
    --name baseexample2 \
    --image helloworld:{{.Run.ID}} \
    --context https://github.com/$GIT_USER/acr-build-helloworld-node.git#main \
    --file Dockerfile-app \
    --git-access-token $GIT_PAT \
    --arg REGISTRY_NAME=$BASE_ACR.azurecr.io \
    --assign-identity

Questa attività, simile a quella creata nell'esercitazione precedente, indica ad ACR Tasks di attivare una compilazione dell'immagine quando viene eseguito il push di commit nel repository specificato da --context. Mentre il documento Dockerfile usato per compilare l'immagine nell'esercitazione precedente specifica un'immagine di base pubblica (FROM node:15-alpine), il documento Dockerfile in questa attività, Dockerfile-app, specifica un'immagine di base nel registro immagini di base:

FROM ${REGISTRY_NAME}/baseimages/node:15-alpine

Questa configurazione semplifica la simulazione di una patch del framework nell'immagine di base più avanti in questa esercitazione.

Assegnare all'identità le autorizzazioni per il pull nel registro di base

Per assegnare all'identità gestita dell'attività le autorizzazioni per il pull delle immagini dal registro immagini di base, è prima necessario eseguire il comando az acr task show per ottenere l'ID dell'entità servizio dell'identità. Eseguire quindi il comando az acr show per ottenere l'ID risorsa del registro di base:

# Get service principal ID of the task
principalID=$(az acr task show --name baseexample2 --registry $ACR_NAME --query identity.principalId --output tsv) 

# Get resource ID of the base registry
baseregID=$(az acr show --name $BASE_ACR --query id --output tsv)

Per assegnare all'identità gestita le autorizzazioni per il pull nel registro, eseguire il comando az role assignment create:

az role assignment create \
  --assignee $principalID \
  --scope $baseregID --role acrpull

Aggiungere le credenziali del registro di destinazione all'attività

Eseguire il comando az acr task credential add per aggiungere le credenziali all'attività. Passare il parametro --use-identity [system] per specificare che l'identità gestita assegnata dal sistema dell'attività può accedere alle credenziali.

az acr task credential add \
  --name baseexample2 \
  --registry $ACR_NAME \
  --login-server $BASE_ACR.azurecr.io \
  --use-identity [system]

Eseguire manualmente l'attività

Usare az acr task run per attivare manualmente l'attività e creare l'immagine dell'applicazione. Questo passaggio è necessario per garantire che l'attività tenga traccia delle dipendenze dell'immagine dell'applicazione nell'immagine di base.

az acr task run --registry $ACR_NAME --name baseexample2

Al termine dell'attività, se si intende completare il passaggio facoltativo seguente prendere nota del valore di ID esecuzione (ad esempio, "da6").

Facoltativo: eseguire il contenitore dell'applicazione in locale

Se si lavora in locale (non in Cloud Shell) ed è installato Docker, eseguire il contenitore per verificare il rendering dell'applicazione in un Web browser prima di ricompilare l'immagine di base. Se si usa Cloud Shell, ignorare questa sezione. Cloud Shell non supporta az acr login né docker run.

Prima di tutto, eseguire l'autenticazione nel registro contenitori con az acr login:

az acr login --name $ACR_NAME

Eseguire quindi il contenitore in locale con docker run. Sostituire <run-id> con il valore di "ID esecuzione" riportato nell'output del passaggio precedente (ad esempio, "da6"). Questo esempio assegna al contenitore il nome myapp e include il parametro --rm per rimuovere il contenitore quando viene arrestato.

docker run -d -p 8080:80 --name myapp --rm $ACR_NAME.azurecr.io/helloworld:<run-id>

Passare a http://localhost:8080 nel browser. Nella pagina Web verrà visualizzato il rendering del numero di versione di Node.js, simile allo screenshot seguente. In un passaggio successivo si modificherà la versione aggiungendo una "a" alla stringa della versione.

Screenshot dell'applicazione di esempio nel browser

Per arrestare e rimuovere il contenitore, eseguire questo comando:

docker stop myapp

Elencare le compilazioni

Elencare quindi le esecuzioni delle attività completate dal Registro Azure Container per il registro usando il comando az acr task list-runs:

az acr task list-runs --registry $ACR_NAME --output table

Se è stata completata l'esercitazione precedente e non è stato eliminato il registro, l'output visualizzato dovrebbe essere simile al seguente. Prendere nota del numero di esecuzioni delle attività e del valore di ID esecuzione più recente per poter confrontare l'output dopo l'aggiornamento dell'immagine di base nella sezione successiva.

az acr task list-runs --registry $ACR_NAME --output table

UN ID    TASK            PLATFORM    STATUS     TRIGGER       STARTED               DURATION
--------  --------------  ----------  ---------  ------------  --------------------  ----------
ca12      baseexample2    linux       Succeeded  Manual        2020-11-21T00:00:56Z  00:00:36
ca11      baseexample1    linux       Succeeded  Image Update  2020-11-20T23:38:24Z  00:00:34
ca10      taskhelloworld  linux       Succeeded  Image Update  2020-11-20T23:38:24Z  00:00:24
cay                       linux       Succeeded  Manual        2020-11-20T23:38:08Z  00:00:22
cax       baseexample1    linux       Succeeded  Manual        2020-11-20T23:33:12Z  00:00:30
caw       taskhelloworld  linux       Succeeded  Commit        2020-11-20T23:16:07Z  00:00:29

Aggiornare l'immagine di base

In questa sezione si simula l'applicazione di una patch del framework nell'immagine di base. Modificare Dockerfile-base e aggiungere una "a" dopo il numero di versione definito in NODE_VERSION:

ENV NODE_VERSION 15.2.1a

Eseguire un'attività rapida per compilare l'immagine di base modificata. Prendere nota del valore di ID esecuzione nell'output.

az acr build --registry $BASE_ACR --image baseimages/node:15-alpine --file Dockerfile-base .

Al termine della compilazione e del push della nuova immagine di base nel registro, ACR Tasks attiva una compilazione dell'immagine dell'applicazione. Prima che l'attività creata in precedenza attivi la compilazione dell'immagine dell'applicazione potrebbero trascorrere alcuni istanti, perché deve essere rilevata l'immagine di base appena compilata e sottoposta a push.

Elencare la compilazione aggiornata

Dopo aver aggiornato l'immagine di base, visualizzare di nuovo l'elenco delle esecuzioni delle attività per confrontarlo con l'elenco precedente. Se inizialmente l'output non presenta differenze, eseguire periodicamente il comando finché la nuova esecuzione dell'attività non risulta inclusa nell'elenco.

az acr task list-runs --registry $ACR_NAME --output table

L'output è simile al seguente. Il valore di TRIGGER per l'ultima compilazione eseguita sarà "Image Update", che indica che l'attività è stata avviata dall'attività rapida dell'immagine di base.

az acr task list-runs --registry $ACR_NAME --output table

         PLATFORM    STATUS     TRIGGER       STARTED               DURATION
--------  --------------  ----------  ---------  ------------  --------------------  ----------
ca13      baseexample2    linux       Succeeded  Image Update  2020-11-21T00:06:00Z  00:00:43
ca12      baseexample2    linux       Succeeded  Manual        2020-11-21T00:00:56Z  00:00:36
ca11      baseexample1    linux       Succeeded  Image Update  2020-11-20T23:38:24Z  00:00:34
ca10      taskhelloworld  linux       Succeeded  Image Update  2020-11-20T23:38:24Z  00:00:24
cay                       linux       Succeeded  Manual        2020-11-20T23:38:08Z  00:00:22
cax       baseexample1    linux       Succeeded  Manual        2020-11-20T23:33:12Z  00:00:30
caw       taskhelloworld  linux       Succeeded  Commit        2020-11-20T23:16:07Z  00:00:29

Se si vuole eseguire il passaggio facoltativo seguente che prevede l'esecuzione del contenitore appena compilato per visualizzare il numero di versione aggiornato, prendere nota del valore di ID esecuzione della compilazione attivata da "Image Update" (nell'output precedente, "ca13").

Facoltativo: eseguire l'immagine appena compilata

Se si lavora in locale (non in Cloud Shell) ed è installato Docker, al termine della compilazione eseguire la nuova immagine dell'applicazione. Sostituire <run-id> con il valore di ID esecuzione ottenuto nel passaggio precedente. Se si usa Cloud Shell, ignorare questa sezione. Cloud Shell non supporta docker run.

docker run -d -p 8081:80 --name updatedapp --rm $ACR_NAME.azurecr.io/helloworld:<run-id>

Passare a http://localhost:8081 nel browser. Nella pagina Web verrà visualizzato il numero di versione di Node.js aggiornato con "a":

Screenshot dell'applicazione di esempio aggiornata nel browser

È importante notare che si è aggiornata l'immagine di base con un nuovo numero di versione, ma questo viene visualizzato nell'ultima immagine compilata dell'applicazione. ACR Tasks ha rilevato la modifica apportata all'immagine di base e ha ricompilato automaticamente l'immagine dell'applicazione.