Claude Code para DevOps: Automatize CI/CD, Docker e Deploy

DevOps e a area onde engenheiros passam mais tempo escrevendo configuracoes repetitivas. Dockerfiles, pipelines de CI/CD, modulos Terraform, scripts de deploy -- a maior parte segue padroes conhecidos, mas exige atencao a detalhes que consomem horas.

O Claude Code muda isso. Em vez de copiar snippets do Stack Overflow e adaptar manualmente, voce descreve o que precisa e recebe configuracoes completas, seguindo best practices, ja adaptadas ao seu projeto. Neste guia, voce vai ver como usar Claude Code para as tarefas mais comuns de DevOps -- com exemplos reais que voce pode copiar e adaptar.

Nao estamos falando de geracao generica. O Claude Code le seu projeto, entende a estrutura, identifica dependencias e gera configuracoes que realmente funcionam no seu contexto.

1. Por que usar Claude Code para DevOps

DevOps envolve uma quantidade enorme de ferramentas, cada uma com sua propria sintaxe, suas proprias gotchas e suas proprias best practices. Um engenheiro precisa saber YAML para GitHub Actions, HCL para Terraform, Dockerfile syntax, shell scripting, Kubernetes manifests, nginx configs -- e manter tudo isso atualizado.

O Claude Code consolida esse conhecimento em um unico assistente que:

• Le seu projeto inteiro -- entende linguagem, framework, dependencias e estrutura antes de gerar qualquer configuracao
• Segue best practices atualizadas -- multi-stage builds, layer caching, security scanning, least privilege
• Adapta ao contexto -- nao gera um Dockerfile generico, gera o Dockerfile do seu projeto
• Explica decisoes -- se voce perguntar por que ele usou alpine em vez de slim, ele justifica
• Troubleshoota erros -- cole o log de erro e ele identifica a causa raiz

2. Criando Dockerfiles otimizados

O Dockerfile e provavelmente a configuracao mais comum em projetos modernos. O Claude Code gera Dockerfiles otimizados com multi-stage builds, layer caching inteligente e imagens minimais.

Prompt basico

O Claude Code analisa seu package.json (ou requirements.txt, go.mod, etc.), identifica as dependencias e gera algo como:

# Build stage
FROM node:20-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production && npm cache clean --force
COPY . .
RUN npm run build

# Production stage
FROM node:20-alpine AS production
RUN addgroup -g 1001 -S appgroup && \
    adduser -S appuser -u 1001 -G appgroup
WORKDIR /app
COPY --from=builder --chown=appuser:appgroup /app/dist ./dist
COPY --from=builder --chown=appuser:appgroup /app/node_modules ./node_modules
COPY --from=builder --chown=appuser:appgroup /app/package.json ./
USER appuser
EXPOSE 3000
HEALTHCHECK --interval=30s --timeout=3s --retries=3 \
  CMD wget --no-verbose --tries=1 --spider http://localhost:3000/health || exit 1
CMD ["node", "dist/index.js"]

Pontos que o Claude Code aplica automaticamente:

• Multi-stage build -- separa build de producao, imagem final menor
• Usuario nao-root -- cria usuario dedicado para seguranca
• Layer caching -- copia package.json antes do codigo para cachear dependencias
• Health check -- monitoring nativo do container
• Alpine base -- imagem minima (~5MB vs ~900MB do node:20)

Docker Compose para ambiente completo

version: '3.9'
services:
  app:
    build: .
    ports:
      - "3000:3000"
    environment:
      DATABASE_URL: postgres://app:secret@db:5432/myapp
      REDIS_URL: redis://cache:6379
    depends_on:
      db:
        condition: service_healthy
      cache:
        condition: service_healthy
    networks:
      - backend

  db:
    image: postgres:16-alpine
    volumes:
      - pgdata:/var/lib/postgresql/data
    environment:
      POSTGRES_DB: myapp
      POSTGRES_USER: app
      POSTGRES_PASSWORD: secret
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U app -d myapp"]
      interval: 5s
      retries: 5
    networks:
      - backend

  cache:
    image: redis:7-alpine
    volumes:
      - redisdata:/data
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 5s
      retries: 5
    networks:
      - backend

volumes:
  pgdata:
  redisdata:

networks:
  backend:
    driver: bridge

3. GitHub Actions: pipelines completas com IA

Configurar GitHub Actions do zero e tedioso. O Claude Code gera workflows completos, incluindo matrix builds, caching, artifacts e deploy condicional.

Pipeline CI completa

name: CI/CD Pipeline
on:
  push:
    branches: [main, develop]
  pull_request:
    branches: [main]

jobs:
  lint:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: 20
          cache: 'npm'
      - run: npm ci
      - run: npm run lint

  test:
    runs-on: ubuntu-latest
    needs: lint
    strategy:
      matrix:
        node-version: [18, 20, 22]
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: ${{ matrix.node-version }}
          cache: 'npm'
      - run: npm ci
      - run: npm test -- --coverage
      - uses: actions/upload-artifact@v4
        if: matrix.node-version == 20
        with:
          name: coverage
          path: coverage/

  build:
    runs-on: ubuntu-latest
    needs: test
    steps:
      - uses: actions/checkout@v4
      - uses: docker/setup-buildx-action@v3
      - uses: docker/login-action@v3
        with:
          registry: ghcr.io
          username: ${{ github.actor }}
          password: ${{ secrets.GITHUB_TOKEN }}
      - uses: docker/build-push-action@v5
        with:
          push: true
          tags: ghcr.io/${{ github.repository }}:${{ github.sha }}
          cache-from: type=gha
          cache-to: type=gha,mode=max

  deploy-staging:
    if: github.ref == 'refs/heads/develop'
    runs-on: ubuntu-latest
    needs: build
    environment: staging
    steps:
      - name: Deploy to staging
        run: |
          curl -X POST "${{ secrets.DEPLOY_WEBHOOK_STAGING }}" \
            -H "Authorization: Bearer ${{ secrets.DEPLOY_TOKEN }}" \
            -d '{"image":"ghcr.io/${{ github.repository }}:${{ github.sha }}"}'

  deploy-production:
    if: github.ref == 'refs/heads/main'
    runs-on: ubuntu-latest
    needs: build
    environment: production
    steps:
      - name: Deploy to production
        run: |
          curl -X POST "${{ secrets.DEPLOY_WEBHOOK_PROD }}" \
            -H "Authorization: Bearer ${{ secrets.DEPLOY_TOKEN }}" \
            -d '{"image":"ghcr.io/${{ github.repository }}:${{ github.sha }}"}'

O Claude Code tambem gera workflows especializados: release automation com semantic versioning, scheduled security scans com npm audit ou trivy, e notificacoes via Slack ou Discord quando builds falham.

Workflow de seguranca automatizado

name: Security Scan
on:
  schedule:
    - cron: '0 6 * * 1'  # toda segunda, 6h
  push:
    branches: [main]

jobs:
  security:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: npm audit --audit-level=high
      - uses: aquasecurity/trivy-action@master
        with:
          scan-type: 'fs'
          severity: 'HIGH,CRITICAL'
          exit-code: '1'

4. Terraform e Infrastructure as Code

Terraform e poderoso mas verboso. O Claude Code gera modulos completos com outputs, variables, e state management configurado.

# main.tf
terraform {
  required_version = ">= 1.5"
  required_providers {
    aws = { source = "hashicorp/aws", version = "~> 5.0" }
  }
  backend "s3" {
    bucket         = "myapp-terraform-state"
    key            = "infra/terraform.tfstate"
    region         = "us-east-1"
    dynamodb_table = "terraform-locks"
    encrypt        = true
  }
}

module "vpc" {
  source  = "terraform-aws-modules/vpc/aws"
  version = "~> 5.0"

  name = "${var.project}-${var.environment}"
  cidr = var.vpc_cidr

  azs             = var.availability_zones
  private_subnets = var.private_subnet_cidrs
  public_subnets  = var.public_subnet_cidrs

  enable_nat_gateway = true
  single_nat_gateway = var.environment != "production"

  tags = local.common_tags
}

resource "aws_ecs_service" "app" {
  name            = "${var.project}-service"
  cluster         = aws_ecs_cluster.main.id
  task_definition = aws_ecs_task_definition.app.arn
  desired_count   = var.app_count
  launch_type     = "FARGATE"

  network_configuration {
    subnets         = module.vpc.private_subnets
    security_groups = [aws_security_group.ecs.id]
  }

  load_balancer {
    target_group_arn = aws_lb_target_group.app.arn
    container_name   = var.project
    container_port   = var.container_port
  }
}

# variables.tf
variable "project"     { default = "myapp" }
variable "environment" { default = "staging" }
variable "vpc_cidr"    { default = "10.0.0.0/16" }
variable "app_count"   { default = 2 }
variable "container_port" { default = 3000 }

O Claude Code tambem ajuda com troubleshooting de Terraform. Cole o erro do terraform plan e ele identifica o problema -- permissoes IAM faltando, conflitos de CIDR, recursos que dependem de outros ainda nao criados.

5. Monitoramento e troubleshooting

Alem de criar configuracoes, o Claude Code e excelente para diagnosticar problemas em infraestrutura. Ele analisa logs, identifica padroes de erro e sugere correcoes.

Analisando logs de erro

Configuracao de monitoramento

O Claude Code gera configuracoes completas de monitoramento. Um prompt como "configure Prometheus + Grafana para monitorar este projeto" produz:

# prometheus.yml
global:
  scrape_interval: 15s
  evaluation_interval: 15s

rule_files:
  - "alerts.yml"

alerting:
  alertmanagers:
    - static_configs:
        - targets: ['alertmanager:9093']

scrape_configs:
  - job_name: 'app'
    metrics_path: '/metrics'
    static_configs:
      - targets: ['app:3000']

  - job_name: 'node-exporter'
    static_configs:
      - targets: ['node-exporter:9100']

  - job_name: 'postgres'
    static_configs:
      - targets: ['postgres-exporter:9187']

# alerts.yml
groups:
  - name: app-alerts
    rules:
      - alert: HighErrorRate
        expr: rate(http_requests_total{status=~"5.."}[5m]) > 0.1
        for: 5m
        labels:
          severity: critical
        annotations:
          summary: "Alta taxa de erros 5xx ({{ $value | humanizePercentage }})"

      - alert: HighLatency
        expr: histogram_quantile(0.95, rate(http_request_duration_seconds_bucket[5m])) > 2
        for: 10m
        labels:
          severity: warning
        annotations:
          summary: "P95 latencia acima de 2s"

6. Scripts de deploy automatizados

Scripts de deploy sao criticos -- um erro pode derrubar producao. O Claude Code gera scripts com rollback automatico, health checks e notificacoes.

#!/bin/bash
# deploy.sh -- Deploy com rollback automatico
set -euo pipefail

APP_NAME="myapp"
IMAGE="ghcr.io/myorg/$APP_NAME"
TAG="${1:?Uso: ./deploy.sh }"
HEALTH_URL="https://api.myapp.com/health"
SLACK_WEBHOOK="${SLACK_DEPLOY_WEBHOOK}"

log() { echo "[$(date +'%Y-%m-%d %H:%M:%S')] $1"; }
notify() { curl -s -X POST "$SLACK_WEBHOOK" -d "{\"text\":\"$1\"}" > /dev/null; }

# Salvar tag atual para rollback
CURRENT_TAG=$(docker inspect --format='{{.Config.Image}}' "$APP_NAME" 2>/dev/null | cut -d: -f2 || echo "none")
log "Tag atual: $CURRENT_TAG | Nova tag: $TAG"

# Pull da nova imagem
log "Pulling $IMAGE:$TAG..."
docker pull "$IMAGE:$TAG"

# Deploy
log "Deploying..."
docker stop "$APP_NAME" 2>/dev/null || true
docker rm "$APP_NAME" 2>/dev/null || true
docker run -d --name "$APP_NAME" --restart unless-stopped \
  --env-file .env.production \
  -p 3000:3000 "$IMAGE:$TAG"

# Health check com retry
log "Aguardando health check..."
for i in $(seq 1 30); do
  if curl -sf "$HEALTH_URL" > /dev/null 2>&1; then
    log "Deploy concluido com sucesso!"
    notify "Deploy $APP_NAME:$TAG concluido com sucesso"
    exit 0
  fi
  sleep 2
done

# Rollback
log "ERRO: Health check falhou. Iniciando rollback para $CURRENT_TAG..."
docker stop "$APP_NAME" && docker rm "$APP_NAME"
docker run -d --name "$APP_NAME" --restart unless-stopped \
  --env-file .env.production \
  -p 3000:3000 "$IMAGE:$CURRENT_TAG"
notify "ROLLBACK $APP_NAME para $CURRENT_TAG -- deploy de $TAG falhou"
exit 1

7. Skills de DevOps prontas para usar

Skills sao instrucoes pre-configuradas que transformam o Claude Code em um especialista de DevOps. Em vez de escrever prompts longos toda vez, voce usa uma skill que ja sabe exatamente o que fazer.

Exemplos de skills do Mega Bundle (748+ skills):

Skill	O que faz
/dockerfile	Gera Dockerfile otimizado para o projeto atual com multi-stage build
/github-actions	Cria pipeline CI/CD completa adaptada ao projeto
/terraform-module	Gera modulo Terraform com variables, outputs e state config
/k8s-manifests	Gera Deployment, Service, Ingress e HPA para Kubernetes
/nginx-config	Configura nginx como reverse proxy com SSL e caching
/deploy-script	Script de deploy com rollback, health check e notificacoes
/troubleshoot	Analisa logs de erro e identifica causa raiz

A vantagem de usar skills e a consistencia. Toda vez que voce roda /dockerfile, o resultado segue as mesmas best practices: multi-stage, non-root user, health check, layer caching. Nao depende de voce lembrar de pedir cada detalhe.

8. Boas praticas de seguranca

Usar IA para DevOps exige cuidados extras com seguranca. Siga estas regras:

• Nunca cole secrets no prompt. Use variaveis de ambiente e referencia a secrets managers. O Claude Code entende ${{ secrets.MY_TOKEN }} sem precisar ver o valor real
• Revise antes de aplicar. Sempre rode terraform plan antes de apply. Sempre valide Dockerfiles com hadolint. Sempre teste pipelines em branch de staging primeiro
• Principio do menor privilegio. O Claude Code gera usuarios non-root em Dockerfiles e IAM policies restritivas por padrao -- mas verifique
• Nao confie cegamente. O Claude Code e uma ferramenta de produtividade, nao substitui revisao humana em infraestrutura critica. Use como acelerador, nao como substituto do seu julgamento
• Audit trail. Commit todas as configuracoes de infra no Git. IaC deve ser versionada e revisada via PR, mesmo quando gerada por IA