GSP055

Visão geral

O Docker é uma plataforma aberta para desenvolvimento, envio e execução de aplicativos. Com ele, você pode separar os aplicativos da sua infraestrutura e tratá-la como um aplicativo gerenciado. A plataforma agiliza o envio de códigos, os testes e as implantações, além de encurtar o ciclo entre a criação e a execução do código.

Para isso, o Docker combina recursos de conteinerização do kernel com fluxos de trabalho e ferramentas que ajudam no gerenciamento e na implantação dos seus aplicativos.

Os contêineres do Docker podem ser usados diretamente no Kubernetes, o que facilita a execução no Kubernetes Engine. Depois de aprender os conceitos básicos do Docker, você terá as habilidades necessárias para começar a desenvolver aplicativos conteinerizados e no Kubernetes.

Objetivos

Neste laboratório, você vai aprender a:

• Criar, executar e depurar contêineres do Docker.
• Extrair imagens Docker no Docker Hub e no Google Artifact Registry.
• Enviar imagens Docker para o Google Artifact Registry.

Pré-requisitos

Este é um laboratório de nível introdutório. Ele não exige experiência com o Docker e contêineres. Conhecer o Cloud Shell e a linha de comando é recomendável, mas não obrigatório.

Configuração e requisitos

Antes de clicar no botão Start Lab

Leia estas instruções. Os laboratórios são cronometrados e não podem ser pausados. O timer é iniciado quando você clica em Começar o laboratório e mostra por quanto tempo os recursos do Google Cloud vão ficar disponíveis.

Este laboratório prático permite que você realize as atividades em um ambiente real de nuvem, não em uma simulação ou demonstração. Você vai receber novas credenciais temporárias para fazer login e acessar o Google Cloud durante o laboratório.

Confira os requisitos para concluir o laboratório:

• Acesso a um navegador de Internet padrão (recomendamos o Chrome).

Observação: para executar este laboratório, use o modo de navegação anônima ou uma janela anônima do navegador. Isso evita conflitos entre sua conta pessoal e a conta de estudante, o que poderia causar cobranças extras na sua conta pessoal.

• Tempo para concluir o laboratório---não se esqueça: depois de começar, não será possível pausar o laboratório.

Observação: não use seu projeto ou conta do Google Cloud neste laboratório para evitar cobranças extras na sua conta.

Como iniciar seu laboratório e fazer login no console do Google Cloud

1. Clique no botão Começar o laboratório. Se for preciso pagar, você verá um pop-up para selecionar a forma de pagamento. No painel Detalhes do laboratório à esquerda, você verá o seguinte:

   • O botão Abrir Console do Cloud
   • Tempo restante
   • As credenciais temporárias que você vai usar neste laboratório
   • Outras informações se forem necessárias

2. Clique em Abrir Console do Google. O laboratório ativa recursos e depois abre outra guia com a página Fazer login.

   Dica: coloque as guias em janelas separadas lado a lado.

   Observação: se aparecer a caixa de diálogo Escolher uma conta, clique em Usar outra conta.

3. Caso seja preciso, copie o Nome de usuário no painel Detalhes do laboratório e cole esse nome na caixa de diálogo Fazer login. Clique em Avançar.

4. Copie a Senha no painel Detalhes do laboratório e a cole na caixa de diálogo Olá. Clique em Avançar.

   Importante: você precisa usar as credenciais do painel à esquerda. Não use suas credenciais do Google Cloud Ensina. Observação: se você usar sua própria conta do Google Cloud neste laboratório, é possível que receba cobranças adicionais.

5. Acesse as próximas páginas:

   • Aceite os Termos e Condições.
   • Não adicione opções de recuperação nem autenticação de dois fatores (porque essa é uma conta temporária).
   • Não se inscreva em testes gratuitos.

Depois de alguns instantes, o console do GCP vai ser aberto nesta guia.

Observação: para ver uma lista dos produtos e serviços do Google Cloud, clique no Menu de navegação no canto superior esquerdo.

Ativar o Cloud Shell

O Cloud Shell é uma máquina virtual com várias ferramentas de desenvolvimento. Ele tem um diretório principal permanente de 5 GB e é executado no Google Cloud. O Cloud Shell oferece acesso de linha de comando aos recursos do Google Cloud.

1. Clique em Ativar o Cloud Shell na parte de cima do console do Google Cloud.

Depois de se conectar, vai notar que sua conta já está autenticada, e que o projeto está configurado com seu PROJECT_ID. A saída contém uma linha que declara o projeto PROJECT_ID para esta sessão:

Your Cloud Platform project in this session is set to YOUR_PROJECT_ID

gcloud é a ferramenta de linha de comando do Google Cloud. Ela vem pré-instalada no Cloud Shell e aceita preenchimento com tabulação.

2. (Opcional) É possível listar o nome da conta ativa usando este comando:

gcloud auth list

3. Clique em Autorizar.

4. A saída será parecida com esta:

Saída:

ACTIVE: * ACCOUNT: student-01-xxxxxxxxxxxx@qwiklabs.net To set the active account, run: $ gcloud config set account `ACCOUNT`

5. (Opcional) É possível listar o ID do projeto usando este comando:

gcloud config list project

Saída:

[core] project = <project_ID>

Exemplo de saída:

[core] project = qwiklabs-gcp-44776a13dea667a6 Observação: para conferir a documentação completa da gcloud, acesse o guia com informações gerais sobre a gcloud CLI no Google Cloud.

Tarefa 1: Hello World

1. No Cloud Shell, digite o comando a seguir para executar um contêiner do Hello World:

docker run hello-world

Resposta ao comando

Unable to find image 'hello-world:latest' locally latest: Pulling from library/hello-world 9db2ca6ccae0: Pull complete Digest: sha256:4b8ff392a12ed9ea17784bd3c9a8b1fa3299cac44aca35a85c90c5e3c7afacdc Status: Downloaded newer image for hello-world:latest Hello from Docker! This message shows that your installation appears to be working correctly. ...

Esse contêiner simples exibe a mensagem Hello from Docker!. O comando é simples, mas observe na saída o número de etapas que ele executou. O daemon do Docker procurou a imagem do Hello World, não a encontrou no local, extraiu a imagem de um registro público chamado Docker Hub, criou um contêiner dessa imagem e o executou para você.

2. Execute o comando a seguir para examinar a imagem do contêiner extraída do Docker Hub:

docker images

Resposta ao comando

REPOSITORY TAG IMAGE ID CREATED SIZE hello-world latest feb5d9fea6a5 14 months ago 13.3kB

Essa é a imagem extraída do registro público Docker Hub. O ID da imagem tem o formato de hash SHA256 (em inglês). Esse campo especifica a imagem do Docker que foi provisionada. Quando o daemon do Docker não encontra uma imagem no local, ele procura a imagem no registro público por padrão.

3. Execute o contêiner novamente:

docker run hello-world

Resposta ao comando

Hello from Docker! This message shows that your installation appears to be working correctly. To generate this message, Docker took the following steps: ...

Quando você executar esse comando pela segunda vez, o daemon do Docker vai encontrar a imagem no registro local e executar o contêiner a partir dela. Não será mais necessário extrair a imagem do Docker Hub.

4. Por último, para examinar os contêineres em execução, use o seguinte comando:

docker ps

Resposta ao comando

CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES

Não há contêineres em execução. Você já saiu dos contêineres do Hello World executados anteriormente.

5. Para conferir todos os contêineres, inclusive os que não estão mais em execução, use o comando docker ps -a:

docker ps -a

Resposta ao comando

CONTAINER ID IMAGE COMMAND ... NAMES 6027ecba1c39 hello-world "/hello" ... elated_knuth 358d709b8341 hello-world "/hello" ... epic_lewin

Essa resposta mostra metadados relativos à execução e o Container ID, um UUID gerado pelo Docker para identificar o contêiner. Os Names dos contêineres também são gerados aleatoriamente, mas podem ser especificados com o comando docker run --name [container-name] hello-world.

Tarefa 2: Criação

Nesta seção, você vai criar uma imagem do Docker baseada em um aplicativo de nó simples.

1. Execute o comando abaixo para criar e alternar para uma pasta chamada test.

mkdir test && cd test

2. Crie um Dockerfile:

cat > Dockerfile <<EOF # Use um tempo de execução oficial do Node como imagem pai FROM node:lts # Defina o diretório de trabalho no contêiner como /app WORKDIR /app # Copie o conteúdo do diretório atual para o contêiner em/app ADD . /app # Disponibilize a porta 80 do contêiner para o mundo exterior EXPOSE 80 # Execute app.js usando o nó quando o contêiner for iniciado CMD ["node", "app.js"] EOF

O arquivo instrui o daemon do Docker sobre como criar a imagem.

• A linha inicial especifica a imagem primária de base, que, nesse caso, é a imagem oficial do Docker para suporte de longo prazo (LTS) da versão do nó.
• Na segunda linha, você define o diretório de trabalho atual do contêiner.
• Na terceira, você adiciona ao contêiner o conteúdo do diretório atual, indicado por ".".
• Em seguida, exponha a porta do contêiner para que ela possa aceitar conexões e, por fim, execute o comando do nó para iniciar o aplicativo.

Observação: analise as referências dos comandos do Dockerfile (em inglês) para entender todas as linhas do Dockerfile.

Agora você vai criar o aplicativo do nó e depois a imagem.

3. Execute o comando abaixo para criar o aplicativo do nó:

cat > app.js << EOF; const http = require("http"); const hostname = "0.0.0.0"; const port = 80; const server = http.createServer((req, res) => { res.statusCode = 200; res.setHeader("Content-Type", "text/plain"); res.end("Hello World\n"); }); server.listen(port, hostname, () => { console.log("Server running at http://%s:%s/", hostname, port); }); process.on("SIGINT", function () { console.log("Caught interrupt signal and will exit"); process.exit(); }); EOF

Esse é um servidor HTTP simples que detecta atividade na porta 80 e retorna "Hello World".

Agora crie a imagem.

4. Observe novamente o ".", que indica o diretório atual. Você precisa executar este comando dentro do diretório que contém o Dockerfile:

docker build -t node-app:0.1 .

A execução desse comando pode levar alguns minutos. Ao terminar, a resposta será parecida com esta:

+] Building 0.7s (8/8) FINISHED docker:default => [internal] load .dockerignore 0.0s => => transferring context: 2B 0.0s => [internal] load build definition from Dockerfile 0.0s => => transferring dockerfile: 397B 0.0s => [internal] load metadata for docker.io/library/node:lts

O -t nomeia e marca uma imagem com a sintaxe name:tag. O nome da imagem é node-app, e a tag é 0.1. É altamente recomendado usar a tag para criar imagens do Docker. Se você não especificar uma tag, ela vai receber o valor latest por padrão. Dessa forma, será mais difícil distinguir as imagens mais recentes das mais antigas. Observe também como cada linha no Dockerfile acima resulta em camadas de contêiner intermediárias à medida que a imagem é criada.

5. Agora execute o comando a seguir para conferir as imagens que você criou:

docker images

A saída será parecida com esta:

REPOSITORY TAG IMAGE ID CREATED SIZE node-app 0.1 f166cd2a9f10 25 seconds ago 656.2 MB node lts 5a767079e3df 15 hours ago 656.2 MB hello-world latest 1815c82652c0 6 days ago 1.84 kB

O node é a imagem de base e o node-app é a imagem que você criou. Não é possível remover o node sem remover o node-app primeiro. O tamanho da imagem é relativamente pequeno em comparação com as VMs. Outras versões da imagem do nó, como node:slim e node:alpine, podem ser ainda menores para facilitar a portabilidade. A redução do tamanho dos contêineres é explorada mais a fundo nos tópicos avançados. Todas as versões do repositório oficial estão disponíveis nesta página.

Tarefa 3: Execução

1. Use o código a seguir para executar contêineres baseados na imagem que você criou:

docker run -p 4000:80 --name my-app node-app:0.1

Resposta ao comando

Server running at http://0.0.0.0:80/

A flag --name permite nomear o contêiner. O -p instrui o Docker a mapear a porta 4000 do host para a porta 80 do contêiner. Agora você pode acessar o servidor em http://localhost:4000. Sem o mapeamento de portas, você não poderia acessar o contêiner em localhost.

2. Abra outro terminal (no Cloud Shell, clique no ícone +) e teste o servidor:

curl http://localhost:4000

Resposta ao comando

Hello World

O contêiner será executado enquanto o terminal inicial estiver em funcionamento. Se você quiser que o contêiner seja executado em segundo plano (não vinculado à sessão do terminal), será necessário especificar a sinalização -d.

3. Feche o terminal inicial e execute o comando a seguir para interromper e remover o contêiner:

docker stop my-app && docker rm my-app

4. Agora execute este comando para iniciar o contêiner em segundo plano:

docker run -p 4000:80 --name my-app -d node-app:0.1 docker ps

Resposta ao comando

CONTAINER ID IMAGE COMMAND CREATED ... NAMES xxxxxxxxxxxx node-app:0.1 "node app.js" 16 seconds ago ... my-app

5. Observe que o contêiner está sendo executado na saída do docker ps. Para conferir os registros, execute docker logs [container_id].

Observação: você não vai precisar escrever todo o ID do contêiner desde que os caracteres iniciais o identifiquem de maneira exclusiva. Por exemplo, você poderá executar docker logs 17b se o ID do contêiner for 17bcaca6f.... docker logs [container_id]

Resposta ao comando

Server running at http://0.0.0.0:80/

Agora modifique o aplicativo.

1. No Cloud Shell, abra o diretório de teste criado anteriormente no laboratório:

cd test

2. Edite o arquivo app.js com um editor de texto da sua escolha, como o nano ou o vim, e substitua "Hello World" por outra string:

.... const server = http.createServer((req, res) => { res.statusCode = 200; res.setHeader('Content-Type', 'text/plain'); res.end('Welcome to Cloud\n'); }); ....

3. Crie a nova imagem e atribua a tag 0.2 a ela:

docker build -t node-app:0.2 .

Resposta ao comando

[+] Building 0.7s (8/8) FINISHED docker:default => [internal] load .dockerignore 0.0s => => transferring context: 2B 0.0s => [internal] load build definition from Dockerfile 0.0s => => transferring dockerfile: 397B 0.0s => [internal] load metadata for docker.io/library/node:lts 0.5s

Observe que, na etapa 2, você usou uma camada de cache atual. Da etapa 3 em diante, as camadas serão modificadas porque você alterou o app.js.

4. Execute outro contêiner com a nova versão da imagem. Mapeamos a porta 8080 do host em vez da 80. Não é possível usar a porta 4000 do host porque ela já está sendo utilizada.

docker run -p 8080:80 --name my-app-2 -d node-app:0.2 docker ps

Resposta ao comando

CONTAINER ID IMAGE COMMAND CREATED xxxxxxxxxxxx node-app:0.2 "node app.js" Há 53 segundos ... xxxxxxxxxxxx node-app:0.1 "node app.js" Há cerca de uma hora ...

5. Teste os contêineres:

curl http://localhost:8080

Resposta ao comando

Welcome to Cloud

6. Agora teste o primeiro contêiner que você fez:

curl http://localhost:4000

Resposta ao comando

Hello World

Tarefa 4: Depuração

Agora que você sabe como criar e executar contêineres, confira algumas práticas de depuração.

1. Para acessar os registros de um contêiner, use o comando docker logs [container_id]. Para seguir a saída do registro com o contêiner em execução, use a opção -f.

docker logs -f [container_id]

Resposta ao comando

Server running at http://0.0.0.0:80/

Em alguns momentos, é melhor iniciar uma sessão interativa de Bash dentro do contêiner em execução.

2. Você pode usar o docker exec para fazer isso. Abra outro terminal (no Cloud Shell, clique no ícone +) e insira o seguinte comando:

docker exec -it [container_id] bash

Com as flags -it, aloque um pseudo-tty e mantenha o stdin aberto para interagir com um contêiner. Observe que o bash foi executado no diretório (/app) WORKDIR especificado no Dockerfile. Agora, você tem uma sessão de shell interativa dentro do contêiner para depurar.

Resposta ao comando

root@xxxxxxxxxxxx:/app#

3. Confira o diretório:

ls

Resposta ao comando

Dockerfile app.js

4. Saia da sessão de Bash:

exit

5. Use "Docker inspect" para examinar os metadados de um contêiner no Docker:

docker inspect [container_id]

Resposta ao comando

[ { "Id": "xxxxxxxxxxxx....", "Created": "2017-08-07T22:57:49.261726726Z", "Path": "node", "Args": [ "app.js" ], ...

6. Use --format para inspecionar campos específicos do JSON retornado. Exemplo:

docker inspect --format='{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' [container_id]

Exemplo de saída

192.168.9.3

Confira mais informações sobre depuração nos recursos a seguir da documentação do Docker:

• Referência de "Docker inspect" (em inglês)
• Referência de "Docker exec" (em inglês)

Tarefa 5: Publicação

Agora você vai enviar a imagem para o Google Artifact Registry. Depois disso, será preciso remover todos os contêineres e imagens para simular um ambiente novo. Após isso, extraia e execute os contêineres. Essa tarefa vai demonstrar a portabilidade dos contêineres do Docker.

Para enviar imagens para o registro privado hospedado pelo Artifact Registry, marque as imagens com um nome de registro. O formato é <regional-repository>-docker.pkg.dev/my-project/my-repo/my-image.

Criar o repositório de destino do Docker (usando o console do Cloud)

É necessário criar um repositório antes de enviar imagens para ele. O envio de uma imagem não aciona a criação de um repositório e a conta de serviço do Cloud Build não tem permissões para criar repositórios.

1. No Menu de navegação, em "CI/CD", acesse o Artifact Registry > Repositórios.

2. Clique no ícone +CRIAR REPOSITÓRIO ao lado dos repositórios.

3. Especifique o nome do repositório como my-repository.

4. Escolha Docker como o formato.

5. Em "Tipo de local", selecione Região e escolha o seguinte local: .

6. Clique em Criar.

Configurar a autenticação

Antes de enviar ou extrair imagens, configure o Docker para usar a CLI do Google Cloud e autenticar solicitações ao Artifact Registry.

1. Para configurar a autenticação nos repositórios do Docker na região , execute o seguinte comando no Cloud Shell:

gcloud auth configure-docker {{{ project_0.default_region | "REGION" }}}-docker.pkg.dev

2. Insira Y quando solicitado.

O comando atualiza a configuração do Docker. Agora é possível se conectar ao Artifact Registry no projeto do Google Cloud para enviar e extrair imagens.

Observação: como alternativa, use a CLI gcloud para simplificar a abordagem da linha de comando.

Criar um repositório do Artifact Registry (usando a CLI)

1. Execute estes comandos para criar um repositório de artefatos.

gcloud artifacts repositories create my-repository --repository-format=docker --location={{{ project_0.default_region | "REGION" }}} --description="Docker repository" Observação: quando você faz uma chamada de API do Google Cloud ou usa uma ferramenta de linha de comando que exige credenciais (como a CLI gcloud, o bq ou o gsutil) com o Cloud Shell pela primeira vez, ele mostra a caixa de diálogo Autorizar o Cloud Shell. Para permitir que a ferramenta use suas credenciais para fazer chamadas, clique em Autorizar.

Envie o contêiner para o Artifact Registry

1. Mude para o diretório com seu Dockerfile.

cd ~/test

2. Execute o comando para marcar node-app:0.2.

docker build -t {{{ project_0.default_region | "REGION" }}}-docker.pkg.dev/{{{ project_0.project_id | "PROJECT_ID" }}}/my-repository/node-app:0.2 .

3. Execute o comando a seguir para verificar as imagens do Docker.

docker images

Resposta ao comando

REPOSITORY TAG IMAGE ID CREATED node-app 0.2 76b3beef845e 22 hours {{{project_0.default_region | "REGION"}}}-....node-app:0.2 0.2 76b3beef845e 22 hours node-app 0.1 f166cd2a9f10 26 hours node lts 5a767079e3df 7 days hello-world latest 1815c82652c0 7 weeks

4. Envie esta imagem para o Artifact Registry.

docker push {{{ project_0.default_region | "REGION" }}}-docker.pkg.dev/{{{ project_0.project_id | "PROJECT_ID" }}}/my-repository/node-app:0.2

Resposta ao comando (sujeita à variação):

O envio se refere a um repositório [{{{project_0.default_region | "REGION"}}}-docker.pkg.dev/{{{project_0.project_id | "PROJECT_ID"}}}/my-repository/node-app:0.2] 057029400a4a: Pushed 342f14cb7e2b: Pushed 903087566d45: Pushed 99dac0782a63: Pushed e6695624484e: Pushed da59b99bbd3b: Pushed 5616a6292c16: Pushed f3ed6cb59ab0: Pushed 654f45ecb7e3: Pushed 2c40c66f7667: Pushed 0.2: digest: sha256:25b8ebd7820515609517ec38dbca9086e1abef3750c0d2aff7f341407c743c46 size: 2419

5. Quando o envio terminar, em CI/CD no menu de navegação, acesse Artifact Registry > Repositórios.

6. Clique em my-repository. Você verá o contêiner node-app do Docker:

Teste a imagem

Você pode se conectar a uma máquina virtual usando SSH, iniciar uma nova VM e instalar a gcloud. Para simplificar, remova todos os contêineres e imagens para simular um ambiente novo.

1. Interrompa e remova todos os contêineres:

docker stop $(docker ps -q) docker rm $(docker ps -aq)

Remova as imagens secundárias do node:lts antes de remover a imagem do nó.

2. Execute o comando a seguir para remover todas as imagens do Docker.

docker rmi {{{ project_0.default_region | "REGION" }}}-docker.pkg.dev/{{{ project_0.project_id| "PROJECT_ID" }}}/my-repository/node-app:0.2 docker rmi node:lts docker rmi -f $(docker images -aq) # remover as imagens restantes docker images

Resposta ao comando

REPOSITORY TAG IMAGE ID CREATED SIZE

Neste ponto, você tem um ambiente praticamente novo.

3. Extraia e execute a imagem:

docker run -p 4000:80 -d {{{ project_0.default_region | "REGION" }}}-docker.pkg.dev/{{{ project_0.project_id| "PROJECT_ID" }}}/my-repository/node-app:0.2

4. Use um cURL no contêiner em execução.

curl http://localhost:4000

Resposta ao comando

Welcome to Cloud

Teste a tarefa concluída

Clique em Verificar meu progresso para conferir a tarefa realizada. Se você publicou uma imagem de contêiner no Artifact Registry com êxito, vai receber uma pontuação de avaliação.

Publique sua imagem de contêiner no Artifact Registry

A portabilidade dos contêineres é apresentada nesta etapa. Enquanto o Docker estiver instalado no host (seja no local ou na VM), ele poderá extrair imagens de registros públicos ou privados e executar contêineres baseados nelas. Nenhuma dependência de aplicativo precisa ser instalada no host, com exceção do Docker.

Parabéns!

Parabéns! Neste laboratório, você realizou diversas atividades práticas, incluindo a execução de contêineres com base em imagens públicas do Docker Hub. Você também criou suas próprias imagens de contêiner e as enviou para o Google Artifact Registry. Além disso, agora você tem as habilidades necessárias para depurar contêineres em execução de maneira eficaz e ainda ganhou experiência na execução de contêineres com base em imagens extraídas do Google Artifact Registry, aprimorando seu conhecimento e proficiência no Docker.

Próximas etapas/Saiba mais

• Referência do Dockerfile (em inglês)
• Docker Hub (em inglês)
• Saiba mais sobre o Docker com a documentação oficial (em inglês)
• Documentação do Artifact Registry

Treinamento e certificação do Google Cloud

Esses treinamentos ajudam você a aproveitar as tecnologias do Google Cloud ao máximo. Nossas aulas incluem habilidades técnicas e práticas recomendadas para ajudar você a alcançar rapidamente o nível esperado e continuar sua jornada de aprendizado. Oferecemos treinamentos que vão do nível básico ao avançado, com opções de aulas virtuais, sob demanda e por meio de transmissões ao vivo para que você possa encaixá-las na correria do seu dia a dia. As certificações validam sua experiência e comprovam suas habilidades com as tecnologias do Google Cloud.

Manual atualizado em 29 de fevereiro de 2024

Laboratório testado em 29 de fevereiro de 2024

Copyright 2024 Google LLC. Todos os direitos reservados. Google e o logotipo do Google são marcas registradas da Google LLC. Todos os outros nomes de produtos e empresas podem ser marcas registradas das respectivas empresas a que estão associados.