Como Configurar e Executar Contêineres Docker de Forma Eficiente

Introdução

Este tutorial abrangente sobre Docker oferece a desenvolvedores e profissionais de TI um mergulho profundo na tecnologia de contêineres. Desde a compreensão dos conceitos centrais do Docker até técnicas práticas de instalação e gerenciamento, o guia abrange tudo o que é necessário para aproveitar as poderosas capacidades de conteinerização do Docker para o desenvolvimento e implantação de software modernos.

Fundamentos do Docker

Introdução à Tecnologia de Contêineres

Docker é uma plataforma poderosa para tecnologia de contêineres, permitindo que desenvolvedores empacotem, distribuam e executem aplicações de forma eficiente. Contêineres fornecem ambientes leves e portáteis que encapsulam software e suas dependências.

Conceitos Centrais do Docker

graph TD
    A[Docker Engine] --> B[Container]
    A --> C[Image]
    A --> D[Dockerfile]

Conceito	Descrição
Docker Image	Template somente leitura contendo código da aplicação e dependências
Container	Instância executável de uma Docker image
Docker Engine	Ambiente de tempo de execução para criar e gerenciar contêineres

Verificando a Instalação do Docker

Seu ambiente LabEx vem com o Docker pré-instalado. Vamos verificar a versão do Docker para garantir que ele esteja pronto para uso.

docker --version

A saída deve exibir a versão do Docker, por exemplo, Docker version 20.10.21, build baeda1f. Isso confirma que o Docker está instalado corretamente e acessível.

Baixando Sua Primeira Docker Image

Uma Docker image é um template somente leitura que contém um conjunto de instruções para criar um contêiner. Vamos baixar a imagem hello-world, que é uma imagem mínima usada para testar instalações do Docker.

docker pull hello-world

Este comando baixa a imagem hello-world do Docker Hub para sua máquina local. Você deverá ver uma saída indicando o progresso do download e a confirmação de que a imagem foi baixada.

Executando Seu Primeiro Docker Container

Agora que temos uma imagem, vamos executar um contêiner a partir dela. Executar um contêiner significa criar uma instância da imagem.

docker run hello-world

Ao executar hello-world, o Docker realiza as seguintes ações:

Verifica se a imagem hello-world existe localmente. Se não existir, ele a baixa (o que já fizemos).
Cria um novo contêiner a partir da imagem.
Executa o executável dentro do contêiner.
O contêiner imprime uma mensagem "Hello from Docker!" e, em seguida, sai.

Isso demonstra o ciclo de vida básico de um Docker container: baixar uma imagem, executar um contêiner, e o contêiner executa sua tarefa definida.

Listando Docker Images

Para ver as imagens que você baixou, use o comando docker images.

docker images

Este comando lista todas as Docker images armazenadas em seu sistema local, incluindo a imagem hello-world que acabamos de baixar. Você verá detalhes como o repositório, tag, ID da imagem, data de criação e tamanho.

Compreendendo o Ciclo de Vida do Contêiner

Contêineres fornecem ambientes isolados com seus próprios sistemas de arquivos, processos e interfaces de rede. Eles podem ser iniciados, parados, movidos e excluídos rapidamente, tornando-os ideais para microsserviços e aplicações nativas da nuvem.

Gerenciamento de Arquivos Dockerfile

Noções Básicas de Dockerfile

Um Dockerfile é um documento de texto que contém todos os comandos que um usuário pode chamar na linha de comando para montar uma imagem. Ele define o ambiente, as dependências e a configuração para aplicações conteinerizadas.

graph TD
    A[Dockerfile] --> B[Comando de Build]
    B --> C[Docker Image]
    C --> D[Container]

Criando Seu Primeiro Dockerfile

Navegue até o diretório docker_app, que foi criado durante a fase de configuração. Este será nosso diretório de trabalho para este laboratório.

cd /home/labex/project/docker_app

Agora, vamos criar um Dockerfile simples chamado Dockerfile neste diretório. Este Dockerfile criará uma imagem baseada no Ubuntu e adicionará um arquivo de texto simples a ela.

nano Dockerfile

Adicione o seguinte conteúdo ao Dockerfile:

## Use uma imagem base oficial do Ubuntu
FROM ubuntu:22.04

## Define o diretório de trabalho dentro do contêiner
WORKDIR /app

## Cria um arquivo de texto simples
RUN echo "Hello from Dockerfile!" > /app/message.txt

## Comando a ser executado quando o contêiner iniciar
CMD ["cat", "/app/message.txt"]

FROM ubuntu:22.04: Esta instrução especifica a imagem base para nossa nova imagem. Estamos usando o Ubuntu 22.04.
WORKDIR /app: Isso define o diretório de trabalho para quaisquer instruções RUN, CMD, ENTRYPOINT, COPY ou ADD que a sigam no Dockerfile. Se /app não existir, ele será criado.
RUN echo "Hello from Dockerfile!" > /app/message.txt: Esta instrução executa um comando dentro da imagem durante o processo de build. Aqui, ela cria um arquivo chamado message.txt no diretório /app com o conteúdo "Hello from Dockerfile!".
CMD ["cat", "/app/message.txt"]: Esta instrução fornece comandos padrão para um contêiner em execução. Quando um contêiner é executado a partir desta imagem, ele executará cat /app/message.txt, exibindo o conteúdo do nosso arquivo de mensagem.

Salve o arquivo pressionando Ctrl+S e saia do nano pressionando Ctrl+X.

Construindo Sua Docker Image

Agora que temos nosso Dockerfile, vamos construir a Docker image a partir dele. O comando docker build lê o Dockerfile e cria uma Docker image.

docker build -t my-ubuntu-app .

docker build: O comando para construir uma Docker image.
-t my-ubuntu-app: Isso marca nossa imagem com o nome my-ubuntu-app. Você pode escolher qualquer nome que desejar.
.: Isso especifica o contexto de build, que é o conjunto de arquivos no PATH ou URL especificado. O . indica que o diretório atual (/home/labex/project/docker_app) é o contexto de build. O Docker procurará por um Dockerfile neste diretório.

Você verá a saída mostrando cada etapa do processo de build, correspondendo às instruções em seu Dockerfile.

Executando Seu Docker Container Personalizado

Após construir a imagem com sucesso, vamos executar um contêiner a partir dela para ver o conteúdo de message.txt.

docker run my-ubuntu-app

Este comando criará e executará um novo contêiner a partir da sua imagem my-ubuntu-app. A instrução CMD em seu Dockerfile será executada, e você deverá ver "Hello from Dockerfile!" impresso em seu terminal.

Inspecionando o Sistema de Arquivos do Contêiner

Para entender melhor como os arquivos são gerenciados dentro de um contêiner, vamos executar uma sessão interativa e inspecionar o arquivo que criamos.

docker run -it my-ubuntu-app /bin/bash

-it: Esta flag aloca um pseudo-TTY e mantém o STDIN aberto, permitindo que você interaja com o contêiner.
my-ubuntu-app: O nome da imagem que queremos executar.
/bin/bash: Isso substitui a instrução CMD no Dockerfile e, em vez disso, executa um shell Bash dentro do contêiner, fornecendo um prompt de comando.

Uma vez dentro do contêiner, você verá um novo prompt de comando (por exemplo, root@<container_id>:/app#). Agora, você pode listar os arquivos e visualizar o conteúdo de message.txt.

ls -l
cat message.txt

Você deverá ver message.txt listado e seu conteúdo exibido. Para sair do contêiner, basta digitar exit.

exit

Esta sessão interativa demonstra que o arquivo message.txt foi criado com sucesso e é acessível dentro do sistema de arquivos do contêiner.

Técnicas Avançadas de Docker

Estratégias de Build Multi-Stage

Builds multi-stage são um recurso poderoso que permite usar múltiplas instruções FROM em seu Dockerfile. Cada instrução FROM pode usar uma imagem base diferente, e cada instrução FROM inicia um novo estágio de build. Isso ajuda a otimizar a complexidade do Dockerfile e a reduzir o tamanho da imagem final, separando os ambientes de build e de runtime.

graph TD
    A[Estágio de Build] --> B[Compilar/Build]
    B --> C[Estágio de Runtime]
    C --> D[Imagem Mínima de Produção]

Preparando para um Build Multi-Stage

Para este exemplo, simularemos uma aplicação simples que requer uma etapa de build. Criaremos um arquivo build_script.sh e um arquivo final_app.txt.

Primeiro, certifique-se de estar no diretório docker_app:

cd /home/labex/project/docker_app

Agora, crie um script de build simples:

nano build_script.sh

Adicione o seguinte conteúdo ao build_script.sh:

#!/bin/bash
echo "Executando processo de build..."
echo "Esta é a saída final da aplicação." > /app/output/final_app.txt
echo "Build concluído."

Salve o arquivo (Ctrl+S) e saia (Ctrl+X).

Em seguida, crie um placeholder para o conteúdo final da nossa aplicação. Em um cenário real, isso seria gerado pelo processo de build.

nano final_app.txt

Adicione o seguinte conteúdo ao final_app.txt:

Este é um placeholder para a aplicação final.

Salve o arquivo (Ctrl+S) e saia (Ctrl+X).

Implementando um Dockerfile Multi-Stage

Agora, vamos modificar nosso Dockerfile para usar um build multi-stage. Teremos um estágio "builder" que executa nosso build_script.sh e, em seguida, um estágio "production" que apenas copia a saída necessária do estágio builder.

nano Dockerfile

Substitua o conteúdo existente pelo seguinte:

## Estágio 1: Estágio builder
FROM ubuntu:22.04 AS builder

## Instala bash para executar o script
RUN apt-get update && apt-get install -y bash

## Define o diretório de trabalho para o estágio builder
WORKDIR /build

## Copia o script de build e o torna executável
COPY build_script.sh .
RUN chmod +x build_script.sh

## Cria um diretório para saída
RUN mkdir -p /build/output

## Executa o script de build
RUN ./build_script.sh

## Estágio 2: Estágio de produção
FROM ubuntu:22.04

## Define o diretório de trabalho para o estágio de produção
WORKDIR /app

## Copia apenas o artefato necessário do estágio builder
COPY --from=builder /build/output/final_app.txt .

## Comando a ser executado quando o contêiner iniciar
CMD ["cat", "final_app.txt"]

FROM ubuntu:22.04 AS builder: Isso inicia o primeiro estágio e o nomeia builder.
RUN apt-get update && apt-get install -y bash: Instala bash no estágio builder, que é necessário para executar nosso script.
WORKDIR /build: Define o diretório de trabalho para o estágio builder.
COPY build_script.sh .: Copia nosso script de build para o estágio builder.
RUN chmod +x build_script.sh: Torna o script executável.
RUN mkdir -p /build/output: Cria um diretório de saída no estágio builder.
RUN ./build_script.sh: Executa o script de build, que gera final_app.txt em /build/output.
FROM ubuntu:22.04: Isso inicia o segundo estágio (o estágio de produção). Ele usa uma imagem ubuntu:22.04 nova, o que significa que ele não herda nada do estágio builder por padrão.
WORKDIR /app: Define o diretório de trabalho para o estágio de produção.
COPY --from=builder /build/output/final_app.txt .: Esta é a instrução chave para builds multi-stage. Ela copia final_app.txt do diretório /build/output do estágio builder para o diretório atual (/app) do estágio de produção. Isso garante que apenas o artefato final seja incluído, mantendo a imagem de produção pequena.
CMD ["cat", "final_app.txt"]: O comando a ser executado quando o contêiner de produção iniciar, exibindo o conteúdo do arquivo copiado.

Salve o arquivo (Ctrl+S) e saia (Ctrl+X).

Construindo e Executando a Imagem Multi-Stage

Agora, vamos construir a nova imagem usando nosso Dockerfile multi-stage.

docker build -t multi-stage-app .

Observe a saída do build. Você verá as etapas para o estágio builder e o estágio final.

Após a conclusão do build, execute o contêiner para verificar se o conteúdo de final_app.txt é exibido.

docker run multi-stage-app

Você deverá ver "This is the final application output." impresso, confirmando que o build multi-stage copiou com sucesso o artefato do estágio de build para a imagem final.

Limpeza de Recursos Docker

É uma boa prática limpar recursos Docker (contêineres e imagens) que não são mais necessários para liberar espaço em disco.

Primeiro, liste todos os contêineres (incluindo os que saíram):

docker ps -a

Você pode remover contêineres específicos por seu ID ou nome:

docker rm $(docker ps -aq)

Este comando remove todos os contêineres que saíram. docker ps -aq lista todos os IDs de contêineres, e docker rm os remove.

Em seguida, liste todas as imagens:

docker images

Você pode remover imagens específicas por seu ID ou nome. Tenha cuidado para não remover imagens que ainda estão em uso por contêineres em execução.

docker rmi my-ubuntu-app multi-stage-app hello-world ubuntu:22.04

Este comando remove as imagens que criamos e usamos neste laboratório. Se uma imagem ainda estiver sendo usada por um contêiner, você precisará remover o contêiner primeiro.

docker images

Este comando mostrará que as imagens foram removidas.

Isso conclui o laboratório sobre fundamentos e técnicas avançadas de Docker. Você aprendeu como criar Dockerfiles, construir imagens, executar contêineres e otimizar o tamanho da imagem usando builds multi-stage.

Resumo

Ao dominar os fundamentos do Docker, o gerenciamento de Dockerfile e técnicas avançadas, os desenvolvedores podem criar ambientes de software mais eficientes, portáteis e escaláveis. Este tutorial equipou você com habilidades práticas na criação de contêineres, gerenciamento de imagens e estratégias de implantação, permitindo que você otimize fluxos de trabalho de desenvolvimento e adote arquiteturas de aplicações nativas da nuvem.