Padrões de Implantação

Fluxos de trabalho de implantação em produção e melhores práticas de CI/CD.

Quando Ativar

• Configuração de pipelines de CI/CD
• Dockerização de uma aplicação
• Planejamento de estratégia de implantação (blue-green, canary, rolling)
• Implementação de verificações de saúde (health checks) e sondas de prontidão (readiness probes)
• Preparação para um lançamento em produção
• Configuração de ajustes específicos para cada ambiente

Estratégias de Implantação

Implantação Contínua (Rolling Deployment - Padrão)

Substitua instâncias gradualmente — versões antiga e nova executam simultaneamente durante a implantação.

Instance 1: v1 → v2  (update first)
Instance 2: v1        (still running v1)
Instance 3: v1        (still running v1)

Instance 1: v2
Instance 2: v1 → v2  (update second)
Instance 3: v1

Instance 1: v2
Instance 2: v2
Instance 3: v1 → v2  (update last)

Prós: Zero tempo de inatividade, implantação gradual Contras: Duas versões executam simultaneamente — requer alterações compatíveis com versões anteriores Use quando: Implantações padrão, alterações compatíveis com versões anteriores

Implantação Blue-Green

Execute dois ambientes idênticos. Alterne o tráfego atomicamente.

Blue  (v1) ← traffic
Green (v2)   idle, running new version

# After verification:
Blue  (v1)   idle (becomes standby)
Green (v2) ← traffic

Prós: Rollback instantâneo (volte para o blue), corte limpo Contras: Requer 2x de infraestrutura durante a implantação Use quando: Serviços críticos, tolerância zero a problemas

Implantação Canary

Direcione uma pequena porcentagem do tráfego para a nova versão primeiro.

v1: 95% of traffic
v2:  5% of traffic  (canary)

# If metrics look good:
v1: 50% of traffic
v2: 50% of traffic

# Final:
v2: 100% of traffic

Prós: Detecta problemas com tráfego real antes da implantação completa Contras: Requer infraestrutura de divisão de tráfego, monitoramento Use quando: Serviços de alto tráfego, alterações arriscadas, feature flags

Docker

Dockerfile Multi-Estágio (Node.js)

# Stage 1: Install dependencies
FROM node:22-alpine AS deps
WORKDIR /app
COPY package.json package-lock.json ./
RUN npm ci --production=false

# Stage 2: Build
FROM node:22-alpine AS builder
WORKDIR /app
COPY --from=deps /app/node_modules ./node_modules
COPY . .
RUN npm run build
RUN npm prune --production

# Stage 3: Production image
FROM node:22-alpine AS runner
WORKDIR /app

RUN addgroup -g 1001 -S appgroup && adduser -S appuser -u 1001
USER appuser

COPY --from=builder --chown=appuser:appgroup /app/node_modules ./node_modules
COPY --from=builder --chown=appuser:appgroup /app/dist ./dist
COPY --from=builder --chown=appuser:appgroup /app/package.json ./

ENV NODE_ENV=production
EXPOSE 3000

HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
  CMD wget --no-verbose --tries=1 --spider http://localhost:3000/health || exit 1

CMD ["node", "dist/server.js"]

Dockerfile Multi-Estágio (Go)

FROM golang:1.22-alpine AS builder
WORKDIR /app
COPY go.mod go.sum ./
RUN go mod download
COPY . .
RUN CGO_ENABLED=0 GOOS=linux go build -ldflags="-s -w" -o /server ./cmd/server

FROM alpine:3.19 AS runner
RUN apk --no-cache add ca-certificates
RUN adduser -D -u 1001 appuser
USER appuser

COPY --from=builder /server /server

EXPOSE 8080
HEALTHCHECK --interval=30s --timeout=3s CMD wget -qO- http://localhost:8080/health || exit 1
CMD ["/server"]

Dockerfile Multi-Estágio (Python/Django)

FROM python:3.12-slim AS builder
WORKDIR /app
RUN pip install --no-cache-dir uv
COPY requirements.txt .
RUN uv pip install --system --no-cache -r requirements.txt

FROM python:3.12-slim AS runner
WORKDIR /app

RUN useradd -r -u 1001 appuser
USER appuser

COPY --from=builder /usr/local/lib/python3.12/site-packages /usr/local/lib/python3.12/site-packages
COPY --from=builder /usr/local/bin /usr/local/bin
COPY . .

ENV PYTHONUNBUFFERED=1
EXPOSE 8000

HEALTHCHECK --interval=30s --timeout=3s CMD python -c "import urllib.request; urllib.request.urlopen('http://localhost:8000/health/')" || exit 1
CMD ["gunicorn", "config.wsgi:application", "--bind", "0.0.0.0:8000", "--workers", "4"]

Melhores Práticas do Docker

# Boas práticas
- Use tags de versão específicas (node:22-alpine, não node:latest)
- Builds multi-estágio para minimizar o tamanho da imagem
- Execute como usuário não-root
- Copie arquivos de dependência primeiro (cache de camadas)
- Use .dockerignore para excluir node_modules, .git, tests
- Adicione a instrução HEALTHCHECK
- Defina limites de recursos no docker-compose ou k8s

# Más práticas
- Executar como root
- Usar tags :latest
- Copiar o repositório inteiro em uma única camada COPY
- Instalar dependências de desenvolvimento na imagem de produção

…