Vad är Docker Compose och varför använda det?

Question

Accepted Answer

**Docker Compose** är ett verktyg för att definiera och köra **applikationer med flera behållare** med hjälp av en enda YAML-fil. Istället för att köra många `docker run`-kommandon manuellt beskriver du alla dina tjänster (app, databas, cache) i `docker-compose.yml` och startar dem tillsammans med ett kommando.

## Problemet som Compose löser

```text
A real app often has MULTIPLE containers: a web app + a database + a cache + ...
  → manually running each with docker run (ports, networks, volumes, env, dependencies)
    is tedious, error-prone, and hard to reproduce/share
→ Compose defines the WHOLE stack in one file → start it all with one command.
```

## En docker-compose.yml

```yaml
services:
  web:
    build: .                    # build from the local Dockerfile
    ports:
      - "3000:3000"             # map ports
    environment:
      - DATABASE_URL=postgres://db:5432/myapp
    depends_on:
      - db                       # start db before web
  db:
    image: postgres:16           # use a prebuilt image
    environment:
      - POSTGRES_PASSWORD=secret
    volumes:
      - dbdata:/var/lib/postgresql/data   # persist the database
volumes:
  dbdata:
```

En fil definierar alla tjänster, deras avbildningar/byggen, portar, miljövariabler, volymer och beroenden — och de delar ett nätverk (kan nå varandra via tjänstnamn, t.ex. `db`).

## Köra stacken

```bash
docker compose up -d        # build and start ALL services (in the background)
docker compose ps           # list the running services
docker compose logs -f      # view logs from all services
docker compose down         # stop and remove everything
docker compose down -v      # also remove volumes
```

## Varför det är viktigt

Att förstå Docker Compose är värdefullt eftersom verkliga applikationer nästan alltid involverar **flera behållare**, och Compose är standardverktyget för att hantera dem, så det är viktig praktisk kunskap.

Problemet det löser är verkligt: en typisk applikation har flera tjänster (en webbapp, en databas, en cache, kanske en meddelandekö), och att manuellt köra var och en med separata `docker run`-kommandon — konfigurera portar, nätverk, volymer, miljövariabler och startordning — är tråkigt, felbenäget och svårt att reproducera eller dela. **Compose** löser detta genom att definiera **hela multi-container-stacken i en deklarativ YAML-fil** och starta allt med ett enda kommando (`docker compose up`), vilket gör multi-container-applikationer lätta att köra, reproducera och dela.

Att förstå `docker-compose.yml`-strukturen (definiera tjänster med deras avbildningar/byggen, portar, miljövariabler, volymer och beroenden, med tjänster som automatiskt är nätverkade och kan nås efter namn) och nyckelkommandona (`up`, `down`, `ps`, `logs`) är praktisk, daglig kunskap för utveckling och körning av multi-tjänst-applikationer.

Compose är särskilt värdefullt för **lokala utvecklingsmiljöer** (starta en app med dess databas och beroenden med ett kommando) och för att definiera applikationsstackar reproducerbart.

Eftersom verkliga applikationer vanligtvis är multi-container, och eftersom Docker Compose är standardverktyget, välanvänt verktyg för att definiera och köra dem enkelt (ersätta tråkig manuell orkestrering med en deklarativ fil och ett kommando), är det värdefullt, ofta använt att förstå Docker Compose — vad det löser, compose-filstrukturen och kommandona — för arbete med multi-container-applikationer, en nästan essentiell följeslagare till Docker för all icke-trivial containeriserad applikation och ett allestädes närvarande verktyg i utvecklingsarbetsflöden.