Tutorial: criar e implantar imagens de contêineres na nuvem com as Tarefas do Registro de Contêiner do AzureTutorial: Build and deploy container images in the cloud with Azure Container Registry Tasks

As Tarefas do ACR são um pacote de recursos no Registro de Contêiner do Azure que fornece builds de imagem de contêiner do Docker aprimorados e eficientes no Azure.ACR Tasks is a suite of features within Azure Container Registry that provides streamlined and efficient Docker container image builds in Azure. Neste artigo, você aprenderá a usar o recurso tarefa rápida das Tarefas do ACR.In this article, you learn how to use the quick task feature of ACR Tasks.

O ciclo de desenvolvimento “loop interno” é o processo iterativo de escrever código, compilar e testar seu aplicativo antes de confirmá-lo no controle do código-fonte.The "inner-loop" development cycle is the iterative process of writing code, building, and testing your application before committing to source control. Uma tarefa rápida estende o “loop interno” para a nuvem, fornecendo validação de sucesso de build e push automático de imagens criadas com êxito para o registro de contêiner.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. As imagens são criadas nativamente na nuvem, perto de seu registro, permitindo a implantação mais rápida.Your images are built natively in the cloud, close to your registry, enabling faster deployment.

Todos os seus conhecimentos do Dockerfile são transferíveis diretamente para as Tarefas do ACR.All your Dockerfile expertise is directly transferrable to ACR Tasks. Você não precisa alterar seus Dockerfiles para compilar na nuvem com as Tarefas do ACR, apenas o comando que você executa.You don't have to change your Dockerfiles to build in the cloud with ACR Tasks, just the command you run.

Neste tutorial, a primeira parte de uma série:In this tutorial, part one of a series:

  • Obter o código-fonte do aplicativo de exemploGet the sample application source code
  • Criar uma imagem de contêiner no AzureBuild a container image in Azure
  • Implantar um contêiner em Instâncias de Contêiner do AzureDeploy a container to Azure Container Instances

Em tutoriais subsequentes, você aprenderá a usar as Tarefas do ACR para builds de imagem de contêiner automatizados na confirmação de código e atualização da imagem base.In subsequent tutorials, you learn to use ACR Tasks for automated container image builds on code commit and base image update. As Tarefas do ACR também podem executar tarefas de várias etapas, usando um arquivo YAML para definir as etapas para criar, efetuar push e, opcionalmente, testar vários contêineres.ACR Tasks can also run multi-step tasks, using a YAML file to define steps to build, push, and optionally test multiple containers.

Usar o Azure Cloud ShellUse Azure Cloud Shell

O Azure hospeda o Azure Cloud Shell, um ambiente de shell interativo que pode ser usado por meio do navegador.Azure hosts Azure Cloud Shell, an interactive shell environment that you can use through your browser. É possível usar o bash ou o PowerShell com o Cloud Shell para trabalhar com os serviços do Azure.You can use either Bash or PowerShell with Cloud Shell to work with Azure services. É possível usar os comandos pré-instalados do Cloud Shell para executar o código neste artigo sem precisar instalar nada no seu ambiente local.You can use the Cloud Shell preinstalled commands to run the code in this article without having to install anything on your local environment.

Para iniciar o Azure Cloud Shell:To start Azure Cloud Shell:

OpçãoOption Exemplo/LinkExample/Link
Selecione Experimente no canto superior direito de um bloco de código.Select Try It in the upper-right corner of a code block. Selecionar Experimente não copia automaticamente o código para o Cloud Shell.Selecting Try It doesn't automatically copy the code to Cloud Shell. Exemplo de “Experimente” no Azure Cloud Shell
Acesse https://shell.azure.com ou selecione o botão Iniciar o Cloud Shell para abri-lo no navegador.Go to https://shell.azure.com, or select the Launch Cloud Shell button to open Cloud Shell in your browser. Inicie o Cloud Shell em uma nova janelaLaunch Cloud Shell in a new window
Clique no botão Cloud Shell na barra de menus no canto superior direito do portal do Azure.Select the Cloud Shell button on the top-right menu bar in the Azure portal. Botão Cloud Shell no portal do Azure

Para executar o código neste artigo no Azure Cloud Shell:To run the code in this article in Azure Cloud Shell:

  1. Inicie o Cloud Shell.Start Cloud Shell.

  2. Clique no botão Copiar no bloco de código para copiá-lo.Select the Copy button on a code block to copy the code.

  3. Cole o código na sessão do Cloud Shell ao pressionar Ctrl+Shift+V no Windows e no Linux ou Cmd+Shift+V no 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. Pressione Enter para executar o código.Select Enter to run the code.

Se quiser usar a CLI do Azure localmente, será preciso ter a CLI do Azure versão 2.0.46 ou posterior instalada e conectada com 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. Execute az --version para encontrar a versão.Run az --version to find the version. Se você precisar instalar ou atualizar a CLI, confira como instalar a CLI do Azure.If you need to install or upgrade the CLI, see Install Azure CLI.

Pré-requisitosPrerequisites

Conta do GitHubGitHub account

Crie uma conta no https://github.com caso você ainda não tenha uma.Create an account on https://github.com if you don't already have one. Esta série de tutoriais usa um repositório do GitHub para demonstrar os builds de imagem automatizados nas Tarefas do ACR.This tutorial series uses a GitHub repository to demonstrate automated image builds in ACR Tasks.

Repositório de exemplo de forkFork sample repository

Em seguida, use a interface do usuário do GitHub para dividir o repositório de exemplo em sua conta do GitHub.Next, use the GitHub UI to fork the sample repository into your GitHub account. Neste tutorial, você compilará uma imagem de contêiner da origem no repositório e, no tutorial seguinte, efetuará push de uma confirmação para o seu fork do repositório para iniciar uma tarefa automatizada.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.

Crie fork para este repositório: https://github.com/Azure-Samples/acr-build-helloworld-nodeFork this repository: https://github.com/Azure-Samples/acr-build-helloworld-node

Captura de tela do botão Fork (realçado) no GitHub

Clonar seu forkClone your fork

Depois que você tiver criado o fork do repositório, clone o fork e entre no diretório que contém o clone local.Once you've forked the repo, clone your fork and enter the directory containing your local clone.

Clone o repositório com git, substitua <your-github-username> pelo seu nome de usuário do 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

Insira o diretório que contém o código-fonte:Enter the directory containing the source code:

cd acr-build-helloworld-node

Shell do BashBash shell

Os comandos nesta série de tutoriais são formatados para o shell de Bash.The commands in this tutorial series are formatted for the Bash shell. Se você preferir usar o PowerShell, o Prompt de Comando ou outro shell, convém ajustar a continuação da linha e o formato da variável de ambiente adequadamente.If you prefer to use PowerShell, Command Prompt, or another shell, you may need to adjust the line continuation and environment variable format accordingly.

Compilar no Azure com as Tarefas do ACRBuild in Azure with ACR Tasks

Agora que você efetuou pull do código-fonte para o seu computador, siga estas etapas para compilar um registro de contêiner e a imagem de contêiner com as Tarefas do ACR.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.

Para tornar a execução dos comandos de exemplo mais fácil, os tutoriais desta série usam variáveis de ambiente de shell.To make executing the sample commands easier, the tutorials in this series use shell environment variables. Execute o seguinte comando para definir a variável ACR_NAME.Execute the following command to set the ACR_NAME variable. Substitua <registry-name> por um nome exclusivo para seu novo registro de contêiner.Replace <registry-name> with a unique name for your new container registry. O nome do Registro precisa ser exclusivo no Azure, conter apenas letras minúsculas e conter de 5 a 50 caracteres alfanuméricos.The registry name must be unique within Azure, contain only lower case letters, and contain 5-50 alphanumeric characters. Os outros recursos que você cria no tutorial se baseiam nesse nome, e você precisará modificar apenas essa primeira variável.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>

Com a variável de ambiente de registro de contêiner preenchida, agora você deverá ser capaz de copiar e colar o restante dos comandos no tutorial sem editar valores.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. Execute os comandos a seguir para criar um registro de contêiner e um grupo de recursos: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

Agora que você tem um Registro, use as Tarefas do ACR para compilar uma imagem de contêiner com base no código de exemplo.Now that you have a registry, use ACR Tasks to build a container image from the sample code. Execute o comando az acr build para executar uma tarefa rápida:Execute the az acr build command to perform a quick task:

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

A saída do comando az acr build é semelhante ao seguinte.Output from the az acr build command is similar to the following. Você pode ver o upload do código-fonte (o “contexto”) para o Azure e os detalhes da operação docker build que a tarefa do ACR executa na nuvem.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. Como as tarefas do ACR usam docker build para compilar suas imagens, nenhuma alteração nos seus Dockerfiles é necessária para começar a usar as Tarefas do ACR imediatamente.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

No final da saída, as Tarefas do ACR exibem as dependências descobertas para a imagem.Near the end of the output, ACR Tasks displays the dependencies it's discovered for your image. Isso permite que as Tarefas do ACR automatizem os builds de imagem em atualizações da imagem base, como quando uma imagem base é atualizada com os patches de sistema operacional ou de estrutura.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. Você aprenderá sobre a compatibilidade das Tarefas do ACR com as atualizações de imagem base mais tarde nesta série de tutoriais.You learn about ACR Tasks support for base image updates later in this tutorial series.

Implantar para Instâncias de Contêiner do AzureDeploy to Azure Container Instances

As Tarefas do ACR efetuam push automaticamente das imagens criadas com êxito para o registro por padrão, permitindo que sejam implantadas do registro imediatamente.ACR tasks automatically push successfully built images to your registry by default, allowing you to deploy them from your registry immediately.

Nesta seção, você cria um Azure Key Vault e a entidade de serviço e depois implanta o contêiner nas Instâncias de Contêiner do Azure (ACI) usando as credenciais da entidade de serviço.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.

Configurar a autenticação do registroConfigure registry authentication

Todos os cenários de produção devem usar entidades de serviço para acessar um registro de contêiner do Azure.All production scenarios should use service principals to access an Azure container registry. As entidades de serviço permitem que você forneça controle de acesso baseado em função às imagens de contêiner.Service principals allow you to provide role-based access control to your container images. Por exemplo, é possível configurar uma entidade de serviço com acesso somente pull para um registro.For example, you can configure a service principal with pull-only access to a registry.

Criar um cofre de chaveCreate a key vault

Se você ainda não tiver um cofre no Azure Key Vault, crie um com a CLI do Azure usando os comandos a seguir.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

Criar entidade de serviço e armazenar credenciaisCreate a service principal and store credentials

Agora, é necessário criar uma entidade de serviço e armazenar as credenciais no cofre de chaves.You now need to create a service principal and store its credentials in your key vault.

Use o comando az ad sp create-for-rbac para criar a entidade de serviço e az keyvault secret set para armazenar a senha da entidade de serviço no cofre: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)

O argumento --role no comando anterior configura a entidade de serviço com a função acrpull, que permite a ela acesso somente de pull ao Registro.The --role argument in the preceding command configures the service principal with the acrpull role, which grants it pull-only access to the registry. Para permitir acesso de push e pull, altere o argumento --role para acrpush.To grant both push and pull access, change the --role argument to acrpush.

Em seguida, armazene o appId da entidade de serviço no cofre, que é o nome de usuário que você passa para o Registro de Contêiner do Azure para autenticação: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)

Você criou um Azure Key Vault e armazenou dois segredos nele:You've created an Azure Key Vault and stored two secrets in it:

  • $ACR_NAME-pull-usr: a ID da entidade de serviço, para uso como o nome de usuário do registro de contêiner.$ACR_NAME-pull-usr: The service principal ID, for use as the container registry username.
  • $ACR_NAME-pull-pwd: a senha da entidade de serviço, para uso como a senha do registro de contêiner.$ACR_NAME-pull-pwd: The service principal password, for use as the container registry password.

Agora, é possível referenciar esses segredos pelo nome quando você ou os aplicativos e serviços efetuam pull de imagens do registro.You can now reference these secrets by name when you or your applications and services pull images from the registry.

Implantar contêiner com a CLI do AzureDeploy a container with Azure CLI

Agora que as credenciais da entidade de serviço estão armazenadas como segredos do Azure Key Vault, os aplicativos e serviços podem utilizá-las para acessar o registro privado.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.

Execute o seguinte comando az container create para implantar uma instância de contêiner.Execute the following az container create command to deploy a container instance. O comando usa as credenciais da entidade de serviço armazenadas no Azure Key Vault para autenticar no registro de contêiner.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

O valor --dns-name-label deve ser exclusivo no Azure, portanto, o comando anterior acrescenta o nome do registro de contêiner ao rótulo do nome DNS do contêiner.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. A saída do comando exibe o FQDN (nome de domínio totalmente qualificado) do contêiner, por exemplo: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

Anote o FQDN do contêiner, você o usará na próxima seção.Take note of the container's FQDN, you'll use it in the next section.

Verificar a implantaçãoVerify the deployment

Para inspecionar o processo de inicialização do contêiner, use o 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

A saída az container attach exibe primeiro o status do contêiner conforme ele efetua pull da imagem e é iniciado, em seguida, associa STDOUT e STDERR do console local para o do contêiner.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 Server running at http://localhost:80 aparecer, navegue para o FQDN do contêiner no seu navegador para ver o aplicativo em execução.When Server running at http://localhost:80 appears, navigate to the container's FQDN in your browser to see the running application. O FQDN será exibido na saída do comando az container create que você executou na seção anterior.The FQDN should have been displayed in the output of the az container create command you executed in the previous section.

Captura de tela do aplicativo de exemplo renderizado no navegador

Para desanexar o console do contêiner, pressione Control+C.To detach your console from the container, hit Control+C.

Limpar recursosClean up resources

Pare a instância de contêiner com o comando az container delete:Stop the container instance with the az container delete command:

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

Para remover todos os recursos que você criou neste tutorial, incluindo o registro de contêiner, o cofre de chaves e a entidade de serviço, emita os seguintes comandos.To remove all resources you've created in this tutorial, including the container registry, key vault, and service principal, issue the following commands. Esses recursos são usados no tutorial seguinte da série, no entanto, será conveniente mantê-los se você passar diretamente para o próximo tutorial.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

Próximas etapasNext steps

Agora que você testou o loop interno com uma tarefa rápida, configure uma tarefa de build para disparar os builds de imagens de contêiner ao confirmar o código-fonte em um repositório 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: