Guia de Docker: Começando com o pé direito

1. Introdução: O Caminho para Ambientes Consistentes

Este guia foi seu ponto de partida no universo Docker, desvendando a conteinerização desde a instalação e conceitos fundamentais como imagens, contêineres, volumes e redes, até a orquestração com Docker Compose.

O Docker é uma peça central na engenharia de software moderna. Sua capacidade de empacotar aplicações em unidades isoladas e portáteis revoluciona o desenvolvimento e implantação, garantindo consistência e eliminando o "funciona na minha máquina".

Mas este guia foi apenas o aquecimento. Para dominar a conteinerização e escalar, aprofunde-se em:

• Orquestração Avançada: Explore Docker Swarm e, principalmente, Kubernetes, o padrão da indústria.
• CI/CD com Docker: Integre para automatizar a construção, teste e implantação.
• Docker em Produção: Aprofunde-se em melhores práticas de segurança, monitoramento, logging, escalabilidade e resiliência.

Lembre-se: a prática é onde o verdadeiro aprendizado acontece. Não hesite em experimentar e construir.

Este é apenas o começo da sua aventura Docker. O futuro do desenvolvimento está em contêineres, e você já deu o primeiro passo na direção certa. Vá em frente!

2. O Que é Docker e Por Que Usá-lo?

Bem-vindo ao guia Docker! Essencial para desenvolvedores e entusiastas, ele desmistifica a ferramenta para revolucionar construção e execução de aplicações.

A frustração "na minha máquina funciona!", causada por inconsistências de ambiente, é o que Docker soluciona. Ele encapsula aplicações e suas dependências em contêineres padronizados, garantindo consistência, portabilidade e isolamento. Sua aplicação funcionará identicamente em qualquer lugar.

Este guia prático aborda instalação, imagens, contêineres, volumes, redes e Docker Compose. O foco é a aplicação imediata do conhecimento para ambientes de desenvolvimento e produção eficientes.

3. Instalando o Docker: Preparando o Terreno

Para compreender o impacto do Docker e contêineres, é crucial diferenciá-los de Máquinas Virtuais (VMs).

VMs emulam hardware e rodam um SO completo, sendo pesadas e lentas. Contêineres, por outro lado, compartilham o kernel do host, encapsulando apenas a aplicação e suas dependências. O isolamento é via recursos do kernel Linux como namespaces e cgroups. Isso resulta em desempenho superior, inicialização instantânea e menor consumo de recursos.

O Docker opera via dois pilares: Imagens Docker e Contêineres Docker.

Imagens Docker são "moldes" estáticos e somente leitura (blueprints), contendo a aplicação e suas dependências. Construídas em camadas via Dockerfile, são imutáveis, garantindo ambientes consistentes.

Contêineres Docker são instâncias executáveis de imagens. Cada contêiner é um processo isolado, com ambiente próprio e execução segura e consistente, facilmente gerenciável (iniciar, parar, remover).

Registros de Imagens, como o Docker Hub, facilitam o compartilhamento e a distribuição de imagens.

Os principais benefícios do Docker são:

• Consistência entre Ambientes: Elimina o "funciona na minha máquina", padronizando ambientes.
• Portabilidade: "Construa uma vez, execute em qualquer lugar" em qualquer máquina com Docker.
• Isolamento de Dependências: Aplicações em contêineres próprios evitam conflitos.
• Eficiência no Uso de Recursos: Consome menos que VMs, otimizando hardware e custos.
• Agilidade no Desenvolvimento e Implantação (CI/CD): Inicialização rápida e previsibilidade agilizam o ciclo de CI/CD.

Para experimentar, o próximo passo é rodar o Docker em sua máquina.

4. Primeiros Comandos Essenciais: Mão na Massa

A instalação do Docker é o primeiro passo para trabalhar com contêineres, sendo um processo simplificado e bem documentado.

Requisitos de Sistema: A Base Necessária

Antes de instalar, certifique-se de que seu sistema atende aos requisitos e que a virtualização está habilitada na BIOS/UEFI, essencial para Docker no Windows/macOS.

• Windows: Hyper-V (Pro/Enterprise/Education) ou WSL 2.
• macOS: Versão recente e 4GB RAM.
• Linux: Kernel 3.10+ e suporte a virtualização. O Docker Engine no Linux utiliza recursos nativos do kernel (namespaces, cgroups).

Instalando o Docker no Windows

No Windows, instale via Docker Desktop, que integra todas as ferramentas.

1. Baixe o instalador no site oficial.
2. Execute a instalação; habilite o WSL 2 para melhor desempenho (Hyper-V como alternativa).
3. Siga as instruções pós-instalação e reinicie se solicitado.

Instalando o Docker no macOS

Para macOS, use o Docker Desktop, que aproveita as tecnologias de virtualização nativas.

1. Baixe o instalador (escolha a versão correta para seu chip).
2. Arraste o ícone para "Aplicativos".
3. Abra e conceda as permissões necessárias.

Instalando o Docker no Linux

No Linux, use o repositório oficial do Docker via gerenciador de pacotes para obter as versões mais recentes e seguras.

Para Ubuntu/Debian:

sudo apt update
sudo apt install ca-certificates curl gnupg lsb-release
sudo mkdir -p /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
  $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt update
sudo apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
sudo systemctl start docker
sudo systemctl enable docker

Para Fedora/CentOS (e derivados RHEL):

sudo dnf -y install dnf-plugins-core
sudo dnf config-manager --add-repo https://download.docker.com/linux/fedora/docker-ce.repo
sudo dnf install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
sudo systemctl start docker
sudo systemctl enable docker

Pós-instalação (Linux): Evitando sudo

Para usar o Docker sem sudo no Linux, adicione seu usuário ao grupo docker e reinicie a sessão:

sudo usermod -aG docker $USER

Verificando a Instalação: Confirmação Final

Verifique a instalação:

1. docker --version (Verifica versões)
2. docker run hello-world (Baixa e executa uma imagem de teste, confirmando a instalação).

Com o Docker instalado, você está pronto para gerenciar contêineres e imagens.

5. Criando Sua Primeira Imagem Docker (Dockerfile): Personalização

Dominar os comandos Docker essenciais é o primeiro passo para gerenciar contêineres e imagens.

Vamos aos comandos fundamentais:

• docker run: Inicia um contêiner a partir de uma imagem (baixa se não local).

  • Exemplo:

    docker run alpine echo 'Olá, Docker!'
    

    (Executa um comando simples e encerra o contêiner.)
  • Opções essenciais:
    • -p <host>:<contêiner>: Mapeia portas.
    • -d: Executa em segundo plano (detached mode).
    • --name <nome>: Atribui um nome ao contêiner.
    • --rm: Remove o contêiner automaticamente ao parar.

• docker ps: Lista contêineres em execução.

  • -a: Exibe todos os contêineres (incluindo parados).

• docker images: Lista imagens Docker locais.

• docker pull <imagem>: Baixa uma imagem (ex: docker pull nginx).

• docker stop <contêiner>: Para um contêiner em execução.

• docker start <contêiner>: Inicia um contêiner parado.

• docker restart <contêiner>: Para e reinicia um contêiner.

• docker rm <contêiner>: Remove um contêiner parado.

• docker rmi <imagem>: Remove uma imagem local (se não houver contêineres associados).

• docker logs <contêiner>: Exibe os logs do contêiner. Use -f para seguir em tempo real.

• docker exec <contêiner> <comando>: Executa um comando dentro de um contêiner em execução.

  • Exemplo (shell interativo):

    docker exec -it meu-servidor-web bash
    

Estes comandos são a base. Para criar imagens personalizadas, explore o Dockerfile.

6. Gerenciando Dados com Volumes: Persistência Eficaz

Para criar suas próprias imagens Docker, usa-se o Dockerfile: um arquivo de texto simples que atua como uma "receita". Ele define instruções passo a passo que o Docker Engine executa, construindo a imagem camada por camada, de forma modular e otimizada.

Para construir uma imagem eficiente, entenda as instruções essenciais de um Dockerfile:

• FROM: Define a imagem base (ex: python:3.9-slim). Imagens leves são cruciais.
• RUN: Executa comandos durante o build (instalar pacotes, compilar).
• COPY / ADD: Copiam arquivos do host para a imagem. COPY é preferível.
• WORKDIR: Define o diretório padrão para instruções.
• EXPOSE: Documenta portas que o contêiner escuta (ex: EXPOSE 80). Não publica; use -p com docker run para isso.
• CMD / ENTRYPOINT: Definem o comando padrão ao iniciar. CMD é substituível; ENTRYPOINT anexa argumentos de docker run.

Exemplo Prático: Aplicação Web Simples

Para uma aplicação Python Flask, o Dockerfile seria:

Dockerfile:

FROM python:3.9-slim-buster
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
EXPOSE 5000
CMD ["python", "app.py"]

Construa com docker build.

O Comando docker build

docker build constrói uma imagem a partir de um Dockerfile e do contexto de build (arquivos no diretório, ex: .).

docker build -t minha-app-web:1.0 .

(-t etiqueta a imagem).

Teste a imagem:

docker run -p 5000:5000 minha-app-web:1.0

Acesse http://localhost:5000.

Otimização de Dockerfiles: Boas Práticas

Para imagens eficientes:

• Minimizar Camadas: Agrupe comandos (RUN cmd1 && cmd2) para reduzir camadas e tamanho.
• Cache de Build: Posicione instruções estáveis (dependências) antes das voláteis (código) para acelerar builds.
• .dockerignore: Exclua arquivos desnecessários do contexto de build, otimizando o processo e a imagem.
• Builds Multi-Stage: Separe o ambiente de build do de execução, copiando apenas artefatos finais para uma imagem menor e mais segura.

Contêineres executam aplicações, mas dados são efêmeros. O próximo tópico abordará a persistência de dados via volumes.

7. Redes no Docker: Conectando Contêineres

Contêineres são efêmeros: dados gravados internamente se perdem ao serem removidos. Para aplicações que precisam persistir informações (bancos de dados, logs, configurações), o armazenamento interno não é viável.

Os Volumes do Docker são a solução para persistir dados. Eles desacopplam o armazenamento do ciclo de vida do contêiner, permitindo que os dados sobrevivam à remoção ou recriação e possam ser anexados a novos contêineres.

O Docker oferece dois tipos principais:

• Volumes Nomeados: Gerenciados pelo Docker, são a forma preferencial para dados de aplicações (ex: bancos de dados). Portáteis, fáceis de fazer backup, e com melhor performance em não-Linux. Identificados por um nome.
• Bind Mounts: Mapeiam um diretório do host para o contêiner. Ideais para desenvolvimento (refletir código do host) ou compartilhar arquivos de configuração específicos do host.

Como usar Volumes

Anexe volumes com docker run -v (ou --volume):

• Volumes Nomeados:

  docker run -d -v meu_volume_dados:/caminho/no/container imagem:tag
  

• Bind Mounts:

  docker run -d -v /caminho/do/host:/caminho/no/container imagem:tag
  

• Somente Leitura (:ro): Adicione :ro para permitir apenas leitura, útil para configurações estáticas.

  docker run -d -v /caminho/do/host/config:/etc/config:ro imagem:tag
  

Gerenciando Volumes

Comandos para gerenciar volumes:

• docker volume create <nome_do_volume>
• docker volume ls
• docker volume inspect <nome_do_volume>
• docker volume rm <nome_do_volume> (Apaga os dados!)

Exemplos Práticos

• Banco de Dados: docker run -d -v mysql_data:/var/lib/mysql mysql:latest (persistência).
• Dev: docker run -it --rm -v $(pwd):/app -w /app node:lts npm install (código do host no contêiner).
• Configuração: docker run -d -v /caminho/host/config.conf:/etc/config.conf:ro nginx (arquivo de config do host ro).

Com a persistência resolvida, o próximo passo é a rede de contêineres.

8. Docker Compose: Orquestração Simplificada para Múltiplos Contêineres

Compreender a rede Docker é crucial para aplicações robustas e seguras, permitindo a comunicação entre contêineres e com o exterior.

Redes Padrão:

• bridge: Padrão para contêineres autônomos. Oferece IPs internos e isolamento. Requer mapeamento de portas (-p) para acesso externo.
• host: Contêiner compartilha a pilha de rede do host. Sem isolamento de IP. Útil para performance, mas expõe o contêiner.
• none: Contêiner sem interface de rede. Sem comunicação. Para tarefas offline.

Redes Personalizadas:
Melhor prática para aplicações complexas, criando redes bridge isoladas com docker network create.

docker network create minha_rede_app

Benefícios: Isolamento aprimorado e descoberta de serviços por nome. Contêineres na mesma rede comunicam-se usando seus nomes (ex: nome do contêiner), simplificando a interconexão.
Conecte contêineres com --network no docker run:

docker run -d --name meu_banco --network minha_rede_app postgres
docker run -d --name minha_app --network minha_rede_app meu_aplicativo_web

minha_app pode acessar meu_banco usando o nome meu_banco.

Mapeamento de Portas (-p):
Essencial para expor serviços do contêiner ao host ou ao mundo exterior. Sintaxe: -p <porta_no_host>:<porta_no_contêiner>.

docker run -d --name minha_app --network minha_rede_app -p 80:80 meu_aplicativo_web

Mapeia a porta 80 do contêiner para a porta 80 do host.

Exemplo Prático (Aplicação Web + Banco de Dados):
Crie a rede, inicie o banco e a aplicação na mesma rede:

docker network create rede_minha_app
docker run -d --name meu_banco_dados --network rede_minha_app -e POSTGRES_PASSWORD=minhasenha postgres:latest
docker run -d --name minha_app_web --network rede_minha_app -p 8080:80 minha_imagem_app_web:latest

Dentro de minha_app_web, conecte-se a meu_banco_dados usando seu nome. Use a flag -e para passar variáveis de ambiente (como senhas).

9. Boas Práticas e Dicas Finais: Otimizando seu Uso de Docker

Gerenciar aplicações Docker complexas com múltiplos contêineres é um desafio. O Docker Compose simplifica essa orquestração, permitindo definir e executar ambientes multi-contêiner usando um único arquivo YAML. Em vez de múltiplos docker run, um comando gerencia o ciclo de vida de todos os serviços.

A espinha dorsal é o docker-compose.yml, onde se declaram serviços (contêineres), redes e volumes. Nele, você especifica:

• version: Versão do formato.
• services: Cada item é um contêiner, definindo image (ou build), ports (mapeamento host:contêiner), volumes (persistência/compartilhamento), environment (variáveis) e depends_on (ordem de inicialização).
• networks: Redes customizadas para comunicação (serviços se comunicam por nome).
• volumes: Volumes nomeados para persistência de dados.

Comandos essenciais:

• docker-compose up [-d]: Constrói, cria e inicia serviços (detached).
• docker-compose down: Para e remove contêineres, redes e volumes.
• docker-compose build: Constrói imagens customizadas.
• docker-compose ps: Lista o estado dos serviços.
• docker-compose logs: Exibe logs.

Para ilustrar, um docker-compose.yml para uma aplicação web (Node.js) e PostgreSQL:

version: '3.8'

services:
  web:
    build: .
    ports:
      - "3000:3000"
    environment:
      DATABASE_URL: postgres://user:password@db:5432/mydatabase
    depends_on:
      - db
    volumes:
      - .:/app

  db:
    image: postgres:13
    environment:
      POSTGRES_DB: mydatabase
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password
    volumes:
      - db_data:/var/lib/postgresql/data

volumes:
  db_data:

Com este arquivo, docker-compose up -d inicia tudo, garantindo o DB pronto. Use docker-compose down para desligar e remover.

Com Docker e Compose, você pode orquestrar suas aplicações. Otimize o uso com boas práticas.

10. Conclusão: Próximos Passos na Jornada Docker

Com o Docker, a conveniência de empacotar e executar aplicações exige boas práticas para contêineres eficientes e seguros.

Otimização de Dockerfiles

• Minimizar Camadas: Agrupe comandos RUN (&&) para reduzir camadas; otimiza imagens e builds.
• Usar .dockerignore: Exclua arquivos desnecessários; acelera build e protege dados.
• Imagens Menores: Prefira imagens base leves (ex: alpine): menor tamanho e superfície de ataque.
• Multi-stage Builds: Separe build/execução, copiando só artefatos para imagens leves.

Segurança em Contêineres

• Evitar root: Use USER (não privilegiado) no Dockerfile para limitar danos.
• Imagens Confiáveis: Prefira imagens oficiais/confiáveis, evitando vulnerabilidades.
• Superfície Mínima: Instale só o essencial; reduza superfície de ataque e vulnerabilidades.

Gerenciamento de Recursos

• Limitar CPU/Memória: Defina limites (--cpus, --memory) para contêineres, garantindo previsibilidade.

Limpeza de Recursos

• docker system prune: Use para remover recursos não usados (imagens, contêineres, volumes, redes), liberando espaço.

Versionamento de Imagens

• Taggear com Versões: Taggeie imagens com versões claras (ex: app:1.0), não latest, para controle e colaboração.

Monitoramento de Logs

• Ferramentas de Log: Em produção, use ferramentas de agregação de logs (ELK, Loki) para centralizar e analisar.

Este guia oferece base sólida para aproveitar a conteinerização.