# Docker Compose för webbutveckling – Enkel guide till att containerisera hela din stack

*Camilla Sundh*
*17 november 2026*

> Lär dig hur Docker Compose används för att köra hela din webbutvecklingsstack lokalt med enkla docker-compose.yml-filer och kommandon.

# Docker Compose för webbutveckling – Komplett guide till att containerisera hela din stack

Docker Compose för webbutveckling är ett verktyg som gör det enkelt att definiera och köra flera Docker-containrar som en grupp. För webbutveckling är Docker Compose för webbutveckling ett oumbärligt verktyg som låter dig återskapa produktionsmiljön lokalt med en enda konfigurationsfil.

## Vad är Docker Compose för webbutveckling?

Docker Compose är en del av Docker-ekosystemet som låter dig definiera en applikation med flera containrar i en YAML-fil. Du kan sedan starta alla tjänster med ett enda kommando. Detta är perfekt för webbutveckling då du ofta behöver en webbserver, en databas och kanske en message broker som alla måste samverka.

I stället för att starta varje container separat med `docker run` beskriver du hela miljön i en fil, `docker-compose.yml`. Sedan startar du allt med `docker compose up`. Alla containrar startas tillsammans och kan kommunicera med varandra via ett internt nätverk som Docker skapar automatiskt.

## Grundläggande syntax i docker-compose.yml

Modern Docker Compose fungerar utan ett versionsfält högst upp i din fil. Äldre Compose-versioner använde ett `version:`-fält i samma fil för att ange vilken syntaxstandard som gällde, men dagens docker compose-kommando kräver det inte längre. Du kan definiera tjänster och deras konfigurationer direkt.

Här är ett praktiskt exempel:

```yaml
services:
  web:
    build: .
    ports:
      - "3000:3000"
```

`services`-avsnittet innehåller varje tjänst i din stack. Varje tjänst kan ha egna inställningar för image, bygg, portar, volymer och miljövariabler.

### Viktiga nyckelord i docker-compose.yml

- `image` – vilken Docker-image som ska användas för tjänsten
- `build` – sökväg till Dockerfile om containern ska byggas från din egen kod
- `ports` – vilka portar som ska mappas mellan din dator och containern
- `volumes` – mappar som ska delas mellan din dator och containern
- `environment` – miljövariabler som sätts inuti containern
- `depends_on` – anger vilka andra tjänster som måste starta först

## Exempel: Node.js och MongoDB med Docker Compose för webbutveckling

En mycket vanlig webbutvecklingsstack är ett Node.js API som kommunicerar med en MongoDB-databas. Med Docker Compose för webbutveckling kan du köra båda tjänsterna lokalt utan att installera Node eller MongoDB direkt på din dator.

Här är ett komplett exempel:

```yaml
services:
  web:
    build: .
    ports:
      - "3000:3000"
    volumes:
      - .:/app
    environment:
      - NODE_ENV=development
    depends_on:
      - mongo

  mongo:
    image: mongo:7
    ports:
      - "27017:27017"
    volumes:
      - mongodb_data:/data/db

volumes:
  mongodb_data:
```

Denna konfiguration definierar två tjänster:

1. `web` – en webbserver som byggs från din Dockerfile i projektets rot. Port 3000 på din dator mappar till port 3000 i containern. Koden delas via en volym så att ändringar du gör i koden syns direkt i containern. `depends_on` ser till att databasen startar före webbservern.
2. `mongo` – en officiell MongoDB-container som lyssnar på port 27017. Datan sparas i en namngiven volym så att den inte försvinner när containern stoppas eller tas bort.

Med den här konfigurationen kan du köra `docker compose up` och få igång både API:et och databasen på några sekunder, med exakt samma versioner som ni använder i teamet.

## Byggsteg i Docker Compose

1. **Skapa en Dockerfile** – definierar hur varje container ska byggas, vilket operativsystem den ska baseras på och vilka beroenden som ska installeras.
2. **Skapa en docker-compose.yml** – beskriver kommunikationen mellan containrarna, vilka portar som ska öppnas och vilka miljövariabler som ska sättas.
3. **Kör `docker compose up`** – startar alla tjänster samtidigt. Docker läser konfigurationsfilen, bygger images som behövs och startar varje container i rätt ordning.
4. **Kör `docker compose down`** – stoppar och tar bort containrarna, nätverken och eventuella volymer som du har markerat för borttagning.

## Vanliga kommandon i Docker Compose

Här är de kommandon du använder mest i vardagen:

- `docker compose up` – startar alla tjänster i förgrunden så att du ser loggarna direkt i terminalen
- `docker compose up -d` – startar alla tjänster i bakgrunden (detached mode) så att du kan fortsätta arbeta i samma terminalfönster
- `docker compose down` – stoppar och tar bort containrar, nätverk och volymer som skapades av `up`
- `docker compose logs -f` – visar loggarna från alla tjänster i realtid och följer dem löpande
- `docker compose exec web bash` – öppnar en terminalsession inne i webbcontainern så att du kan köra kommandon där
- `docker compose ps` – visar vilka tjänster som körs, deras status och vilka portar de lyssnar på

## Miljövariabler och .env-filer

I stället för att hårdkoda lösenord, API-nycklar och andra inställningar direkt i docker-compose.yml kan du lagra dem i en separat `.env`-fil i projektets rot:

```
MONGO_INITDB_ROOT_USERNAME=root
MONGO_INITDB_ROOT_PASSWORD=hemligt123
```

Sedan refererar du till variablerna i YAML-filen:

```yaml
environment:
  - MONGO_INITDB_ROOT_USERNAME=${MONGO_INITDB_ROOT_USERNAME}
  - MONGO_INITDB_ROOT_PASSWORD=${MONGO_INITDB_ROOT_PASSWORD}
```

Detta håller känsliga värden utanför versionshanteringen och gör det enkelt att byta miljö utan att redigera konfigurationsfilen.

## Komplett guide till Docker Compose för webbutveckling

Docker Compose gör det möjligt att ha exakt samma konfiguration lokalt som i produktion. Detta minskar "det fungerar inte hos mig"-problemen och sparar tid under utvecklingen. Alla i teamet får samma databasversion, samma webbserver och samma miljövariabler, oavsett vilken dator de använder.

För webbutveckling innebär det att du kan börja koda direkt utan att spendera timmar på att ställa in databaser, cache-servrar och köhanterare manuellt. Du checkar ut projektet, kör ett kommando och har hela stacken igång.

## Vanliga frågor om Docker Compose för webbutveckling

### Hur bygger jag om containrarna efter kodändringar?

Kör `docker compose up --build` så byggs om alla images som har förändrats innan de startas. Detta är användbart när du har uppdaterat beroenden eller ändrat i Dockerfile.

### Kan jag köra olika tjänster i samma fil?

Ja, du definierar valfritt antal tjänster under `services`. Det kan vara webbserver, databas, cache, köhanterare, samt en webbserver för frontend. Alla tjänster kan kommunicera med varandra via tjänstens namn som värdnamn.

### Hur tar jag bort volymer tillsammans med containrarna?

Använd `docker compose down -v` för att också ta bort de namngivna volymerna. Detta är användbart om du vill börja om med en tom databas eller rensa gammal testdata.

### Fungerar Docker Compose på Windows och Mac?

Ja, med Docker Desktop finns Docker Compose tillgängligt på alla större plattformar: Windows, macOS och Linux. Kommandona är desamma oavsett operativsystem.

### Behöver jag installera Docker och Docker Compose separat?

Nej, med modern Docker Desktop är Docker Compose inbyggt. Du kör `docker compose` (med mellanrum, inte bindestreck) och det fungerar direkt.

## Sammanfattning

Docker Compose för webbutveckling är ett oumbärligt verktyg för webbutvecklare som vill arbeta i isolerade, återupptagbara miljöer. Med en enda `docker-compose.yml`-fil definierar du hela stacken och kommer igång på några sekunder, oavsett om du bygger ett litet projekt eller en stor applikation med många tjänster. Det sparar tid, minskar fel och gör samarbetet i teamet enklare eftersom alla arbetar i exakt samma miljö.
