Docker för utvecklare: Från noll till produktion

Docker löser ett problem som alla utvecklare har haft: "Det fungerar på min dator." Genom att paketera din applikation med alla dess beroenden i en container som körs identiskt överallt eliminerar Docker den klassen av problem helt.

Den här guiden är skriven för utvecklare som vill använda Docker i sitt dagliga arbete — inte för de som vill bli DevOps-ingenjörer. Fokus ligger på det du behöver veta, inte på allt som finns att veta.

Containers vs virtuella maskiner

En container är inte en VM. En VM kör ett helt operativsystem ovanpå ditt befintliga. En container delar värdoperativsystemets kernel men isolerar filsystem, nätverk och processer. Resultatet: containers startar på sekunder (inte minuter), använder en bråkdel av minnet och tar minimalt med diskutrymme.

# Installera Docker Desktop (macOS/Windows)
# https://www.docker.com/products/docker-desktop

# Verifiera installation
docker --version    # Docker version 27.x
docker compose version  # Docker Compose v2.x

# Kör din första container
docker run hello-world

# Kör en interaktiv Ubuntu-container
docker run -it ubuntu bash
# Du är nu "inuti" en isolerad Ubuntu-miljö
# exit för att avsluta

# Lista körande containers
docker ps

# Lista alla containers (inkl. stoppade)
docker ps -a

Dockerfile — beskriv din applikation

En Dockerfile är receptet för att bygga en container-image av din applikation. Varje instruktion skapar ett lager som cachas — så ordningen spelar roll för build-prestanda.

# Dockerfile för en Node.js-applikation
FROM node:22-alpine AS base

# Sätt arbetskatalog
WORKDIR /app

# Kopiera package.json FÖRST (cachas separat)
COPY package.json package-lock.json ./
RUN npm ci --production

# Kopiera resten av koden
COPY . .

# Bygg applikationen
RUN npm run build

# Exponera port
EXPOSE 3000

# Startkommando
CMD ["node", "dist/server.js"]

# Multi-stage build — mindre slutimage
FROM node:22-alpine AS builder
WORKDIR /app
COPY package.json package-lock.json ./
RUN npm ci
COPY . .
RUN npm run build

# Produktionsimage — bara det nödvändiga
FROM node:22-alpine AS runner
WORKDIR /app

# Skapa non-root användare
RUN addgroup --system app && adduser --system --ingroup app app

# Kopiera bara det som behövs från builder
COPY --from=builder /app/dist ./dist
COPY --from=builder /app/node_modules ./node_modules
COPY --from=builder /app/package.json ./

USER app
EXPOSE 3000
CMD ["node", "dist/server.js"]

# Builder: ~500 MB (med dev dependencies + källkod)
# Runner: ~150 MB (bara produktion)

Multi-stage builds är en av Dockers bästa features. Du bygger i en stor image med alla verktyg, men slutresultatet innehåller bara det som behövs för att köra.

docker-compose — flera tjänster

De flesta applikationer behöver mer än en tjänst: en webbserver, en databas, kanske en Redis-cache. docker-compose.yml beskriver hela stacken och startar allt med ett kommando.

# docker-compose.yml
services:
  app:
    build: .
    ports:
      - "3000:3000"
    environment:
      DATABASE_URL: postgres://user:pass@db:5432/myapp
      REDIS_URL: redis://cache:6379
    depends_on:
      db:
        condition: service_healthy
      cache:
        condition: service_started
    volumes:
      - ./src:/app/src  # Hot reload i utveckling

  db:
    image: postgres:16-alpine
    environment:
      POSTGRES_USER: user
      POSTGRES_PASSWORD: pass
      POSTGRES_DB: myapp
    ports:
      - "5432:5432"
    volumes:
      - pgdata:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U user"]
      interval: 5s
      timeout: 5s
      retries: 5

  cache:
    image: redis:7-alpine
    ports:
      - "6379:6379"

volumes:
  pgdata:

# Starta hela stacken
docker compose up

# Starta i bakgrunden
docker compose up -d

# Se loggar
docker compose logs -f app

# Stoppa allt
docker compose down

# Stoppa och radera volymer (databas-data)
docker compose down -v

# Bygg om efter kodändringar
docker compose up --build

Vanliga Docker-kommandon

De här kommandona använder du dagligen som utvecklare.

# Bygga images
docker build -t myapp:latest .
docker build -t myapp:v2.0 -f Dockerfile.prod .

# Köra containers
docker run -p 3000:3000 myapp:latest
docker run -d --name myapp -p 3000:3000 myapp:latest
docker run -it --rm myapp:latest sh  # Interaktiv shell

# Inspektera
docker logs myapp
docker logs -f myapp          # Följ loggar
docker stats                   # CPU/minne per container

# Felsökning — gå in i körande container
docker exec -it myapp sh

# Rensa
docker system prune            # Ta bort oanvända resurser
docker image prune -a          # Ta bort oanvända images
docker volume prune            # Ta bort oanvända volymer

Utvecklingsmiljö med Docker

Docker i utveckling handlar om att eliminera "works on my machine"-problemet. Ny teammedlem? docker compose up och allt fungerar. Inga manuella installationer av PostgreSQL, Redis, Elasticsearch eller andra beroenden.

Tips: Använd volymer för att mounta din källkod i containern. Då får du hot reload utan att behöva bygga om imagen vid varje ändring. Kombinera med nodemon eller Vites dev-server för en smidig utvecklingsupplevelse.

Tips: Ha separata Dockerfiler för utveckling och produktion.Dockerfile för produktion (optimerad, multi-stage) och Dockerfile.dev för utveckling (med dev dependencies och debug-verktyg).

Läs mer om deployment och DevOps i vår webbutvecklingsguide, eller fördjupa dig i Python med vår Python-guide.