Esercitazione: Compilare e distribuire immagini dei contenitori nel cloud con Attività del Registro Azure ContainerTutorial: Build and deploy container images in the cloud with Azure Container Registry Tasks

ACR Tasks è un gruppo di funzionalità in Registro Azure Container che consente una compilazione efficiente e semplificata delle immagini dei contenitori Docker in Azure.ACR Tasks is a suite of features within Azure Container Registry that provides streamlined and efficient Docker container image builds in Azure. Questo articolo illustra come usare la funzionalità di attività rapida di ACR Tasks.In this article, you learn how to use the quick task feature of ACR Tasks.

Il ciclo di sviluppo "interno" è il processo iterativo di scrittura di codice, compilazione e test dell'applicazione prima di eseguire il commit nel controllo del codice sorgente.The "inner-loop" development cycle is the iterative process of writing code, building, and testing your application before committing to source control. Un'attività rapida estende il ciclo interno al cloud, con convalida del completamento della compilazione e push automatico delle immagini compilate correttamente nel registro contenitori.A quick task extends your inner-loop to the cloud, providing you with build success validation and automatic pushing of successfully built images to your container registry. Le immagini vengono compilate in modo nativo nel cloud, in prossimità del registro, in modo da velocizzare la distribuzione.Your images are built natively in the cloud, close to your registry, enabling faster deployment.

Tutte le competenze acquisite nei documenti Dockerfile sono trasferibili direttamente ad ACR Tasks.All your Dockerfile expertise is directly transferrable to ACR Tasks. Per la compilazione nel cloud con ACR Tasks non è necessario modificare i documenti Dockerfile, ma solo il comando che viene eseguito.You don't have to change your Dockerfiles to build in the cloud with ACR Tasks, just the command you run.

In questa esercitazione, che è la prima parte di una serie, si apprenderà come:In this tutorial, part one of a series:

  • Ottenere il codice sorgente dell'applicazione di esempioGet the sample application source code
  • Compilare un'immagine del contenitore in AzureBuild a container image in Azure
  • Distribuire un contenitore in Istanze di Azure ContainerDeploy a container to Azure Container Instances

Le esercitazioni successive illustrano come usare ACR Tasks per automatizzare la compilazione delle immagini dei contenitori in caso di commit del codice e di aggiornamento delle immagini di base.In subsequent tutorials, you learn to use ACR Tasks for automated container image builds on code commit and base image update. 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.ACR Tasks can also run multi-step tasks, using a YAML file to define steps to build, push, and optionally test multiple containers.

Usare Azure Cloud ShellUse Azure Cloud Shell

Azure Cloud Shell è un ambiente di shell interattivo ospitato in Azure e usato tramite il browser.Azure hosts Azure Cloud Shell, an interactive shell environment that you can use through your browser. È possibile usare Bash o PowerShell con Cloud Shell per usare i servizi di Azure.You can use either Bash or PowerShell with Cloud Shell to work with Azure services. È possibile usare i comandi preinstallati di Cloud Shell per eseguire il codice contenuto in questo articolo senza dover installare strumenti nell'ambiente locale.You can use the Cloud Shell preinstalled commands to run the code in this article without having to install anything on your local environment.

Per avviare Azure Cloud Shell:To start Azure Cloud Shell:

OpzioneOption Esempio/CollegamentoExample/Link
Selezionare Prova nell'angolo superiore destro di un blocco di codice.Select Try It in the upper-right corner of a code block. La selezione di Prova non comporta la copia automatica del codice in Cloud Shell.Selecting Try It doesn't automatically copy the code to Cloud Shell. Esempio di Prova per Azure Cloud Shell
Passare a https://shell.azure.com o selezionare il pulsante Avvia Cloud Shell per aprire Cloud Shell nel browser.Go to https://shell.azure.com, or select the Launch Cloud Shell button to open Cloud Shell in your browser. Avviare Cloud Shell in una nuova finestraLaunch Cloud Shell in a new window
Selezionare il pulsante Cloud Shell nella barra dei menu nell'angolo superiore destro del portale di Azure.Select the Cloud Shell button on the top-right menu bar in the Azure portal. Pulsante Cloud Shell nel portale di Azure

Per eseguire il codice di questo articolo in Azure Cloud Shell:To run the code in this article in Azure Cloud Shell:

  1. Avviare Cloud Shell.Start Cloud Shell.

  2. Selezionare il pulsante Copia in un blocco di codice per copiare il codice.Select the Copy button on a code block to copy the code.

  3. Incollare il codice nella sessione di Cloud Shell premendo CTRL+MAIUSC+V in Windows e Linux o CMD+MAIUSC+V in macOS.Paste the code into the Cloud Shell session by selecting Ctrl+Shift+V on Windows and Linux or by selecting Cmd+Shift+V on macOS.

  4. Premere INVIO per eseguire il codice.Select Enter to run the code.

Se si preferisce usare l'interfaccia della riga di comando di Azure in locale, è necessario che sia installata la versione 2.0.46 o successiva e che sia stato eseguito l'accesso con az login.If you'd like to use the Azure CLI locally, you must have Azure CLI version 2.0.46 or later installed and logged in with az login. Eseguire az --version per trovare la versione.Run az --version to find the version. Se è necessario installare o aggiornare l'interfaccia della riga di comando, vedere Installare l'interfaccia della riga di comando di Azure.If you need to install or upgrade the CLI, see Install Azure CLI.

PrerequisitiPrerequisites

Account GitHubGitHub account

Se non se ne ha già uno, creare un account in https://github.com.Create an account on https://github.com if you don't already have one. In questa serie di esercitazioni viene usato un repository GitHub per illustrare la compilazione automatica di immagini in ACR Tasks.This tutorial series uses a GitHub repository to demonstrate automated image builds in ACR Tasks.

Creare una copia tramite fork del repository di esempioFork sample repository

Usare quindi l'interfaccia utente di GitHub per creare una copia tramite fork del repository di esempio nell'account GitHub.Next, use the GitHub UI to fork the sample repository into your GitHub account. In questa esercitazione si compila un'immagine del contenitore dall'origine nel repository, mentre nell'esercitazione successiva si esegue il push di un commit nel fork del repository per avviare un'attività automatica.In this tutorial, you build a container image from the source in the repo, and in the next tutorial, you push a commit to your fork of the repo to kick off an automated task.

Creare una copia tramite fork del repository https://github.com/Azure-Samples/acr-build-helloworld-nodeFork this repository: https://github.com/Azure-Samples/acr-build-helloworld-node

Screenshot del pulsante Fork (evidenziato) in GitHub

Clonare il forkClone your fork

Dopo aver creato una copia tramite fork del repository, clonare il fork e passare alla directory contenente il clone locale.Once you've forked the repo, clone your fork and enter the directory containing your local clone.

Clonare il repository con git, sostituendo <your-github-username> con il proprio nome utente GitHub:Clone the repo with git, replace <your-github-username> with your GitHub username:

git clone https://github.com/<your-github-username>/acr-build-helloworld-node

Passare alla directory contenente il codice sorgente:Enter the directory containing the source code:

cd acr-build-helloworld-node

Shell BashBash shell

I comandi in questa serie di esercitazioni sono presentati nel formato per la shell Bash.The commands in this tutorial series are formatted for the Bash shell. Se si preferisce usare PowerShell, il prompt dei comandi o un'altra shell, potrebbe essere necessario modificare di conseguenza il formato di continuazione di riga e delle variabili di ambiente.If you prefer to use PowerShell, Command Prompt, or another shell, you may need to adjust the line continuation and environment variable format accordingly.

Compilare in Azure con ACR TasksBuild in Azure with ACR Tasks

Dopo aver eseguito il pull del codice sorgente nel computer in uso, seguire questa procedura per creare un registro contenitori e compilare l'immagine del contenitore con Attività del Registro Azure Container.Now that you've pulled the source code down to your machine, follow these steps to create a container registry and build the container image with ACR Tasks.

Per semplificare l'esecuzione dei comandi di esempio, nelle esercitazioni di questa serie vengono usate variabili di ambiente della shell.To make executing the sample commands easier, the tutorials in this series use shell environment variables. Eseguire il comando seguente per impostare la variabile ACR_NAME.Execute the following command to set the ACR_NAME variable. Sostituire <registry-name> con un nome univoco per il nuovo registro contenitori.Replace <registry-name> with a unique name for your new container registry. Il nome del registro deve essere univoco in Azure e contenere da 5 a 50 caratteri alfanumerici in minuscolo.The registry name must be unique within Azure, contain only lower case letters, and contain 5-50 alphanumeric characters. Dato che le altre risorse create in questa esercitazione sono basate su questo nome, sarà necessario modificare solo questa prima variabile.The other resources you create in the tutorial are based on this name, so you should need to modify only this first variable.

ACR_NAME=<registry-name>

Dopo aver popolato la variabile di ambiente del registro contenitori, sarà possibile copiare e incollare il resto dei comandi dell'esercitazione senza modificare alcun valore.With the container registry environment variable populated, you should now be able to copy and paste the remainder of the commands in the tutorial without editing any values. Eseguire questi comandi per creare un gruppo di risorse e un registro contenitori:Execute the following commands to create a resource group and container registry:

RES_GROUP=$ACR_NAME # Resource Group name

az group create --resource-group $RES_GROUP --location eastus
az acr create --resource-group $RES_GROUP --name $ACR_NAME --sku Standard --location eastus

Ora che è disponibile un registro, usare Attività del Registro Azure Container per compilare un'immagine del contenitore dal codice di esempio.Now that you have a registry, use ACR Tasks to build a container image from the sample code. Eseguire il comando az acr build per eseguire un'attività rapida:Execute the az acr build command to perform a quick task:

az acr build --registry $ACR_NAME --image helloacrtasks:v1 .

L'output del comando az acr build è simile al seguente.Output from the az acr build command is similar to the following. Vengono visualizzati il caricamento del codice sorgente ("context") in Azure e i dettagli dell'operazione docker build eseguita da ACR Tasks nel cloud.You can see the upload of the source code (the "context") to Azure, and the details of the docker build operation that the ACR task runs in the cloud. Dato che ACR Tasks usa docker build per compilare le immagini, è possibile iniziare a usare subito ACR Tasks senza apportare alcuna modifica ai documenti Dockerfile.Because ACR tasks use docker build to build your images, no changes to your Dockerfiles are required to start using ACR Tasks immediately.

$ az acr build --registry $ACR_NAME --image helloacrtasks:v1 .
Packing source code into tar file to upload...
Sending build context (4.813 KiB) to ACR...
Queued a build with build ID: da1
Waiting for build agent...
2018/08/22 18:31:42 Using acb_vol_01185991-be5f-42f0-9403-a36bb997ff35 as the home volume
2018/08/22 18:31:42 Setting up Docker configuration...
2018/08/22 18:31:43 Successfully set up Docker configuration
2018/08/22 18:31:43 Logging in to registry: myregistry.azurecr.io
2018/08/22 18:31:55 Successfully logged in
Sending build context to Docker daemon   21.5kB
Step 1/5 : FROM node:9-alpine
9-alpine: Pulling from library/node
Digest: sha256:8dafc0968fb4d62834d9b826d85a8feecc69bd72cd51723c62c7db67c6dec6fa
Status: Image is up to date for node:9-alpine
 ---> a56170f59699
Step 2/5 : COPY . /src
 ---> 88087d7e709a
Step 3/5 : RUN cd /src && npm install
 ---> Running in e80e1263ce9a
npm notice created a lockfile as package-lock.json. You should commit this file.
npm WARN helloworld@1.0.0 No repository field.

up to date in 0.1s
Removing intermediate container e80e1263ce9a
 ---> 26aac291c02e
Step 4/5 : EXPOSE 80
 ---> Running in 318fb4c124ac
Removing intermediate container 318fb4c124ac
 ---> 113e157d0d5a
Step 5/5 : CMD ["node", "/src/server.js"]
 ---> Running in fe7027a11787
Removing intermediate container fe7027a11787
 ---> 20a27b90eb29
Successfully built 20a27b90eb29
Successfully tagged myregistry.azurecr.io/helloacrtasks:v1
2018/08/22 18:32:11 Pushing image: myregistry.azurecr.io/helloacrtasks:v1, attempt 1
The push refers to repository [myregistry.azurecr.io/helloacrtasks]
6428a18b7034: Preparing
c44b9827df52: Preparing
172ed8ca5e43: Preparing
8c9992f4e5dd: Preparing
8dfad2055603: Preparing
c44b9827df52: Pushed
172ed8ca5e43: Pushed
8dfad2055603: Pushed
6428a18b7034: Pushed
8c9992f4e5dd: Pushed
v1: digest: sha256:b038dcaa72b2889f56deaff7fa675f58c7c666041584f706c783a3958c4ac8d1 size: 1366
2018/08/22 18:32:43 Successfully pushed image: myregistry.azurecr.io/helloacrtasks:v1
2018/08/22 18:32:43 Step ID acb_step_0 marked as successful (elapsed time in seconds: 15.648945)
The following dependencies were found:
- image:
    registry: myregistry.azurecr.io
    repository: helloacrtasks
    tag: v1
    digest: sha256:b038dcaa72b2889f56deaff7fa675f58c7c666041584f706c783a3958c4ac8d1
  runtime-dependency:
    registry: registry.hub.docker.com
    repository: library/node
    tag: 9-alpine
    digest: sha256:8dafc0968fb4d62834d9b826d85a8feecc69bd72cd51723c62c7db67c6dec6fa
  git: {}

Run ID: da1 was successful after 1m9.970148252s

Nella parte finale dell'output, ACR Tasks mostra le dipendenze individuate per l'immagine.Near the end of the output, ACR Tasks displays the dependencies it's discovered for your image. ACR Tasks può così automatizzare la compilazione di immagini in caso di aggiornamenti dell'immagine di base, ad esempio quando un'immagine di base viene aggiornata con patch del sistema operativo o del framework.This enables ACR Tasks to automate image builds on base image updates, such as when a base image is updated with OS or framework patches. Il supporto di ACR Tasks per gli aggiornamenti delle immagini di base verrà illustrato più avanti in questa serie di esercitazioni.You learn about ACR Tasks support for base image updates later in this tutorial series.

Eseguire la distribuzione in Istanze di Azure ContainerDeploy to Azure Container Instances

Per impostazione predefinita, ACR Tasks esegue automaticamente il push delle immagini compilate correttamente nel registro, dal quale possono essere distribuite immediatamente.ACR tasks automatically push successfully built images to your registry by default, allowing you to deploy them from your registry immediately.

In questa sezione si creano un'istanza di Azure Key Vault e un'entità servizio e quindi si distribuisce il contenitore in Istanze di Azure Container usando le credenziali dell'entità servizio.In this section, you create an Azure Key Vault and service principal, then deploy the container to Azure Container Instances (ACI) using the service principal's credentials.

Configurare l'autenticazione del registroConfigure registry authentication

In tutti gli scenari di produzione dovrebbero essere usate entità servizio per accedere a un registro contenitori di Azure.All production scenarios should use service principals to access an Azure container registry. Mediante le entità servizio è possibile fornire il controllo degli accessi in base al ruolo alle immagini del contenitore.Service principals allow you to provide role-based access control to your container images. Ad esempio, è possibile configurare un'entità servizio con accesso pull-only a un registro.For example, you can configure a service principal with pull-only access to a registry.

Creare un insieme di credenziali delle chiaviCreate a key vault

Se non si ha già un insieme di credenziali delle chiavi in Azure Key Vault, crearne uno usando i comandi seguenti nell'interfaccia della riga di comando di Azure.If you don't already have a vault in Azure Key Vault, create one with the Azure CLI using the following commands.

AKV_NAME=$ACR_NAME-vault

az keyvault create --resource-group $RES_GROUP --name $AKV_NAME

Creare un'entità servizio e archiviare le credenzialiCreate a service principal and store credentials

A questo punto occorre creare un'entità servizio e archiviarne le credenziali nell'insieme di credenziali delle chiavi.You now need to create a service principal and store its credentials in your key vault.

Usare il comando az ad sp create-for-rbac per creare l'entità servizio e az keyvault secret set per archiviare la password dell'entità servizio nell'insieme di credenziali:Use the az ad sp create-for-rbac command to create the service principal, and az keyvault secret set to store the service principal's password in the vault:

# Create service principal, store its password in AKV (the registry *password*)
az keyvault secret set \
  --vault-name $AKV_NAME \
  --name $ACR_NAME-pull-pwd \
  --value $(az ad sp create-for-rbac \
                --name $ACR_NAME-pull \
                --scopes $(az acr show --name $ACR_NAME --query id --output tsv) \
                --role acrpull \
                --query password \
                --output tsv)

L'argomento --role nel comando precedente configura l'entità servizio con il ruolo acrpull, che concede l'accesso al registro con autorizzazioni solo di pull.The --role argument in the preceding command configures the service principal with the acrpull role, which grants it pull-only access to the registry. Per concedere l'accesso con autorizzazioni sia di push che di pull, impostare l'argomento --role su acrpush.To grant both push and pull access, change the --role argument to acrpush.

Archiviare quindi nell'insieme di credenziali il valore appId dell'entità servizio, che è il nome utente passato a Registro Azure Container per l'autenticazione:Next, store the service principal's appId in the vault, which is the username you pass to Azure Container Registry for authentication:

# Store service principal ID in AKV (the registry *username*)
az keyvault secret set \
    --vault-name $AKV_NAME \
    --name $ACR_NAME-pull-usr \
    --value $(az ad sp show --id http://$ACR_NAME-pull --query appId --output tsv)

È stato creato un insieme di credenziali delle chiavi di Azure e vi sono stati archiviati due segreti:You've created an Azure Key Vault and stored two secrets in it:

  • $ACR_NAME-pull-usr: ID dell'entità servizio, da usare come nome utente del registro contenitori.$ACR_NAME-pull-usr: The service principal ID, for use as the container registry username.
  • $ACR_NAME-pull-pwd: password dell'entità servizio, da usare come password del registro contenitori.$ACR_NAME-pull-pwd: The service principal password, for use as the container registry password.

Ora è possibile fare riferimento a questi segreti per nome quando gli utenti o le applicazioni e i servizi eseguono il pull di immagini dal registro.You can now reference these secrets by name when you or your applications and services pull images from the registry.

Distribuire un contenitore con l'interfaccia della riga di comando di AzureDeploy a container with Azure CLI

Ora che le credenziali dell'entità servizio sono archiviate come segreti di Azure Key Vault, le applicazioni e i servizi possono usarle per accedere al registro privato.Now that the service principal credentials are stored as Azure Key Vault secrets, your applications and services can use them to access your private registry.

Eseguire il comando az container create seguente per distribuire un'istanza di contenitore.Execute the following az container create command to deploy a container instance. Il comando usa le credenziali dell'entità servizio archiviate in Azure Key Vault per eseguire l'autenticazione al registro contenitori.The command uses the service principal's credentials stored in Azure Key Vault to authenticate to your container registry.

az container create \
    --resource-group $RES_GROUP \
    --name acr-tasks \
    --image $ACR_NAME.azurecr.io/helloacrtasks:v1 \
    --registry-login-server $ACR_NAME.azurecr.io \
    --registry-username $(az keyvault secret show --vault-name $AKV_NAME --name $ACR_NAME-pull-usr --query value -o tsv) \
    --registry-password $(az keyvault secret show --vault-name $AKV_NAME --name $ACR_NAME-pull-pwd --query value -o tsv) \
    --dns-name-label acr-tasks-$ACR_NAME \
    --query "{FQDN:ipAddress.fqdn}" \
    --output table

Dato che il valore di --dns-name-label deve essere univoco in Azure, il comando precedente aggiunge il nome del registro contenitori all'etichetta del nome DNS del contenitore.The --dns-name-label value must be unique within Azure, so the preceding command appends your container registry's name to the container's DNS name label. L'output del comando visualizza il nome di dominio completo (FQDN) del contenitore, ad esempio:The output from the command displays the container's fully qualified domain name (FQDN), for example:

$ az container create \
>     --resource-group $RES_GROUP \
>     --name acr-tasks \
>     --image $ACR_NAME.azurecr.io/helloacrtasks:v1 \
>     --registry-login-server $ACR_NAME.azurecr.io \
>     --registry-username $(az keyvault secret show --vault-name $AKV_NAME --name $ACR_NAME-pull-usr --query value -o tsv) \
>     --registry-password $(az keyvault secret show --vault-name $AKV_NAME --name $ACR_NAME-pull-pwd --query value -o tsv) \
>     --dns-name-label acr-tasks-$ACR_NAME \
>     --query "{FQDN:ipAddress.fqdn}" \
>     --output table
FQDN
----------------------------------------------
acr-tasks-myregistry.eastus.azurecontainer.io

Prendere nota del nome di dominio completo del contenitore, perché verrà usato nella sezione successiva.Take note of the container's FQDN, you'll use it in the next section.

Verificare la distribuzioneVerify the deployment

Per controllare il processo di avvio del contenitore, usare il comando az container attach:To watch the startup process of the container, use the az container attach command:

az container attach --resource-group $RES_GROUP --name acr-tasks

L'output di az container attach mostra per prima cosa lo stato del contenitore durante il pull dell'immagine e l'avvio, quindi associa STDOUT e STDERR della console locale a STDOUT e STDERR del contenitore.The az container attach output first displays the container's status as it pulls the image and starts, then binds your local console's STDOUT and STDERR to that of the container's.

$ az container attach --resource-group $RES_GROUP --name acr-tasks
Container 'acr-tasks' is in state 'Running'...
(count: 1) (last timestamp: 2018-08-22 18:39:10+00:00) pulling image "myregistry.azurecr.io/helloacrtasks:v1"
(count: 1) (last timestamp: 2018-08-22 18:39:15+00:00) Successfully pulled image "myregistry.azurecr.io/helloacrtasks:v1"
(count: 1) (last timestamp: 2018-08-22 18:39:17+00:00) Created container
(count: 1) (last timestamp: 2018-08-22 18:39:17+00:00) Started container

Start streaming logs:
Server running at http://localhost:80

Quando viene visualizzato Server running at http://localhost:80, passare al nome di dominio completo del contenitore nel browser per visualizzare l'applicazione in esecuzione.When Server running at http://localhost:80 appears, navigate to the container's FQDN in your browser to see the running application. Il nome di dominio completo dovrebbe essere visualizzato nell'output del comando az container create eseguito nella sezione precedente.The FQDN should have been displayed in the output of the az container create command you executed in the previous section.

Screenshot del rendering dell'applicazione di esempio nel browser

Per scollegare la console dal contenitore, premere Control+C.To detach your console from the container, hit Control+C.

Pulire le risorseClean up resources

Arrestare l'istanza del contenitore con il comando az container delete:Stop the container instance with the az container delete command:

az container delete --resource-group $RES_GROUP --name acr-tasks

Per rimuovere tutte le risorse create in questa esercitazione, inclusi il registro contenitori, l'insieme di credenziali delle chiavi e l'entità servizio, eseguire questi comandi.To remove all resources you've created in this tutorial, including the container registry, key vault, and service principal, issue the following commands. Tali risorse, tuttavia, vengono usate nell'esercitazione successiva della serie ed è quindi consigliabile mantenerle se si intende passare direttamente a tale esercitazione.These resources are used in the next tutorial in the series, however, so you might want to keep them if you move on directly to the next tutorial.

az group delete --resource-group $RES_GROUP
az ad sp delete --id http://$ACR_NAME-pull

Passaggi successiviNext steps

Dopo aver testato il ciclo interno con un'attività rapida, configurare un'attività di compilazione per attivare compilazioni delle immagini dei contenitori quando si esegue il commit di codice sorgente in un repository Git:Now that you've tested your inner loop with a quick task, configure a build task to trigger container images builds when you commit source code to a Git repository: