Docker

Docker é uma plataforma de containerização que virtualiza sistemas operacionais, permitindo empacotar aplicações com suas dependências em contêineres isolados e portáveis.

Configuração WSL2

Para instalação do WSL2, consulte: codeedu/wsl2-docker-quickstart

Acesso ao Sistema de Arquivos

O acesso às unidades de armazenamento no WSL é feito através do diretório /mnt/:

# Navegar para unidades de armazenamento
cd /mnt/

# Copiar arquivos entre Linux e Windows
cp /home/lucas/documento.docx /mnt/c/Users/lucas/Documents

Para acesso via interface gráfica, digite \\wsl$ no Windows Explorer.

Comandos Básicos

Gerenciamento de Contêineres

# Listar contêineres
docker ps                    # Em execução
docker ps -a                 # Todos os contêineres

# Executar contêineres
docker run nginx                         # Modo padrão
docker run -d nginx                      # Modo detached (background)
docker run -d -p 8080:80 nginx          # Com porta exposta
docker run -d --name meu-nginx nginx    # Com nome customizado
docker run --rm nginx                   # Remove após execução

# Controle de contêineres
docker start <container-name>   # Iniciar contêiner parado
docker stop <container-name>    # Parar contêiner
docker restart <container-name> # Reiniciar contêiner
docker rm <container-name>      # Remover contêiner
docker rm <container-name> -f   # Remover forçado

# Acesso ao contêiner
docker exec -it <container-name> bash   # Executar comando interativo
docker attach <container-name>          # Conectar ao processo principal

Gerenciamento de Imagens

docker images              # Listar imagens locais
docker pull <image-name>   # Baixar imagem do registry
docker rmi <image-name>    # Remover imagem
docker build -t <tag> .    # Construir imagem a partir do Dockerfile

Limpeza do Sistema

# Remover todos contêineres parados
docker rm $(docker ps -a -q) -f

# Remover imagens não utilizadas
docker image prune

# Limpeza completa do sistema
docker system prune -a

Conceitos Fundamentais

Contêineres

Contêineres são unidades de software que empacotam código e dependências, garantindo execução consistente entre ambientes. Baseiam-se em três pilares fundamentais:

Namespaces: Isolam processos para evitar conflitos com outros componentes do sistema operacional.

CGroups: Controlam e limitam o uso de recursos do sistema (CPU, memória, I/O) para evitar sobrecarga.

Overlay File System (OFS): Permite reutilização de camadas entre contêineres, otimizando armazenamento e reduzindo duplicação.

Imagens

Imagens são templates imutáveis que servem como base para criar contêineres. Características importantes:

• Compostas por camadas reutilizáveis
• Versionadas através de tags
• Armazenadas em registries (Docker Hub, AWS ECR, etc.)
• Imutáveis durante execução do contêiner

Natureza Efêmera

Contêineres são efêmeros por design. Dados gravados no sistema de arquivos do contêiner são perdidos quando ele é removido. Para persistência, utilize volumes ou bind mounts.

Dockerfile

Arquivo de configuração que define como construir uma imagem Docker:

# Imagem base
FROM ubuntu:latest

# Instalar dependências
RUN apt-get update && apt-get install -y nginx

# Copiar arquivos
COPY ./app /var/www/html

# Expor porta
EXPOSE 80

# Comando de inicialização
CMD ["nginx", "-g", "daemon off;"]

Comandos de Build

# Construir imagem
docker build -t minha-imagem:latest .

# Especificar Dockerfile customizado
docker build -f custom.dockerfile -t minha-imagem:latest .

# Build com argumentos
docker build --build-arg ARG_NAME=value -t minha-imagem .

Diferença entre CMD e ENTRYPOINT

• CMD: Comando padrão que pode ser sobrescrito
• ENTRYPOINT: Comando fixo sempre executado

Volumes e Persistência

Bind Mounts

Vinculam diretórios do host ao contêiner:

# Sintaxe antiga (ainda funcional)
docker run -d -v ~/local:/container nginx

# Sintaxe recomendada
docker run -d --mount type=bind,source="$(pwd)",target=/app nginx

Volumes Docker

Gerenciados pelo Docker, independentes do ciclo de vida dos contêineres:

# Gerenciar volumes
docker volume create meu-volume     # Criar
docker volume ls                    # Listar
docker volume inspect meu-volume   # Inspecionar
docker volume rm meu-volume        # Remover
docker volume prune                 # Limpar não utilizados

# Usar volume em contêiner
docker run -d --mount type=volume,source=meu-volume,target=/data nginx

Redes (Networks)

Tipos de Rede

Bridge (padrão): Comunicação entre contêineres no mesmo host

Host: Compartilha rede com o host (não funciona no macOS)

Overlay: Comunicação entre contêineres em hosts diferentes

Macvlan: Permite definir endereço MAC personalizado

None: Isola completamente o contêiner

Comandos de Rede

# Gerenciar redes
docker network ls                                    # Listar redes
docker network create <network-name>                 # Criar rede bridge
docker network create --driver overlay <network-name> # Criar rede overlay
docker network inspect <network-name>               # Inspecionar rede
docker network rm <network-name>                    # Remover rede

# Conectar contêineres
docker run -d --network <network-name> nginx        # Conectar na criação
docker network connect <network-name> <container>   # Conectar contêiner existente
docker network disconnect <network-name> <container> # Desconectar

# Acesso a serviços do host
# Use host.docker.internal:porta para acessar serviços do host

Modo Interativo

# Executar contêiner interativo
docker run -it ubuntu:latest bash

# Parâmetros:
# -i: Modo interativo (mantém stdin ativo)
# -t: TTY (permite digitação de comandos)

Docker Compose

Ferramenta para definir e executar aplicações multi-contêiner usando arquivos YAML.

Comandos Básicos

# Gerenciar serviços
docker compose up              # Iniciar serviços
docker compose up -d           # Iniciar em background
docker compose up --build     # Rebuild das imagens
docker compose down            # Parar e remover serviços
docker compose restart        # Reiniciar serviços
docker compose logs           # Ver logs dos serviços
docker compose ps             # Listar serviços em execução

Exemplo docker-compose.yml

version: '3.8'

services:
  web:
    build: .
    ports:
      - "8080:80"
    volumes:
      - .:/app
    networks:
      - app-network
    depends_on:
      - database
    environment:
      - NODE_ENV=production

  database:
    image: mysql:8.0
    environment:
      MYSQL_ROOT_PASSWORD: password
      MYSQL_DATABASE: app_db
    volumes:
      - db-data:/var/lib/mysql
    networks:
      - app-network
    healthcheck:
      test: ["CMD", "mysqladmin", "ping", "-h", "localhost"]
      timeout: 20s
      retries: 10

volumes:
  db-data:

networks:
  app-network:
    driver: bridge

Boas Práticas

Desenvolvimento de Imagens

1. Use imagens oficiais como base sempre que possível
2. Minimize camadas combinando comandos RUN
3. Use .dockerignore para excluir arquivos desnecessários
4. Não execute como root dentro do contêiner
5. Use multi-stage builds para reduzir tamanho da imagem
6. Especifique versões das imagens base (evite 'latest')

Gerenciamento de Recursos

1. Defina limites de recursos (CPU, memória)
2. Use health checks para monitoramento
3. Implemente logs estruturados
4. Configure restart policies adequadas

Segurança

1. Escaneie imagens em busca de vulnerabilidades
2. Use usuários não-privilegiados
3. Minimize superfície de ataque (imagens distroless)
4. Gerencie secrets adequadamente (não em variáveis de ambiente)

Exemplo de Multi-stage Build

# Estágio de build
FROM node:18-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production

# Estágio final
FROM node:18-alpine
RUN addgroup -g 1001 -S nodejs
RUN adduser -S nextjs -u 1001
WORKDIR /app
COPY --from=builder /app/node_modules ./node_modules
COPY . .
USER nextjs
EXPOSE 3000
CMD ["npm", "start"]