CtrlK
BlogDocsLog inGet started
Tessl Logo

docker-compose-generator

Generate multi-service Docker Compose files with common stacks (app + DB + Redis + Nginx), volumes, networks, healthchecks, depends_on, environment variables, and profiles.

79

Quality

73%

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

SecuritybySnyk

Risky

Do not use without reviewing

Optimize this skill with Tessl

npx tessl skill review --optimize ./infrastructure/docker-compose-generator/SKILL.md
SKILL.md
Quality
Evals
Security

Docker Compose Generator

Generate multi-service Docker Compose files with common stacks (app + DB + Redis + Nginx), volumes, networks, healthchecks, depends_on, environment variables, and profiles.

Prerequisites

  • Docker Engine >= 24.x
  • Docker Compose V2 (built into Docker CLI)
  • Docker Desktop or colima (macOS)

Scaffold Command

# Initialize a compose file in the project root
touch docker-compose.yml
touch .env

# Optional: create override for local dev
touch docker-compose.override.yml

Project Structure

project-root/
  docker-compose.yml              # Base services (production-like)
  docker-compose.override.yml     # Dev overrides (auto-loaded with docker compose up)
  docker-compose.prod.yml         # Production overrides
  .env                            # Default env vars for compose
  .env.example                    # Committed template
  nginx/
    nginx.conf                    # Reverse proxy config
    certs/                        # Local SSL certs (gitignored)
  docker/
    app/
      Dockerfile                  # Application Dockerfile
    worker/
      Dockerfile                  # Background worker Dockerfile

Key Conventions

  • Use Compose V2 syntax (docker compose, not docker-compose).
  • One docker-compose.yml per project root. Use override files for environment-specific config.
  • Never hardcode secrets in compose files. Use .env files or Docker secrets.
  • Pin image tags explicitly (e.g., postgres:16-alpine, not postgres:latest).
  • Define a custom bridge network so services resolve by name.
  • Use healthchecks on infrastructure services so depends_on.condition: service_healthy works.
  • Use profiles to group optional services (e.g., monitoring, debug tools).

Essential Patterns

Full Stack: Node App + PostgreSQL + Redis + Nginx (docker-compose.yml)

name: myapp

services:
  app:
    build:
      context: .
      dockerfile: docker/app/Dockerfile
      target: development
    ports:
      - "${APP_PORT:-3000}:3000"
    environment:
      NODE_ENV: development
      DATABASE_URL: postgresql://${POSTGRES_USER:-app}:${POSTGRES_PASSWORD:-secret}@db:5432/${POSTGRES_DB:-myapp}
      REDIS_URL: redis://redis:6379
    volumes:
      - .:/app
      - /app/node_modules
    depends_on:
      db:
        condition: service_healthy
      redis:
        condition: service_healthy
    networks:
      - backend

  db:
    image: postgres:16-alpine
    ports:
      - "${DB_PORT:-5432}:5432"
    environment:
      POSTGRES_USER: ${POSTGRES_USER:-app}
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-secret}
      POSTGRES_DB: ${POSTGRES_DB:-myapp}
    volumes:
      - pg_data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER:-app}"]
      interval: 5s
      timeout: 3s
      retries: 5
    networks:
      - backend

  redis:
    image: redis:7-alpine
    ports:
      - "${REDIS_PORT:-6379}:6379"
    command: redis-server --appendonly yes --maxmemory 256mb --maxmemory-policy allkeys-lru
    volumes:
      - redis_data:/data
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 5s
      timeout: 3s
      retries: 5
    networks:
      - backend

  nginx:
    image: nginx:1.27-alpine
    ports:
      - "${NGINX_PORT:-80}:80"
      - "${NGINX_SSL_PORT:-443}:443"
    volumes:
      - ./nginx/nginx.conf:/etc/nginx/nginx.conf:ro
    depends_on:
      - app
    networks:
      - backend

  # Optional services — only start with: docker compose --profile monitoring up
  adminer:
    image: adminer:4
    ports:
      - "8080:8080"
    depends_on:
      - db
    profiles:
      - debug
    networks:
      - backend

  redis-commander:
    image: rediscommander/redis-commander:latest
    environment:
      REDIS_HOSTS: local:redis:6379
    ports:
      - "8081:8081"
    profiles:
      - debug
    networks:
      - backend

volumes:
  pg_data:
  redis_data:

networks:
  backend:
    driver: bridge

Production Override (docker-compose.prod.yml)

services:
  app:
    build:
      target: production
    ports: []
    volumes: []
    environment:
      NODE_ENV: production
    restart: unless-stopped
    deploy:
      resources:
        limits:
          cpus: "1.0"
          memory: 512M

  db:
    ports: []
    restart: unless-stopped

  redis:
    ports: []
    restart: unless-stopped

  nginx:
    restart: unless-stopped

Environment File (.env.example)

# Application
APP_PORT=3000
NODE_ENV=development

# Database
POSTGRES_USER=app
POSTGRES_PASSWORD=secret
POSTGRES_DB=myapp
DB_PORT=5432

# Redis
REDIS_PORT=6379

# Nginx
NGINX_PORT=80
NGINX_SSL_PORT=443

Worker Service Pattern

services:
  worker:
    build:
      context: .
      dockerfile: docker/worker/Dockerfile
    environment:
      DATABASE_URL: postgresql://${POSTGRES_USER:-app}:${POSTGRES_PASSWORD:-secret}@db:5432/${POSTGRES_DB:-myapp}
      REDIS_URL: redis://redis:6379
    depends_on:
      db:
        condition: service_healthy
      redis:
        condition: service_healthy
    restart: unless-stopped
    deploy:
      replicas: 2
    networks:
      - backend

MySQL Variant

services:
  db:
    image: mysql:8.4
    environment:
      MYSQL_ROOT_PASSWORD: ${MYSQL_ROOT_PASSWORD:-rootsecret}
      MYSQL_DATABASE: ${MYSQL_DATABASE:-myapp}
      MYSQL_USER: ${MYSQL_USER:-app}
      MYSQL_PASSWORD: ${MYSQL_PASSWORD:-secret}
    volumes:
      - mysql_data:/var/lib/mysql
    healthcheck:
      test: ["CMD", "mysqladmin", "ping", "-h", "localhost"]
      interval: 5s
      timeout: 3s
      retries: 5
    ports:
      - "${DB_PORT:-3306}:3306"

MongoDB Variant

services:
  mongo:
    image: mongo:7
    environment:
      MONGO_INITDB_ROOT_USERNAME: ${MONGO_USER:-admin}
      MONGO_INITDB_ROOT_PASSWORD: ${MONGO_PASSWORD:-secret}
      MONGO_INITDB_DATABASE: ${MONGO_DB:-myapp}
    volumes:
      - mongo_data:/data/db
    healthcheck:
      test: ["CMD", "mongosh", "--eval", "db.adminCommand('ping')"]
      interval: 5s
      timeout: 3s
      retries: 5
    ports:
      - "${MONGO_PORT:-27017}:27017"

Common Commands

# Start all services (uses docker-compose.yml + docker-compose.override.yml)
docker compose up -d

# Start with debug tools
docker compose --profile debug up -d

# Start with production overrides
docker compose -f docker-compose.yml -f docker-compose.prod.yml up -d

# View logs (follow)
docker compose logs -f app

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

# Stop all services
docker compose down

# Stop and remove volumes (full reset)
docker compose down -v

# Execute command in running container
docker compose exec app sh
docker compose exec db psql -U app myapp

# View service status
docker compose ps

# Scale a service
docker compose up -d --scale worker=3

Integration Notes

  • Dockerfile: Pair with dockerfile-generator skill to create optimized per-language Dockerfiles referenced in build.dockerfile.
  • Nginx: Pair with nginx-config-generator skill for the reverse proxy config mounted into the nginx service.
  • CI/CD: Pair with github-actions-ci skill to build and push images in CI, then deploy with compose on the target host.
  • Kubernetes: For production at scale, migrate compose services to Kubernetes manifests using kubernetes-manifests skill. Compose is best for local dev and small deployments.
  • Secrets: For production, consider Docker Swarm secrets or external secret managers instead of .env files.
Repository
achreftlili/deep-dev-skills
Commit

181fcbc

Last updated
Created

Is this your skill?

If you maintain this skill, you can claim it as your own. Once claimed, you can manage eval scenarios, bundle related skills, attach documentation or rules, and ensure cross-agent compatibility.

Claim skill