Docker: Guia Completo de Containerização Para Devs

"Funciona na minha máquina" - a frase que assombrou desenvolvedores por décadas. Docker eliminou esse problema ao empacotar aplicações com todas as suas dependências em containers portáteis que rodam consistentemente em qualquer ambiente.

O que é Docker?

Docker é uma plataforma de containerização que permite empacotar aplicações e suas dependências em containers isolados, leves e portáteis. Ao contrário de máquinas virtuais que virtualizam hardware completo, containers compartilham o kernel do sistema operacional, resultando em footprint mínimo e startup instantâneo.

Containers vs VMs

Máquinas Virtuais

• Virtualizam hardware completo
• Cada VM tem SO completo
• Gigabytes de tamanho
• Minutos para iniciar
• Overhead significativo

Containers Docker

• Compartilham kernel do host
• Apenas app + dependências
• Megabytes de tamanho
• Segundos para iniciar
• Overhead mínimo

VM Architecture:
[App A] [App B] [App C]
[Guest OS] [Guest OS] [Guest OS]
[Hypervisor]
[Host OS]
[Infrastructure]

Docker Architecture:
[App A] [App B] [App C]
[Docker Engine]
[Host OS]
[Infrastructure]

Por que Docker Mudou Tudo?

1. Consistência Absoluta

# Dockerfile define ambiente exato
FROM node:18-alpine
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production
COPY . .
EXPOSE 3000
CMD ["node", "server.js"]

Esse container roda identicamente em:

• Dev laptop (Windows/Mac/Linux)
• Servidor staging
• Produção cloud
• CI/CD pipeline

2. Isolamento de Dependências

Múltiplas versões coexistindo pacificamente:

# App A com Node 14
docker run -p 3000:3000 app-a:node14

# App B com Node 18
docker run -p 3001:3000 app-b:node18

# App C com Python 3.11
docker run -p 3002:8000 app-c:python311

Zero conflitos. Cada container é independente.

3. Desenvolvimento Rápido

Clone repo, rode um comando:

git clone https://github.com/user/projeto
cd projeto
docker-compose up

Em minutos, ambiente completo funciona - banco de dados, cache, APIs, tudo.

4. Deploy Simplificado

Build uma vez, deploy em qualquer lugar:

# Build
docker build -t meuapp:v1.0.0 .

# Push para registry
docker push registry.empresa.com/meuapp:v1.0.0

# Deploy (em qualquer servidor)
docker run -d -p 80:3000 registry.empresa.com/meuapp:v1.0.0

Conceitos Fundamentais

Images

Templates read-only para criar containers:

# Baixar image
docker pull nginx:alpine

# Listar images
docker images

# Remover image
docker rmi nginx:alpine

Containers

Instâncias executáveis de images:

# Criar e iniciar container
docker run -d --name meu-nginx -p 8080:80 nginx:alpine

# Listar containers rodando
docker ps

# Parar container
docker stop meu-nginx

# Remover container
docker rm meu-nginx

Dockerfile

Receita para construir images:

# Base image
FROM node:18-alpine

# Metadata
LABEL maintainer="dev@arkanus.app"
LABEL version="1.0"

# Variáveis de ambiente
ENV NODE_ENV=production
ENV PORT=3000

# Working directory
WORKDIR /app

# Copiar dependências
COPY package*.json ./

# Instalar dependências
RUN npm ci --only=production && \
    npm cache clean --force

# Copiar código
COPY . .

# Build (se necessário)
RUN npm run build

# Expor porta
EXPOSE $PORT

# Health check
HEALTHCHECK --interval=30s --timeout=3s --start-period=40s \
  CMD node healthcheck.js

# Usuário não-root (segurança)
USER node

# Comando de inicio
CMD ["node", "dist/server.js"]

Docker Compose

Orquestrar múltiplos containers:

version: '3.8'

services:
  app:
    build: .
    ports:
      - "3000:3000"
    environment:
      - NODE_ENV=development
      - DATABASE_URL=postgres://db:5432/myapp
    depends_on:
      - db
      - redis
    volumes:
      - ./src:/app/src  # Hot reload
    networks:
      - app-network

  db:
    image: postgres:15-alpine
    environment:
      POSTGRES_DB: myapp
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password
    volumes:
      - postgres-data:/var/lib/postgresql/data
    networks:
      - app-network

  redis:
    image: redis:7-alpine
    networks:
      - app-network

  nginx:
    image: nginx:alpine
    ports:
      - "80:80"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf
    depends_on:
      - app
    networks:
      - app-network

volumes:
  postgres-data:

networks:
  app-network:
    driver: bridge

Inicie tudo:

docker-compose up -d

Casos de Uso Práticos

Desenvolvimento Local

Problema: Time com MacOS, Windows, Linux. Versões diferentes de Node, Python, etc.

Solução:

# docker-compose.yml
version: '3.8'

services:
  app:
    build: .
    volumes:
      - .:/app
      - /app/node_modules
    ports:
      - "3000:3000"
    command: npm run dev

# Todos desenvolvem da mesma forma
docker-compose up

Microserviços

Cada serviço isolado:

┌─────────────┐  ┌─────────────┐  ┌─────────────┐
│   Auth      │  │   Users     │  │   Orders    │
│  Service    │  │  Service    │  │  Service    │
│  (Node.js)  │  │  (Python)   │  │  (Go)       │
└─────────────┘  └─────────────┘  └─────────────┘
      ↓                ↓                ↓
┌─────────────────────────────────────────────────┐
│              Service Mesh (Traefik)             │
└─────────────────────────────────────────────────┘

Cada serviço em seu container, tecnologia independente.

CI/CD Pipeline

# .github/workflows/deploy.yml
name: Deploy

on:
  push:
    branches: [main]

jobs:
  build-and-deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      
      - name: Build Docker Image
        run: docker build -t myapp:${{ github.sha }} .
      
      - name: Run Tests
        run: docker run myapp:${{ github.sha }} npm test
      
      - name: Push to Registry
        run: |
          docker login registry.empresa.com
          docker push myapp:${{ github.sha }}
      
      - name: Deploy to Production
        run: |
          ssh production "docker pull myapp:${{ github.sha }} && \
                         docker-compose up -d"

Databases e Ferramentas

# PostgreSQL
docker run -d \
  --name postgres \
  -e POSTGRES_PASSWORD=senha \
  -p 5432:5432 \
  -v postgres-data:/var/lib/postgresql/data \
  postgres:15-alpine

# Redis
docker run -d --name redis -p 6379:6379 redis:7-alpine

# MongoDB
docker run -d --name mongo -p 27017:27017 mongo:6

# PGAdmin
docker run -d \
  --name pgadmin \
  -e PGADMIN_DEFAULT_EMAIL=admin@admin.com \
  -e PGADMIN_DEFAULT_PASSWORD=admin \
  -p 8080:80 \
  dpage/pgadmin4

Melhores Práticas

1. Images Leves

# ❌ Evite images pesadas
FROM ubuntu:latest  # 77MB
RUN apt-get update && apt-get install -y nodejs

# ✅ Use Alpine quando possível
FROM node:18-alpine  # 40MB

2. Multi-Stage Builds

# Stage 1: Build
FROM node:18-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

# Stage 2: Production
FROM node:18-alpine
WORKDIR /app
COPY --from=builder /app/dist ./dist
COPY --from=builder /app/node_modules ./node_modules
EXPOSE 3000
CMD ["node", "dist/server.js"]

Image final contém apenas o necessário para produção.

3. .dockerignore

# .dockerignore
node_modules
npm-debug.log
.git
.env
*.md
.vscode
coverage
.DS_Store

Evita copiar arquivos desnecessários.

4. Layers Caching

# ✅ Ordem otimizada
COPY package*.json ./  # Muda raramente
RUN npm ci             # Cache preservado se package.json não mudar
COPY . .               # Código muda frequentemente
RUN npm run build

Builds subsequentes são muito mais rápidos.

5. Segurança

# Escaneie vulnerabilidades
RUN npm audit

# Usuário não-root
RUN addgroup -g 1001 -S nodejs && \
    adduser -S nodejs -u 1001
USER nodejs

# Minimize permissões
RUN chmod -R 555 /app

# Health checks
HEALTHCHECK CMD curl --fail http://localhost:3000/health || exit 1

6. Volumes para Dados Persistentes

services:
  db:
    image: postgres:15-alpine
    volumes:
      - postgres-data:/var/lib/postgresql/data  # Dados persistem

volumes:
  postgres-data:  # Volume nomeado gerenciado pelo Docker

Docker Networking

Bridge Network (Padrão)

Containers na mesma rede comunicam por nome:

services:
  app:
    networks:
      - backend
  db:
    networks:
      - backend

networks:
  backend:

App acessa DB via http://db:5432.

Host Network

Container usa rede do host diretamente:

docker run --network host nginx

Performance máxima, mas perde isolamento.

Overlay Network

Para Docker Swarm, conecta containers entre múltiplos hosts.

Docker Volumes

Volume Nomeado

docker volume create meu-volume
docker run -v meu-volume:/app/data myapp

Bind Mount

docker run -v $(pwd)/src:/app/src myapp

Mapeia diretório do host diretamente.

tmpfs Mount

Dados em memória (não persistem):

docker run --tmpfs /app/cache myapp

Otimização de Performance

1. Limitar Recursos

services:
  app:
    deploy:
      resources:
        limits:
          cpus: '0.5'
          memory: 512M
        reservations:
          cpus: '0.25'
          memory: 256M

2. Logging Driver

services:
  app:
    logging:
      driver: "json-file"
      options:
        max-size: "10m"
        max-file: "3"

3. Cleanup Regular

# Remover containers parados
docker container prune

# Remover images não usadas
docker image prune -a

# Remover tudo não usado
docker system prune -a --volumes

Docker em Produção

Docker Swarm

Orquestração nativa do Docker:

# Inicializar swarm
docker swarm init

# Deploy stack
docker stack deploy -c docker-compose.yml myapp

# Scale service
docker service scale myapp_web=5

Kubernetes

Orquestração enterprise:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp
spec:
  replicas: 3
  selector:
    matchLabels:
      app: myapp
  template:
    metadata:
      labels:
        app: myapp
    spec:
      containers:
      - name: myapp
        image: myapp:1.0.0
        ports:
        - containerPort: 3000

Registries

Docker Hub: Público e privado AWS ECR: Registry AWS Google GCR: Registry Google Cloud Azure ACR: Registry Azure Self-hosted: Harbor, Nexus

# Push para registry privado
docker tag myapp:1.0.0 registry.empresa.com/myapp:1.0.0
docker push registry.empresa.com/myapp:1.0.0

Debugging e Troubleshooting

# Logs
docker logs -f container-name

# Executar comandos
docker exec -it container-name bash

# Inspecionar container
docker inspect container-name

# Stats em tempo real
docker stats

# Top processes
docker top container-name

# Copiar arquivos
docker cp container-name:/app/log.txt ./log.txt

Docker Desktop vs Docker Engine

Docker Desktop (Mac/Windows)

• GUI amigável
• Kubernetes integrado
• VM para rodar Linux
• Requer licença para empresas grandes

Docker Engine (Linux)

• CLI only
• Performance nativa
• Open source gratuito
• Produção servers

Alternativas ao Docker

Podman: Drop-in replacement, rootless, daemonless containerd: Engine usado pelo Kubernetes LXC/LXD: System containers rkt: Descontinuado, mas influente

Docker domina mercado, mas alternativas existem.

Conclusão

Docker transformou desenvolvimento e deployment de software. Containers eliminaram inconsistências ambientais, simplificaram deployment e permitiram arquiteturas modernas de microserviços.

Benefícios Docker: ✅ Portabilidade total ✅ Isolamento de dependências ✅ Deploy consistente ✅ Escalabilidade fácil ✅ CI/CD simplificado ✅ Desenvolvimento local espelhando produção

Na Arkanus, Docker é fundamental em nossa stack:

• Desenvolvimento local consistente
• Pipelines CI/CD
• Deployment em cloud (AWS ECS/EKS, Cloud Run)
• Microserviços arquitetura

Se você quer modernizar sua infraestrutura com containers, estamos aqui para ajudar.

---

Precisa containerizar suas aplicações? Nossa equipe tem expertise em Docker e Kubernetes. Fale conosco.