Skip to content

artubss/SKILLS-CLAUDE-CODE / favorites/tpl-devops-docker-compose-dev

tpl-devops-docker-compose-dev

Unverified

Template do pack (devops/04-docker-compose-dev.md). Orienta o agente em infra, deploy, CI/CD e operacao alinhado a esse contexto.

PROJECT: Docker Compose Multi-Service Dev Environment

Skill gerado a partir do pack templates-claude-code. Arquivo de origem: devops/04-docker-compose-dev.md. Use como baseline e adapte ao projeto antes de mudancas grandes.

Conteudo do template

STACK

  • Docker Compose: v3.9 (Compose Specification)
  • Services: Node.js app + PostgreSQL 16 + Redis 7 + Nginx
  • Hot Reload: Nodemon / Vite HMR via bind mounts
  • Environment: .env file (dotenv)
  • Networking: Custom bridge network with DNS service discovery
  • Profiles: dev (all services) / test (app + db only) / prod (override)

FILE STRUCTURE

project/
├── docker-compose.yml          # Base config (shared across envs)
├── docker-compose.override.yml # Dev overrides (auto-loaded)
├── docker-compose.prod.yml     # Prod overrides (explicit)
├── docker-compose.test.yml     # Test overrides
├── .env                        # Local env vars (gitignored)
├── .env.example                # Committed template
├── Dockerfile                  # Multi-stage (dev + prod)
└── nginx/
    ├── nginx.conf
    └── conf.d/
        └── default.conf

ARCHITECTURE RULES

  1. .env is gitignored — .env.example is committed with all keys (values redacted).
  2. Volumes for data, binds for code — named volumes for DB/Redis data; bind mounts for app source.
  3. depends_on with condition: service_healthy — app never starts before DB is truly ready.
  4. Services talk by service name — postgres://postgres:5432/mydb, not localhost.
  5. No hardcoded ports in app code — always use process.env.REDIS_HOST, process.env.DB_HOST.
  6. Dev Dockerfile stage has devDependencies — prod stage does NOT (npm ci --omit=dev).
  7. Health checks on every stateful service — postgres, redis, nginx must have healthcheck.
  8. Resource limits on prod override — do not run unbounded containers in any environment.

BASE COMPOSE FILE

# docker-compose.yml
version: "3.9"

x-common-env: &common-env
  NODE_ENV: ${NODE_ENV:-development}
  LOG_LEVEL: ${LOG_LEVEL:-debug}

services:
  app:
    build:
      context: .
      dockerfile: Dockerfile
      target: ${BUILD_TARGET:-dev}     # dev | prod
    ports:
      - "${APP_PORT:-3000}:3000"
    environment:
      <<: *common-env
      DATABASE_URL: postgresql://${POSTGRES_USER}:${POSTGRES_PASSWORD}@postgres:5432/${POSTGRES_DB}
      REDIS_URL: redis://redis:6379
      PORT: 3000
    depends_on:
      postgres:
        condition: service_healthy
      redis:
        condition: service_healthy
    networks:
      - app-network
    restart: unless-stopped

  postgres:
    image: postgres:16-alpine
    environment:
      POSTGRES_USER:     ${POSTGRES_USER:-appuser}
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-changeme}
      POSTGRES_DB:       ${POSTGRES_DB:-appdb}
    volumes:
      - postgres-data:/var/lib/postgresql/data
      - ./db/init:/docker-entrypoint-initdb.d:ro   # Init SQL scripts
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER:-appuser} -d ${POSTGRES_DB:-appdb}"]
      interval: 5s
      timeout: 5s
      retries: 10
      start_period: 10s
    networks:
      - app-network
    restart: unless-stopped

  redis:
    image: redis:7-alpine
    command: >
      redis-server
      --requirepass ${REDIS_PASSWORD:-changeme}
      --maxmemory 256mb
      --maxmemory-policy allkeys-lru
    volumes:
      - redis-data:/data
    healthcheck:
      test: ["CMD", "redis-cli", "-a", "${REDIS_PASSWORD:-changeme}", "ping"]
      interval: 5s
      timeout: 3s
      retries: 5
    networks:
      - app-network
    restart: unless-stopped

  nginx:
    image: nginx:1.25-alpine
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx/nginx.conf:/etc/nginx/nginx.conf:ro
      - ./nginx/conf.d:/etc/nginx/conf.d:ro
      - nginx-cache:/var/cache/nginx
    depends_on:
      app:
        condition: service_started
    healthcheck:
      test: ["CMD", "nginx", "-t"]
      interval: 30s
      timeout: 5s
      retries: 3
    networks:
      - app-network
    restart: unless-stopped

networks:
  app-network:
    driver: bridge
    ipam:
      config:
        - subnet: 172.20.0.0/16

volumes:
  postgres-data:
    driver: local
  redis-data:
    driver: local
  nginx-cache:
    driver: local

DEV OVERRIDE (auto-loaded)

# docker-compose.override.yml
services:
  app:
    build:
      target: dev
    volumes:
      # Hot reload: bind-mount source into container
      - ./src:/app/src:delegated
      - ./package.json:/app/package.json:ro
      - ./tsconfig.json:/app/tsconfig.json:ro
      # Preserve container's node_modules (NOT bind-mounted)
      - app-node-modules:/app/node_modules
    command: npm run dev          # nodemon or ts-node-dev
    environment:
      CHOKIDAR_USEPOLLING: "true"    # Needed on Windows/WSL2
      WATCHPACK_POLLING: "true"      # For webpack/vite in WSL2

  postgres:
    ports:
      - "5432:5432"   # Expose in dev for DBeaver/psql access

  redis:
    ports:
      - "6379:6379"   # Expose in dev for Redis Insight

volumes:
  app-node-modules:

PRODUCTION OVERRIDE

# docker-compose.prod.yml
# Usage: docker compose -f docker-compose.yml -f docker-compose.prod.yml up -d
services:
  app:
    build:
      target: prod
    restart: always
    deploy:
      resources:
        limits:
          cpus: '0.5'
          memory: 512M
        reservations:
          cpus: '0.25'
          memory: 256M
    logging:
      driver: "json-file"
      options:
        max-size: "10m"
        max-file: "3"

  postgres:
    # Do NOT expose ports in production
    deploy:
      resources:
        limits:
          memory: 1G

  redis:
    deploy:
      resources:
        limits:
          memory: 512M

MULTI-STAGE DOCKERFILE

# Dockerfile
FROM node:20-alpine AS base
WORKDIR /app
RUN addgroup -S appgroup && adduser -S appuser -G appgroup

# --- Dependencies stage ---
FROM base AS deps
COPY package*.json ./
RUN npm ci

# --- Development stage ---
FROM deps AS dev
ENV NODE_ENV=development
COPY . .
USER appuser
CMD ["npm", "run", "dev"]

# --- Build stage ---
FROM deps AS builder
COPY . .
RUN npm run build

# --- Production stage ---
FROM base AS prod
ENV NODE_ENV=production
COPY --from=builder /app/dist ./dist
COPY --from=builder /app/package*.json ./
RUN npm ci --omit=dev && npm cache clean --force
USER appuser
EXPOSE 3000
HEALTHCHECK --interval=30s --timeout=5s --start-period=10s --retries=3 \
  CMD wget -qO- http://localhost:3000/healthz || exit 1
CMD ["node", "dist/server.js"]

.ENV.EXAMPLE

# .env.example — commit this, NOT .env
NODE_ENV=development
APP_PORT=3000

POSTGRES_USER=appuser
POSTGRES_PASSWORD=changeme_dev
POSTGRES_DB=appdb

REDIS_PASSWORD=changeme_dev

LOG_LEVEL=debug

# JWT_SECRET=         ← fill in .env
# OPENAI_API_KEY=     ← fill in .env

COMMON COMMANDS

# Start all services (dev)
docker compose up -d

# Tail logs
docker compose logs -f app

# Exec into running container
docker compose exec app sh

# Run one-off command (migrations)
docker compose run --rm app npm run db:migrate

# Rebuild after Dockerfile changes
docker compose up -d --build

# Production deployment
docker compose -f docker-compose.yml -f docker-compose.prod.yml up -d --build

# Full teardown (keeps volumes)
docker compose down

# Nuke everything including volumes (danger)
docker compose down -v

NGINX REVERSE PROXY CONFIG

# nginx/conf.d/default.conf
upstream app_backend {
    server app:3000;
    keepalive 32;
}

server {
    listen 80;
    server_name _;

    location /healthz {
        proxy_pass http://app_backend;
        access_log off;
    }

    location / {
        proxy_pass http://app_backend;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_cache_bypass $http_upgrade;
        client_max_body_size 10M;
    }
}
writing-skillsobra/superpowersUse when creating new skills, editing existing skills, or verifying skills work before deploymentStars: 318kUpdated Claude CodeCodexUnverifiedInstall
xlsxanthropics/skillsUse this skill any time a spreadsheet file is the primary input or output. This means any task where the user wants to: open, read, edit, or fix an existing .xlsx, .xlsm, .xltx, .csv, or .tsv file (e.g., adding columns, computing formulas, formatting, charting, cleaning messy data); create a new spreadsheet from scratch or from other data sources; or convert between tabular file formats. Trigger especially when the user references a spreadsheet file by name or path — even casually (like "the xlsx in my downloads") — and wants something done to it or produced from it. Also trigger for cleaning or restructuring messy tabular data files (malformed rows, misplaced headers, junk data) into proper spreadsheets. The deliverable must be a spreadsheet file. Do NOT trigger when the primary deliverable is a Word document, HTML report, standalone Python script, database pipeline, or Google Sheets API integration, even if tabular data is involved.Stars: 196kUpdated Claude CodeCodexVerifiedInstall
shipping-and-launchaddyosmani/agent-skillsPrepares production launches. Use when preparing to deploy to production, or when asking what needs to be in place before shipping. Use when you need a pre-launch checklist, when setting up monitoring, when planning a staged rollout, or when you need a rollback strategy.Stars: 118kUpdated Claude CodeCodexVerifiedInstall
childhoodthedotmack/claude-memBabysit a shipped release after merge, publication, or deployment. Verify published packages, production behavior, installed plugins, and late CI or user reports until the observation window is clean; use babysit for PR readiness before release.Stars: 117kUpdated Claude CodeCodexUnverifiedInstall