Docker &
Kubernetes
Masterclass

# ─────────────────────────────────────────────────────────────────────────────
# ESTÁGIO 1: Build
# Instala todas as dependências (incluindo devDependencies) e transpila o código
# ─────────────────────────────────────────────────────────────────────────────
FROM node:22-alpine AS builder

# Criar usuário não-root desde o estágio de build
RUN addgroup -S appgroup && adduser -S appuser -G appgroup

WORKDIR /usr/src/app

# COPIAR manifests ANTES do código-fonte
# Se package.json NÃO mudou, o Docker usa cache e pula o 'yarn install'
# Se você copiasse tudo com 'COPY . .' aqui, qualquer mudança de código
# invalidaria o cache do install — builds seriam 3x mais lentos.
COPY package.json yarn.lock ./
RUN yarn install --frozen-lockfile --production=false

# Agora copia o código-fonte (invalida cache apenas quando código muda)
COPY . .
RUN yarn build   # transpila TypeScript → dist/

# ─────────────────────────────────────────────────────────────────────────────
# ESTÁGIO 2: Runtime
# Imagem final ENXUTA: copia apenas o necessário do estágio anterior
# Compiladores, devDependencies e código-fonte ficam fora da imagem final
# ─────────────────────────────────────────────────────────────────────────────
FROM node:22-alpine AS runtime

# dumb-init: PID 1 leve que propaga sinais POSIX corretamente
# Sem ele, Node.js roda como PID 1 e ignora SIGTERM → container não fecha gracefully
RUN apk add --no-cache dumb-init

# Princípio do Menor Privilégio: nunca rodar como root em produção
RUN addgroup -S appgroup && adduser -S appuser -G appgroup
USER appuser

WORKDIR /usr/src/app

# Copiar APENAS artefatos do estágio 'builder' — não o código-fonte TypeScript
COPY --from=builder --chown=appuser:appgroup /usr/src/app/dist        ./dist
COPY --from=builder --chown=appuser:appgroup /usr/src/app/node_modules ./node_modules

# Variáveis de ambiente default — override via --env-file em produção
ENV NODE_ENV=production \
    PORT=8080

# EXPOSE é apenas documentação — não abre porta automaticamente
# A porta real é mapeada com 'docker run -p 8080:8080'
EXPOSE 8080

# HEALTHCHECK: permite que Docker/K8s saibam se o app está saudável
# Sem isso, o orquestrador não sabe distinguir "container rodando" de "app respondendo"
HEALTHCHECK --interval=30s --timeout=5s --start-period=10s --retries=3 \
    CMD wget -qO- http://localhost:8080/health || exit 1

# ENTRYPOINT fixo com dumb-init; CMD são os argumentos (substituíveis)
ENTRYPOINT ["dumb-init", "--"]
CMD ["node", "dist/server.js"]

FROM python:3.12-slim AS base
ENV PYTHONDONTWRITEBYTECODE=1 PYTHONUNBUFFERED=1
RUN pip install --no-cache-dir uv   # uv: pip ultra-rápido em Rust

FROM base AS builder
WORKDIR /app
COPY requirements.txt .
RUN uv pip install --system -r requirements.txt

FROM base AS runtime
RUN useradd --create-home appuser
USER appuser
WORKDIR /app
COPY --from=builder /usr/local/lib/python3.12 /usr/local/lib/python3.12
COPY --chown=appuser . .
EXPOSE 8000
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000", "--workers", "4"]

FROM golang:1.23-alpine AS builder
WORKDIR /app
COPY go.mod go.sum ./
RUN go mod download
COPY . .
# CGO_ENABLED=0: binário estático sem dependência de libc
RUN CGO_ENABLED=0 GOOS=linux go build -ldflags="-s -w" -o /app/server ./cmd/server

# scratch: imagem absolutamente vazia — apenas o binário Go
FROM scratch
COPY --from=builder /app/server /server
COPY --from=builder /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/
EXPOSE 8080
ENTRYPOINT ["/server"]
# Imagem final: ~6 MB. Zero vulnerabilidades (nada para atacar)

# Docker Compose v2 — integrado ao Docker CLI (sem versão obsoleta)

services:

  # ─── Nginx: Reverse Proxy + TLS Termination ──────────────────────────────
  nginx:
    image: nginx:1.27-alpine
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx/nginx.conf:/etc/nginx/nginx.conf:ro  # :ro = read-only no container
      - ssl-certs:/etc/ssl/certs
      - ./nginx/logs:/var/log/nginx
    depends_on:
      api:
        condition: service_healthy  # Só sobe após API passar no healthcheck
    networks:
      - frontend-net
    restart: unless-stopped

  # ─── API Node.js: 3 réplicas com limites de recursos ─────────────────────
  api:
    build:
      context: .
      target: runtime  # Usa o estágio 'runtime' do Multi-Stage Dockerfile
      args:
        BUILD_DATE: ${BUILD_DATE}
    env_file: .env.production
    environment:
      DATABASE_URL: postgresql://apiuser:${DB_PASS}@postgres:5432/appdb
      REDIS_URL: redis://:${REDIS_PASS}@redis:6379/0
      NODE_ENV: production
    deploy:
      replicas: 3
      resources:
        limits:
          cpus: "0.5"      # máximo 50% de 1 CPU por réplica
          memory: 512M    # OOM killer mata se ultrapassar
        reservations:
          cpus: "0.1"
          memory: 256M
    healthcheck:
      test: ["CMD", "wget", "-qO-", "http://localhost:8080/health"]
      interval: 30s
      timeout: 5s
      retries: 3
      start_period: 15s  # Grace period para o app inicializar
    depends_on:
      postgres:
        condition: service_healthy
      redis:
        condition: service_started
    networks:
      - frontend-net
      - backend-net
    restart: on-failure:3  # Reinicia até 3 vezes em caso de falha

  # ─── PostgreSQL 16 com Secrets ────────────────────────────────────────────
  postgres:
    image: postgres:16.3-alpine
    environment:
      POSTGRES_USER: apiuser
      POSTGRES_DB: appdb
      POSTGRES_PASSWORD_FILE: /run/secrets/db_password
    secrets:
      - db_password
    volumes:
      - pg-data:/var/lib/postgresql/data
      - ./postgres/init.sql:/docker-entrypoint-initdb.d/init.sql:ro
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U apiuser -d appdb"]
      interval: 10s
      retries: 5
    networks:
      - backend-net
    restart: unless-stopped

  # ─── Redis 7: Cache + Session Store com eviction policy ──────────────────
  redis:
    image: redis:7.4-alpine
    command: >
      redis-server
      --requirepass ${REDIS_PASS}
      --maxmemory 256mb
      --maxmemory-policy allkeys-lru
      --save 60 1
      --appendonly yes
    volumes:
      - redis-data:/data
    networks:
      - backend-net
    restart: unless-stopped

  # ─── Adminer: GUI de banco de dados (apenas em dev/staging) ──────────────
  adminer:
    image: adminer:4.8
    profiles:
      - dev  # Só sobe com: docker compose --profile dev up
    ports:
      - "8888:8080"
    networks:
      - backend-net

networks:
  frontend-net:     # Nginx ↔ API
    driver: bridge
  backend-net:      # API ↔ Banco ↔ Cache (sem acesso externo)
    driver: bridge
    internal: true  # Nenhum container nessa rede acessa a internet

volumes:
  pg-data:
  redis-data:
  ssl-certs:

secrets:
  db_password:
    file: ./secrets/db_password.txt   # Arquivo fora do repositório Git

apiVersion: apps/v1
kind: Deployment
metadata:
  name: minha-api
  namespace: producao
  labels:
    app: minha-api
    version: "1.2.0"
spec:
  replicas: 3
  selector:
    matchLabels:
      app: minha-api
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxUnavailable: 1   # Nunca mais que 1 pod indisponível durante update
      maxSurge: 1          # Máximo 1 pod extra criado durante update
  template:
    metadata:
      labels:
        app: minha-api
    spec:
      serviceAccountName: minha-api-sa  # ServiceAccount dedicado (não o default)

      # Pod-level security: aplica a todos os containers do pod
      securityContext:
        runAsNonRoot: true
        runAsUser: 1000
        runAsGroup: 3000
        fsGroup: 2000

      # Garantir HA: pods em nodes e zonas diferentes
      affinity:
        podAntiAffinity:
          preferredDuringSchedulingIgnoredDuringExecution:
            - weight: 100
              podAffinityTerm:
                topologyKey: "kubernetes.io/hostname"
                labelSelector:
                  matchLabels:
                    app: minha-api

      containers:
        - name: api
          image: registry.empresa.com/api/minha-api:1.2.0
          imagePullPolicy: Always  # Sempre verifica novidades no registry
          ports:
            - name: http
              containerPort: 8080
              protocol: TCP

          # Config via ConfigMap (não-sensível) e Secret (sensível)
          envFrom:
            - configMapRef:
                name: api-config
          env:
            - name: DB_PASSWORD
              valueFrom:
                secretKeyRef:
                  name: api-secrets
                  key: db-password

          # Limites de recursos: crítico para scheduler e OOM killer
          resources:
            requests:  # O scheduler usa isso para encontrar nodes com espaço
              cpu: "100m"    # 100 millicores = 0.1 CPU
              memory: 128Mi
            limits:    # O cgroup mata se ultrapassar esses limites
              cpu: "500m"    # CPU é throttled (não mata), memória mata (OOM)
              memory: 512Mi

          # Container-level security
          securityContext:
            allowPrivilegeEscalation: false
            readOnlyRootFilesystem: true
            capabilities:
              drop: ["ALL"]

          # Liveness: "o container está vivo?" — falha = reinicia
          livenessProbe:
            httpGet:
              path: /health/live
              port: http
            initialDelaySeconds: 30
            periodSeconds: 10
            failureThreshold: 3

          # Readiness: "pode receber tráfego?" — falha = remove do Service
          readinessProbe:
            httpGet:
              path: /health/ready
              port: http
            initialDelaySeconds: 10
            periodSeconds: 5

          volumeMounts:
            - name: tmp
              mountPath: /tmp  # readOnlyRootFilesystem precisa de tmp explícito

      volumes:
        - name: tmp
          emptyDir: {}
---
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: minha-api-hpa
  namespace: producao
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: minha-api
  minReplicas: 3
  maxReplicas: 20
  metrics:
    - type: Resource
      resource:
        name: cpu
        target:
          type: Utilization
          averageUtilization: 70  # Escala quando CPU média > 70%
    - type: Resource
      resource:
        name: memory
        target:
          type: Utilization
          averageUtilization: 80

# 1. ServiceAccount: identidade da aplicação dentro do cluster
apiVersion: v1
kind: ServiceAccount
metadata:
  name: minha-api-sa
  namespace: producao
automountServiceAccountToken: false  # NÃO montar token automático (CVE comum)
---
# 2. Role: permissões DENTRO do namespace producao
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  name: minha-api-role
  namespace: producao
rules:
# Princípio do Menor Privilégio: só o que a app REALMENTE precisa
  - apiGroups: [""]
    resources: ["configmaps"]
    verbs: ["get", "list"]
  - apiGroups: [""]
    resources: ["secrets"]
    resourceNames: ["api-secrets"]  # Apenas UM secret específico
    verbs: ["get"]
---
# 3. RoleBinding: associa o Role ao ServiceAccount
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: minha-api-binding
  namespace: producao
subjects:
  - kind: ServiceAccount
    name: minha-api-sa
    namespace: producao
roleRef:
  kind: Role
  name: minha-api-role
  apiGroup: rbac.authorization.k8s.io

# Política 1: Bloquear TODO tráfego ingress e egress no namespace
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: default-deny-all
  namespace: producao
spec:
  podSelector: {}  # Aplica a TODOS os pods do namespace
  policyTypes:
    - Ingress
    - Egress
---
# Política 2: Permitir Nginx → API (porta 8080 apenas)
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-nginx-to-api
  namespace: producao
spec:
  podSelector:
    matchLabels:
      app: minha-api
  ingress:
    - from:
        - podSelector:
            matchLabels:
              app: nginx
      ports:
        - protocol: TCP
          port: 8080
---
# Política 3: Permitir API → PostgreSQL (porta 5432 apenas)
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-api-to-db
  namespace: producao
spec:
  podSelector:
    matchLabels:
      app: postgres
  ingress:
    - from:
        - podSelector:
            matchLabels:
              app: minha-api
      ports:
        - protocol: TCP
          port: 5432

# Taxa de requisições por segundo (golden signal: throughput)
rate(http_requests_total{namespace="producao",job="minha-api"}[5m])

# Percentil 99 de latência (golden signal: latency)
histogram_quantile(0.99,
  rate(http_request_duration_seconds_bucket{namespace="producao"}[5m])
)

# Taxa de erros 5xx (golden signal: errors)
sum(rate(http_requests_total{status=~"5.."}[5m]))
  /
sum(rate(http_requests_total[5m]))

# Uso de CPU por pod (% do limit)
100 * (
  rate(container_cpu_usage_seconds_total{namespace="producao",container!=""}[5m])
  /
  container_spec_cpu_quota{namespace="producao",container!=""} * 100000
)

# Pods em CrashLoop nos últimos 15 minutos
rate(kube_pod_container_status_restarts_total{namespace="producao"}[15m]) * 60 * 15 > 5

# Nodes com pressão de memória
kube_node_status_condition{condition="MemoryPressure",status="true"} == 1

# Estimativa de quando o disco ficará cheio (próximas 4 horas)
predict_linear(
  node_filesystem_avail_bytes{mountpoint="/"}[1h],
  4 * 3600
) < 0