Docker Compose Generator

The Docker Compose Generator creates docker-compose.yml files for multi-container applications. Instead of writing YAML by hand (with its infamous whitespace traps), pick services from a menu — Postgres, MySQL, Redis, MongoDB, Elasticsearch, nginx, Apache, Node.js app, Python app, PHP-FPM, RabbitMQ, Kafka, etc. — configure their ports, volumes, environment variables, and dependencies, and get a valid compose.yaml ready to run with docker compose up. Supports current Compose V2 specification, proper networking setup, named volumes for data persistence, healthchecks, and restart policies.

Docker Compose is the standard way to define development and staging environments with multiple services. A typical web app needs: your app server, a database, a cache, maybe a message queue. Running all these manually with docker run is error-prone. A compose file defines them declaratively, starts them together (docker compose up), stops together (docker compose down), and reproduces identical environments for every developer. This generator makes it trivial to set up LAMP stacks, MEAN stacks, WordPress + MySQL + Redis, Django + Postgres + Celery + Redis, and any other common combination.

Docker Compose is a tool for defining and running multi-container Docker applications. The Compose Specification is the open standard (https://compose-spec.io/). Docker Compose V2 (2021+) implements it.

File structure:

```yaml
version: "3.8" # Optional in V2

services:
web:
image: nginx:alpine
ports:
- "80:80"
volumes:
- ./html:/usr/share/nginx/html:ro
depends_on:
- api
networks:
- frontend

api:
build: ./api
environment:
DATABASE_URL: postgres://user:pass@db:5432/mydb
ports:
- "3000:3000"
depends_on:
db:
condition: service_healthy
networks:
- frontend
- backend

db:
image: postgres:16
environment:
POSTGRES_USER: user
POSTGRES_PASSWORD: pass
POSTGRES_DB: mydb
volumes:
- db-data:/var/lib/postgresql/data
networks:
- backend
healthcheck:
test: ["CMD-SHELL", "pg_isready -U user"]
interval: 10s
timeout: 5s
retries: 5

volumes:
db-data:

networks:
frontend:
backend:
```

Key concepts:

Services — individual containers. Each gets an image (from registry) or build (from Dockerfile). Services can communicate by name on shared networks.

Networks — how services talk to each other. Default: all services on a shared network named after the project. Explicit networks allow isolation (frontend vs backend).

Volumes — persistent storage. Without a volume, container data disappears on restart.
- Named volumes: db-data:/var/lib/postgresql/data — Docker manages the location.
- Bind mounts: ./html:/usr/share/nginx/html — maps host directory to container.

Environment variables — passed to containers:
- environment: block — literal values in YAML (risky for secrets).
- env_file: .env — from a file.
- ${VAR} interpolation — from shell env or .env file.

depends_on — startup order and health waiting:
- Basic: depends_on: [db] — start db first but do not wait for health.
- Health-based: depends_on: db: condition: service_healthy — wait until db healthcheck passes.

Healthchecks — containers report their health:
``yaml
healthcheck:
test: ["CMD", "curl", "-f", "http://localhost/"]
interval: 30s
timeout: 10s
retries: 3
start_period: 40s
``

Ports — expose container port to host:
- "80:80" — host 80 to container 80.
- "127.0.0.1:80:80" — only on localhost.
- Without host mapping — available only to other containers on the network.

Restart policies:

- no (default) — do not restart.
- always — restart always.
- on-failure — restart only on non-zero exit.
- unless-stopped — restart unless explicitly stopped.

For production: unless-stopped is most common.

Build:

``yaml
build:
context: ./api
dockerfile: Dockerfile.dev
args:
NODE_ENV: development
``

Or simply build: ./api using default Dockerfile.

Profiles (for optional services):

``yaml
services:
db:
profiles: ["production"]
``

docker compose --profile production up activates this profile.

Compose V1 vs V2:

V1: docker-compose up (hyphen). V2: docker compose up (space). V2 is plugin for Docker CLI, faster, more features. V2 is the current default.

Docker Compose vs Docker run commands: docker run for individual containers; Compose for multi-container apps. Compose is declarative (YAML) while docker run is imperative (shell). Compose reproducible across machines.

Docker Compose vs Kubernetes: Compose is for development and small deployments. Kubernetes is for production-grade orchestration with auto-scaling, self-healing, distributed across many nodes. Start with Compose; migrate to K8s when you need its features.

Docker Compose vs Docker Swarm: Docker Swarm is Docker native orchestration — works across multiple hosts. Less popular than K8s now but simpler. Compose works locally; Swarm scales to multi-host.

Compose V1 vs V2: V2 is the current standard. V1 (docker-compose binary) is deprecated. V2 is a Docker CLI plugin (docker compose) — faster, more features. All new work should use V2.

compose.yaml vs docker-compose.yml: Current spec prefers compose.yaml (or compose.yml) as the filename. Old convention was docker-compose.yml. Both work; use compose.yaml for new projects.

Development vs production compose files: Convention: compose.yaml is the base. compose.override.yml (auto-applied for development). compose.prod.yml (explicit for production: docker compose -f compose.yaml -f compose.prod.yml up). Separates dev conveniences from production config.