Informações gerais

O Docker é uma plataforma aberta para desenvolvimento, envio e execução de aplicativos em contêineres. Ele oferece mais agilidade no teste e na implantação do código, e um ciclo mais curto entre as fases de desenvolvimento e execução dele. Para isso, o Docker reúne recursos de conteinerização do kernel e fluxos de trabalho, além de ferramentas para o gerenciamento e a implantação dos seus aplicativos.

Com o Docker, é possível expressar o processo de build do aplicativo usando um script chamado Dockerfile, que oferece uma abordagem de baixo nível e flexibilidade ao custo de complexidade. O Dockerfile é um manifesto que detalha como transformar seu código-fonte em uma imagem de contêiner.

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

Objetivos

Neste laboratório, você vai aprender a:

• Criar, executar e depurar contêineres do Docker
• Enviar imagens Docker para o Artifact Registry, o repositório de imagens de contêiner do Google Cloud
• Extrair imagens Docker do Artifact Registry

Configuração

Para cada laboratório, você recebe um novo projeto do Google Cloud e um conjunto de recursos por um determinado período e sem custos financeiros.

1. Faça login no Qwiklabs em uma janela anônima.

2. Confira o tempo de acesso do laboratório (por exemplo, 1:15:00) e finalize todas as atividades nesse prazo.
   Não é possível pausar o laboratório. Você pode reiniciar o desafio, mas vai precisar refazer todas as etapas.

3. Quando tudo estiver pronto, clique em Começar o laboratório.

4. Anote as credenciais (Nome de usuário e Senha). É com elas que você vai fazer login no Console do Google Cloud.

5. Clique em Abrir Console do Google.

6. Clique em Usar outra conta, depois copie e cole as credenciais deste laboratório nos locais indicados.
   Se você usar outras credenciais, vai receber mensagens de erro ou cobranças.

7. Aceite os termos e pule a página de recursos de recuperação.

Ative o Google Cloud Shell

O Google Cloud Shell é uma máquina virtual com 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. No console do Cloud, clique no botão "Abrir o Cloud Shell" na barra de ferramentas superior direita.

   

2. Clique em Continuar.

O provisionamento e a conexão do ambiente podem demorar um pouco. Quando você estiver conectado, já estará autenticado, e o projeto estará definido com seu PROJECT_ID. Exemplo:

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

• Para listar o nome da conta ativa, use este comando:

Saída:

Exemplo de saída:

• Para listar o ID do projeto, use este comando:

Saída:

Exemplo de saída:

Tarefa 1: configurar o ambiente

Você vai executar os comandos do shell neste laboratório em uma VM separada, que foi pré-provisionada para o laboratório.

1. No Cloud Shell, execute o comando a seguir para iniciar uma sessão SSH na VM:

   gcloud compute ssh lab-vm --zone={{{project_0.default_zone| Zone}}}

2. Quando for solicitado, digite Y para continuar.

3. Para a senha, pressione Enter para não usar nenhuma.

4. Pressione Enter novamente.

5. Conceda permissões ao usuário estudante no soquete usado pelo Docker:

   sudo chmod 666 /var/run/docker.sock

6. Para definir as variáveis de ambiente da região e do ID do projeto, execute os seguintes comandos:

   PROJECT_ID={{{project_0.project_id| Project}}} REGION={{{project_0.default_region| Region}}} Você vai precisar executar todos os comandos do laboratório, nas tarefas a seguir, na sessão SSH no Cloud Shell.

Tarefa 2: criar uma imagem de contêiner

Nesta tarefa, você vai criar uma imagem de contêiner do Docker usando um Dockerfile.

Criar um DockerFile

1. Crie um diretório de teste e mude para ele:

   mkdir test && cd test

2. Crie o Dockerfile.

   cat > Dockerfile <<EOF # Use an official Node runtime as the parent image FROM node:lts # Set the working directory in the container to /app WORKDIR /app # Copy the current directory contents into the container at /app COPY . /app # Make the container's port 80 available to the outside world EXPOSE 80 # Run app.js using node when the container launches CMD ["node", "app.js"] EOF Observação: nesta etapa, você vai montar a imagem de contêiner selecionando primeiro uma imagem mãe ou de base.

   Isso é especificado com a instrução FROM e a imagem Docker oficial para a versão do Node (suporte de longo prazo).

   A instrução WORKDIR define o diretório de trabalho no contêiner para quaisquer outras instruções que sigam no Dockerfile. Neste laboratório, usamos o /app como o diretório de trabalho do contêiner.

   A instrução COPY copia diretórios ou arquivos do local de origem para o caminho de destino do sistema de arquivos da imagem de contêiner. Aqui, copiamos arquivos do diretório atual para /app.

   A instrução EXPOSE expõe a porta do contêiner para a aceitação de conexões. Neste laboratório, usaremos a porta 80.

   Por fim, a instrução CMD fornece o comando do nó para executar o aplicativo no contêiner em execução.

Desenvolver o aplicativo

Agora, você vai escrever o código do seu aplicativo Node.js. Esse aplicativo é um servidor HTTP simples que detecta solicitações na porta 80 e responde com uma mensagem estática.

1. Crie o arquivo app.js com o código-fonte do aplicativo:

   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('Welcome to your first Docker container!\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 Observação: o aplicativo também implementa a função de tratamento SIGINT para registrar a mensagem e sair normalmente quando o contêiner é interrompido.

2. Verifique o conteúdo do arquivo de origem do aplicativo:

   cat app.js

Criar a imagem de contêiner

Nesta subtarefa, você vai criar a imagem de contêiner a partir do Dockerfile usando o comando docker build.

1. Execute o comando docker build:

   docker build -t my-app:0.1 .

   Confira abaixo a resposta parcial ao comando:

   => [internal] load dockerignore => => transferring context: 2B => [internal] load build definition from Dockerfile => => transferring dockerfile: 394B => [internal] load metadata for docker.io/library/node:lts => [1/3] FROM docker.io/library/node:lts@sha256:586cdef48f920dea2f47a954b8717601933aa1daa0a08264abf9144789abf8ae => => resolve docker.io/library/node:lts@sha256:586cdef48f920dea2f47a954b8717601933aa1daa0a08264abf9144789abf8ae => => sha256:b7483c70b94e9fbb68e91d64456ee147d120488f876d69efeae815ba164e8b54 2.21kB / 2.21kB ... ... => [internal] load build context => => transferring context: 912B => [2/3] WORKDIR /app => [3/3] COPY . /app => exporting to image => => exporting layers => => writing image sha256:8cf51a1aba351cf505cd6d8eefa966b => => naming to docker.io/library/my-app:0.1 Observação: este comando cria a imagem de contêiner, com base nas instruções do Dockerfile, no diretório atual. Depois, coloca uma tag na imagem resultante com o nome e a versão especificados. O Google recomenda especificar a tag para distinguir as versões mais recentes das mais antigas.

2. Confira a lista de imagens criadas:

   docker images REPOSITORY TAG IMAGE ID CREATED SIZE my-app 0.1 8cf51a1aba35 10 minutes ago 997MB Observação: o comando lista a imagem de base node e a imagem my-app que você criou. O tamanho da imagem é relativamente pequeno, em comparação com outras de máquina virtual.

   Para verificar o objetivo, clique em Verificar meu progresso. Criar uma imagem de contêiner

Tarefa 3: executar e testar o aplicativo

Depois de criar a imagem de contêiner, execute e teste o aplicativo para garantir o comportamento esperado.

Executar o contêiner

1. Para executar o contêiner, use o comando:

   docker run -p 8080:80 --name my-app -d my-app:0.1 Observação: o comando docker run inicia o contêiner com o nome especificado. O argumento -p mapeia a porta 8080 do host para a porta 80 do contêiner. Assim, as solicitações alcançam o servidor em http://localhost:8080. O argumento -d executa o contêiner em segundo plano.

2. Para ver a lista de contêineres em execução, use o comando a seguir:

   docker ps CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES 46c209a1fd87 my-app:0.1 "docker-entrypoint.s…" 19 seconds ago Up 17 seconds 0.0.0.0:8080->80/tcp my-app

Testar o aplicativo

1. Para testar o aplicativo, envie uma solicitação HTTP usando o comando curl:

   curl http://localhost:8080

2. Verifique a resposta do aplicativo:

   Este é seu primeiro contêiner do Docker!

3. Para interromper o contêiner, execute o comando docker stop:

   docker stop [CONTAINER ID]

   Substitua [CONTAINER ID] pelo valor do ID do contêiner da resposta ao comando executado na subtarefa anterior.

Tarefa 4: modificar o contêiner

É possível ter várias versões dos seus aplicativos conteinerizados que compartilham camadas comuns na imagem. Nesta tarefa, você vai criar outra versão do aplicativo conteinerizado e testar as duas versões.

Modificar o código do aplicativo

1. No diretório test, atualize o conteúdo do arquivo app.js:

   cat > app.js <<EOF const http = require('http'); const url = require('url'); const hostname = '0.0.0.0'; const port = 80; const server = http.createServer((req, res) => { res.statusCode = 200; res.setHeader('Content-Type', 'text/plain'); console.log('Received request with URL: ?%s', req.url); var q = url.parse(req.url, true).query; res.end(q.user + ', Welcome to your first Docker container!\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 Observação: o código do aplicativo modificado adiciona o valor de um parâmetro de consulta user, que é transmitido na solicitação HTTP na resposta do aplicativo.

2. Verifique o conteúdo do arquivo de origem do aplicativo modificado com o comando cat:

   cat app.js

Recriar a imagem do contêiner.

1. Recrie a imagem com uma nova tag:

   docker build -t my-app:0.2 .

2. Verifique a resposta ao comando docker build:

   => [internal] load build definition from Dockerfile => => transferring dockerfile: 394B => [internal] load .dockerignore => => transferring context: 2B => [internal] load metadata for docker.io/library/node:lts => [1/3] FROM docker.io/library/node:lts@sha256:586cdef48f920dea2f47a954b8717601933aa1daa0a08264abf9144789abf8ae => [internal] load build context => => transferring context: 691B => CACHED [2/3] WORKDIR /app => [3/3] COPY . /app => exporting to image => => exporting layers => => writing image sha256:5fc2d7a43c4678da17daf204ef4b071f2da869ead758864622d90d880a40c24b => => naming to docker.io/library/my-app:0.2

   Você verá que, na nova imagem de contêiner, apenas as camadas da etapa 3 e abaixo foram modificadas, porque houve alterações no arquivo de origem app.js.

Executar o novo contêiner

1. Para executar o novo contêiner, use o comando:

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

2. Para ver a lista de contêineres em execução, use o comando a seguir:

   docker ps CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES 7071749fe0f6 my-app:0.2 "docker-entrypoint.s…" 10 seconds ago Up 10 seconds 0.0.0.0:8081->80/tcp my-app-2

Testar o aplicativo

1. Para testar o aplicativo, envie uma solicitação HTTP usando o comando curl:

   curl http://localhost:8080?user=Learner

2. Verifique a resposta do aplicativo:

   Olá, estudante! Este é seu primeiro contêiner do Docker. Observação: a resposta contém o valor do argumento user que foi transmitido na solicitação enviada ao contêiner que está executando a versão 0.2 da imagem do aplicativo.

   Clique em Verificar meu progresso para conferir o objetivo. Modificar o contêiner e recriar a imagem do contêiner

Tarefa 5: solucionar problemas

Existem algumas técnicas simples para solucionar problemas nos seus aplicativos conteinerizados. Nesta tarefa, vamos analisar alguns desses métodos.

Ver registros de contêineres

1. Primeiro, recupere o ID do contêiner cujos registros você precisa visualizar:

   docker ps

2. Para visualizar os registros do contêiner, execute o comando docker logs:

   docker logs [CONTAINER ID]

   Substitua o CONTAINER ID pelos caracteres iniciais do ID do contêiner que o identifica de forma exclusiva na resposta ao comando anterior. Para acompanhar a saída do registro com o contêiner em execução, use a opção -f com o comando logs.

   Server running at http://0.0.0.0:80/ Received request with URL: ?/?user=Learner

Iniciar um shell no contêiner

Você pode iniciar um shell interativo em um contêiner em execução para solucionar problemas.

1. Para iniciar uma sessão interativa do Bash, execute:

   docker exec -it [CONTAINER ID] bash root@7071749fe0f6:/app#

2. Para solucionar problemas nesse shell, você pode inspecionar o sistema de arquivos do contêiner e outros arquivos de dados usados pelo aplicativo.

   ls

3. Saia do shell Bash:

   exit

Examinar os metadados do contêiner

1. Para visualizar os metadados de um contêiner, execute:

   docker inspect [CONTAINER ID]

   Confira a resposta parcial ao comando:

   [ { "Id": "7071749fe0f66b8b1953bbb6f28f159bd5dbeae079595675e2591d32d87ae5dc", "Created": "2023-02-23T18:08:34.286519913Z", "Path": "docker-entrypoint.sh", "Args": [ "node", "app.js" ], "State": { "Status": "running", "Running": true, "Paused": false, "Restarting": false, "OOMKilled": false, "Dead": false, "Pid": 1099, "ExitCode": 0, "Error": "", "StartedAt": "2023-02-23T18:08:34.785098365Z", "FinishedAt": "0001-01-01T00:00:00Z" }, "Image": "sha256:5fc2d7a43c4678da17daf204ef4b071f2da869ead758864622d90d880a40c24b", "ResolvConfPath": "/var/lib/docker/containers/7071749fe0f66b8b1953bbb6f28f159bd5dbeae079595675e2591d32d87ae5dc/resolv.conf", "HostnamePath": "/var/lib/docker/containers/ ... ... } ] Observação: por padrão, o comando inspect fornece informações detalhadas de metadados em uma matriz JSON. Você pode filtrar os resultados com o argumento --format para inspecionar campos específicos na saída.

Tarefa 6: publicar uma imagem de contêiner

O Artifact Registry é o serviço do Google Cloud usado para armazenar e controlar artefatos de software em repositórios particulares, incluindo imagens de contêiner e pacotes de software.

Nesta tarefa, você vai enviar as imagens de contêiner para o Artifact Registry. Com isso, elas vão ficar disponíveis para implantação em outros ambientes, como o de testes ou de produção, que compõem o ciclo de vida de entrega de software.

Criar um repositório de imagens

Antes de enviar imagens de contêiner para o Artifact Registry, você precisa criar um repositório.

1. No console do Google Cloud, acesse o Menu de navegação () e clique em Ver todos os produtos. Em seguida, nas categorias CI/CD, acesse Artifact Registry > Repositórios.

2. Na página Criar repositório, forneça as informações a seguir e mantenha as outras configurações padrão:

   Propriedade	Valor (digite ou selecione)
   Nome	my-repo
   Formato	Docker
   Tipo de local	Região
   Região

3. Clique em Criar.

Autenticar o Docker para usar o repositório

Antes de enviar ou extrair imagens do repositório, é necessário configurar o Docker para autenticar as solicitações ao repositório no Artifact Registry.

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

   gcloud auth configure-docker ${REGION}-docker.pkg.dev

2. Quando solicitado, digite Y.

   O nome completo do repositório que você criou é: -docker.pkg.dev//my-repo.

   Os nomes dos repositórios de imagem Docker usam o formato: [location]-docker.pkg.dev no Artifact Registry.

Enviar o contêiner para o Artifact Registry

1. Para enviar uma imagem de contêiner para o registro privado hospedado pelo Artifact Registry, primeiro marque a imagem com o nome do repositório:

   docker build -t ${REGION}-docker.pkg.dev/${PROJECT_ID}/my-repo/my-app:0.2 .

2. Liste as imagens Docker que você criou:

   docker images REPOSITORY TAG IMAGE ID CREATED SIZE my-app 0.2 9b1ef4854d32 4 minutes ago 997MB us-east1-docker.pkg.dev/qwiklabs-gcp-02-7c092125ce3a/my-repo/my-app 0.2 9b1ef4854d32 4 minutes ago 997MB my-app 0.1 8cf51a1aba35 5 minutes ago 997MB

3. Para enviar a imagem ao Artifact Registry, execute o seguinte comando:

   docker push ${REGION}-docker.pkg.dev/$PROJECT_ID/my-repo/my-app:0.2

   A resposta a este comando vai ser parecida com a seguinte:

   O push se refere ao repositório [east1-docker.pkg.dev/qwiklabs-gcp-02-7c092125ce3a/my-repo/my-app] b29bce04ddbb: Pushed 9ba0e19073ee: Pushed 3c397285cb7e: Pushed a8d01c684adc: Pushed 56c4ec92f013: Pushed 4c92897e605e: Pushed 0b6859e9fff1: Pushed 11829b3be9c0: Pushed dc8e1d8b53e9: Pushed 9d49e0bc68a4: Pushed 8e396a1aad50: Pushed 0.2: digest: sha256:383ffb5213f92e33dedb49042c0f070a9f76f263621226de20499dffd863b3df size: 2628

4. Depois que o comando for concluído, no Menu de navegação () do console do Google Cloud, clique em Ver todos os produtos. Em seguida, nas categorias CI/CD, acesse Artifact Registry > Repositórios.

5. Clique no repositório my-repo para mostrar a imagem do contêiner do Docker my-app.

Clique em Verificar meu progresso para conferir o objetivo. Publicar uma imagem de contêiner

Tarefa 7: extrair e testar a imagem de contêiner

Você vai começar esta tarefa com um novo ambiente. Depois, vai extrair a imagem de contêiner do Artifact Registry para testá-la. Para simular outro ambiente, você vai interromper e remover todos os contêineres e imagens do ambiente shell, que foram criados nas tarefas anteriores deste laboratório.

Interromper e remover contêineres

1. Para interromper todos os contêineres em execução, use o seguinte comando:

   docker stop $(docker ps -q)

2. Para remover todos os contêineres, execute o seguinte comando:

   docker rm $(docker ps -aq)

Remover todas as imagens de contêiner

1. Para remover uma imagem de contêiner com tag de registro, execute o seguinte comando:

   docker rmi ${REGION}-docker.pkg.dev/$PROJECT_ID/my-repo/my-app:0.2 Observação: esse comando não remove a imagem de contêiner do registro.

2. Para remover todas as outras imagens, execute o seguinte comando:

   docker rmi -f $(docker images -aq)

3. Verifique se não há imagens de contêiner no seu ambiente de VM:

   docker images REPOSITORY TAG IMAGE ID CREATED SIZE

   Agora você tem um ambiente de host novo, sem imagens locais.

Testar a imagem

Para fazer o teste, primeiro extraia a imagem do Artifact Registry.

1. Para extrair a imagem do Artifact Registry, execute o seguinte comando:

   docker pull ${REGION}-docker.pkg.dev/${PROJECT_ID}/my-repo/my-app:0.2

2. Para listar as imagens, execute o comando a seguir:

   docker images

3. Para executar o contêiner, use o seguinte comando:

   docker run -p 8080:80 -d ${REGION}-docker.pkg.dev/${PROJECT_ID}/my-repo/my-app:0.2

4. Para testar o aplicativo, execute:

   curl http://localhost:8080?user=Learner Observação: esta tarefa demonstra a portabilidade de contêineres, em que é possível executar aplicativos conteinerizados em outras VMs ou ambientes com o Docker, sem precisar instalar dependências de aplicativos na máquina host. As imagens de contêiner podem ser hospedadas em registros públicos ou privados que podem ser acessados pelo Docker.

Parabéns!

Você concluiu o laboratório sobre os fundamentos da criação de contêineres com o Docker. Neste laboratório, você:

• Criou imagens de contêiner com o Docker e executou contêineres do Docker.
• Enviou imagens do Docker para o Artifact Registry, o repositório de imagens de contêiner do Google Cloud.
• Extraiu imagens Docker do Artifact Registry e executou essas imagens em um novo ambiente para verificar a portabilidade do contêiner.

Próximas etapas / Saiba mais

Para mais informações sobre o Docker e o Artifact Registry, consulte a documentação a seguir:

• Documentação do Docker
• Referência de comandos do Docker (em inglês)
• Artifact Registry

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