Hva er Docker Compose og hvorfor bruke det?

Question

Accepted Answer

**Docker Compose** er et verktøy for å definere og kjøre **multi-container-applikasjoner** ved hjelp av en enkelt YAML-fil. I stedet for å kjøre mange `docker run`-kommandoer manuelt, beskriver du alle tjenestene dine (app, database, cache) i `docker-compose.yml` og starter dem sammen med én kommando.

## Problemet 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:
```

Én fil definerer alle tjenester, deres images/builds, porter, miljøvariabler, volumer og avhengigheter — og de deler et nettverk (kan nå hverandre ved tjenestenavn, f.eks. `db`).

## Kjøring av 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 er viktig

Å forstå Docker Compose er verdifullt fordi virkelige applikasjoner nesten alltid involverer **flere containere**, og Compose er standardverktøyet for å administrere dem, så det er viktig praktisk kunnskap.

Problemet det løser er reelt: en typisk applikasjon har flere tjenester (en webapplikasjon, en database, en cache, muligens en meldingskø), og det å kjøre hver enkelt manuelt med separate `docker run`-kommandoer — konfigurere porter, nettverk, volumer, miljøvariabler og oppstartrekkefølge — er tidkrevende, feilpotensielt og vanskelig å gjenopprette eller dele. **Compose** løser dette ved å definere **hele multi-container-stacken i én deklarativ YAML-fil** og starte alt med én kommando (`docker compose up`), noe som gjør multi-container-applikasjoner enkle å kjøre, gjenopprette og dele.

Å forstå `docker-compose.yml`-strukturen (definere tjenester med deres images/builds, porter, miljøvariabler, volumer og avhengigheter, med tjenester automatisk knyttet til nettverk og tilgjengelige ved navn) og nøkkelkommandoene (`up`, `down`, `ps`, `logs`) er praktisk, daglig kunnskap for utvikling og kjøring av multi-service-applikasjoner.

Compose er spesielt verdifullt for **lokale utviklingsmiljøer** (spinne opp en app med sin database og avhengigheter med én kommando) og for å definere applikasjonsstacker på en reproduserbar måte.

Siden virkelige applikasjoner typisk består av flere containere, og siden Docker Compose er standardverktøyet som er mye brukt for å definere og kjøre dem enkelt (erstatte kjedelig manuell orkestrering med én deklarativ fil og kommando), er det å forstå Docker Compose — hva det løser, strukturen på compose-filen og kommandoene — verdifull, ofte brukt kunnskap for arbeid med multi-container-applikasjoner, en nær-essensiell ledsager til Docker for enhver ikke-triviell containerisert applikasjon og et allestedsnærværende verktøy i utviklingsarbeidsflyten.