Docker e Kubernetes: Guia Completo de Containerização

Introdução ao Mundo dos Containers

Containerização revolucionou a forma como desenvolvemos, testamos e fazemos deploy de aplicações. Vamos explorar Docker e Kubernetes do básico ao avançado.

Por Que Usar Containers?

Benefícios Principais

1. Portabilidade - "Funciona na minha máquina" é coisa do passado
2. Isolamento - Cada container tem seu próprio ambiente
3. Eficiência - Usa menos recursos que VMs
4. Escalabilidade - Fácil escalar horizontalmente

## Comparação de recursos
VM: 2GB RAM + Sistema Operacional completo
Container: 50MB RAM + Apenas a aplicação

Docker: Fundamentos

Instalação

## Linux
curl -fsSL https://get.docker.com -o get-docker.sh
sh get-docker.sh

## Verificar instalação
docker --version

Primeiro Container

## Executar nginx
docker run -d -p 8080:80 nginx

## Listar containers
docker ps

## Parar container
docker stop <container-id>

Dockerfile: Criando Imagens

Estrutura Básica

## Imagem base
FROM node:20-alpine

## Diretório de trabalho
WORKDIR /app

## Copiar package files
COPY package*.json ./

## Instalar dependências
RUN npm ci --only=production

## Copiar código
COPY . .

## Build da aplicação
RUN npm run build

## Expor porta
EXPOSE 3000

## Comando de inicialização
CMD ["node", "dist/index.js"]

Multi-Stage Build

Otimize suas imagens com builds em múltiplos estágios:

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

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

Resultado

## Antes: 1.2GB
## Depois: 180MB
docker images

Docker Compose

Definindo Múltiplos Serviços

version: '3.8'

services:
  app:
    build: .
    ports:
      - "3000:3000"
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgresql://db:5432/myapp
    depends_on:
      - db
      - redis

  db:
    image: postgres:16-alpine
    environment:
      - POSTGRES_DB=myapp
      - POSTGRES_PASSWORD=secret
    volumes:
      - postgres-data:/var/lib/postgresql/data

  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"

volumes:
  postgres-data:

Comandos Úteis

## Iniciar todos os serviços
docker-compose up -d

## Ver logs
docker-compose logs -f app

## Parar tudo
docker-compose down

## Rebuild
docker-compose up -d --build

Kubernetes: Orquestração

Conceitos Fundamentais

• Pod - Menor unidade, contém um ou mais containers
• Deployment - Gerencia réplicas de Pods
• Service - Expõe Pods na rede
• Ingress - Gerencia acesso externo

Deployment YAML

apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp
  labels:
    app: myapp
spec:
  replicas: 3
  selector:
    matchLabels:
      app: myapp
  template:
    metadata:
      labels:
        app: myapp
    spec:
      containers:
      - name: app
        image: myapp:latest
        ports:
        - containerPort: 3000
        env:
        - name: NODE_ENV
          value: "production"
        resources:
          requests:
            memory: "128Mi"
            cpu: "100m"
          limits:
            memory: "256Mi"
            cpu: "200m"
        livenessProbe:
          httpGet:
            path: /health
            port: 3000
          initialDelaySeconds: 30
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /ready
            port: 3000
          initialDelaySeconds: 5
          periodSeconds: 5

Service

apiVersion: v1
kind: Service
metadata:
  name: myapp-service
spec:
  selector:
    app: myapp
  ports:
  - protocol: TCP
    port: 80
    targetPort: 3000
  type: LoadBalancer

Ingress

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: myapp-ingress
  annotations:
    kubernetes.io/ingress.class: nginx
    cert-manager.io/cluster-issuer: letsencrypt-prod
spec:
  tls:
  - hosts:
    - myapp.com
    secretName: myapp-tls
  rules:
  - host: myapp.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: myapp-service
            port:
              number: 80

Comandos Kubernetes Essenciais

## Aplicar configuração
kubectl apply -f deployment.yaml

## Ver pods
kubectl get pods

## Ver logs
kubectl logs -f <pod-name>

## Escalar deployment
kubectl scale deployment myapp --replicas=5

## Ver detalhes
kubectl describe pod <pod-name>

## Executar comando em pod
kubectl exec -it <pod-name> -- /bin/sh

## Port forward
kubectl port-forward <pod-name> 3000:3000

ConfigMaps e Secrets

ConfigMap

apiVersion: v1
kind: ConfigMap
metadata:
  name: app-config
data:
  API_URL: "https://api.example.com"
  LOG_LEVEL: "info"

Secret

apiVersion: v1
kind: Secret
metadata:
  name: app-secrets
type: Opaque
data:
  DB_PASSWORD: cGFzc3dvcmQxMjM=  # base64 encoded
  API_KEY: YXBpa2V5MTIzNDU=

Usando em Deployment

containers:
- name: app
  envFrom:
  - configMapRef:
      name: app-config
  - secretRef:
      name: app-secrets

Monitoramento e Logging

Health Checks

// Express.js exemplo
app.get('/health', (req, res) => {
  res.status(200).json({ status: 'healthy' });
});

app.get('/ready', async (req, res) => {
  try {
    await db.ping();
    res.status(200).json({ status: 'ready' });
  } catch (error) {
    res.status(503).json({ status: 'not ready' });
  }
});

Prometheus Metrics

apiVersion: v1
kind: Service
metadata:
  name: myapp-metrics
  annotations:
    prometheus.io/scrape: "true"
    prometheus.io/port: "3000"
    prometheus.io/path: "/metrics"

Best Practices

1. Security

## Não use root
USER node

## Use imagens oficiais
FROM node:20-alpine

## Scan de vulnerabilidades
RUN npm audit

2. Otimização de Imagem

## Use .dockerignore
## .dockerignore
node_modules
.git
*.md
.env

3. Resource Limits

resources:
  requests:
    memory: "128Mi"
    cpu: "100m"
  limits:
    memory: "256Mi"
    cpu: "200m"

4. Rolling Updates

spec:
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 1
      maxUnavailable: 0

CI/CD com Containers

GitHub Actions Exemplo

name: Build and Deploy

on:
  push:
    branches: [main]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v4
    
    - name: Build Docker image
      run: docker build -t myapp:${{ github.sha }} .
    
    - name: Push to registry
      run: |
        docker tag myapp:${{ github.sha }} registry.com/myapp:latest
        docker push registry.com/myapp:latest
    
    - name: Deploy to Kubernetes
      run: |
        kubectl set image deployment/myapp app=registry.com/myapp:${{ github.sha }}

Troubleshooting

Debugging Comum

## Pod não inicia
kubectl describe pod <pod-name>
kubectl logs <pod-name>

## Problemas de rede
kubectl exec -it <pod-name> -- ping <service-name>

## Verificar recursos
kubectl top pods
kubectl top nodes

Conclusão

Docker e Kubernetes são ferramentas essenciais no desenvolvimento moderno. Dominá-las te coloca em posição privilegiada no mercado.

Principais aprendizados:

• Containerização traz portabilidade e eficiência
• Docker simplifica criação e gestão de containers
• Kubernetes orquestra containers em escala
• Segurança e otimização são cruciais

Comece pequeno, containerize uma aplicação simples e vá evoluindo. A curva de aprendizado compensa!