Hvad er Docker Compose, og hvorfor bruge det?

Question

Accepted Answer

**Docker Compose** er et værktøj til at definere og køre **multi-container-applikationer** ved hjælp af en enkelt YAML-fil. I stedet for manuelt at køre mange `docker run`-kommandoer beskriver du alle dine tjenester (app, database, cache) i `docker-compose.yml` og starter dem sammen med en 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 definerer alle tjenester, deres images/builds, porte, miljø, volumes og afhængigheder — og de deler et netværk (når de nås hinanden efter tjenestenavn, f.eks. `db`).

## Kørsel af 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
```

## Hvorfor det betyder noget

At forstå Docker Compose er værdifuldt, fordi rigtige applikationer næsten altid involverer **flere containere**, og Compose er standardværktøjet til at administrere dem, så det er vigtig praktisk viden.

Det problem, som det løser, er reelt: en typisk applikation har flere tjenester (en webapp, en database, en cache, måske en message queue), og manuelt at køre hver med separate `docker run`-kommandoer — konfigurering af porte, netværk, volumes, miljøvariabler og opstartningsrækkefølge — er kedelig, fejlprone og svær at reproducere eller dele. **Compose** løser dette ved at definere **hele multi-container-stacken i en enkelt deklarativ YAML-fil** og starte det hele med en enkelt kommando (`docker compose up`), hvilket gør multi-container-applikationer nemme at køre, reproducere og dele.

At forstå strukturen af `docker-compose.yml` (definition af tjenester med deres images/builds, porte, miljø, volumes og afhængigheder, med tjenester automatisk knyttet til netværk og tilgængelige efter navn) og de vigtigste kommandoer (`up`, `down`, `ps`, `logs`) er praktisk, daglig viden til udvikling og til at køre applikationer med flere tjenester.

Compose er især værdifuldt til **lokale udvikling-miljøer** (spinning up af en app med dens database og afhængigheder i en kommando) og til at definere applikationsstacks reproducerbart.

Da rigtige applikationer typisk er multi-container, og da Docker Compose er standardværktøjet, der er udbredt, til at definere og køre dem enkelt (udskifter kedelig manuel orkestrering med en enkelt deklarativ fil og kommando), er det værdifuldt, hyppigt anvendt viden at forstå Docker Compose — hvad det løser, compose-filstrukturen og kommandoerne — for arbejde med multi-container-applikationer, en næsten uundværlig ledsager til Docker til enhver ikke-triviel containeriseret applikation og et allestedsnærværende værktøj i udviklerworkflows.