Docker för utvecklare: Kom igång med containerteknik

Docker har revolutionerat sättet vi utvecklar, distribuerar och kör applikationer. 2026 är containrar inte längre en trend — de är standarden för att paketera och leverera mjukvara. Oavsett om du bygger en liten webbapplikation eller en komplex mikrotjänstarkitektur ger Docker dig förmågan att köra din kod exakt likadant på din utvecklingsmaskin, i CI/CD-pipelinen och i produktion.

Den här guiden tar dig från noll till produktionsredo Docker-användare på en eftermiddag. Vi börjar med installation och grundläggande koncept, bygger vår första container, skapar en Dockerfile, använder docker-compose för flertjänstapplikationer, och avslutar med tips för CI/CD och felsökning. Varje avsnitt innehåller praktiska exempel du kan köra direkt.

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

Docker är en plattform för att utveckla, leverera och köra applikationer i isolerade miljöer som kallas containrar. En container är som en lättviktig virtuell maskin — den har sitt eget filsystem, nätverk och processutrymme — men den delar operativsystemets kärna med värden. Det gör containrar mycket snabbare och mer resurseffektiva än traditionella virtuella maskiner.

Fördelarna med Docker är många: reproducerbara miljöer (ingen mer "det fungerar på min maskin"), snabb uppstart (millisekunder i stället för minuter), effektiv resursanvändning, och enkel skalning. Docker images är versionshanterade och kan delas via register som Docker Hub, vilket gör samarbete och distribution trivialt. För svenska utvecklingsteam innebär Docker att onboarding av nya utvecklare går från dagar till minuter — allt är redan konfigurerat i containern.

Installera Docker

Docker finns för Windows, macOS och Linux. Installationen varierar beroende på plattform:

• Windows: Ladda ner Docker Desktop från docker.com och installera. Docker Desktop kräver WSL2 (Windows Subsystem for Linux) för bästa prestanda — installationen guidar dig genom detta. Efter installation startar du Docker Desktop och väntar på att motorn ska bli grön.
• macOS: Ladda ner Docker Desktop för Mac (både Intel och Apple Silicon stöds). Installationen är enkel — dra applikationen till mappen Program och starta den.
• Linux: Installera via pakethanteraren: sudo apt install docker.io (Debian/Ubuntu) eller sudo dnf install docker (Fedora). Starta med sudo systemctl start docker och aktivera med sudo systemctl enable docker.

Efter installation kontrollerar du att allt fungerar med docker --version. För att undvika att behöva använda sudo på Linux lägger du till din användare i docker-gruppen: sudo usermod -aG docker $USER och loggar ut och in igen.

Docker grundläggande kommandon

Innan vi dyker in i att bygga egna images är det viktigt att förstå de grundläggande Docker-kommandona. Här är de viktigaste:

• docker pull <image> — ladda ner en image från ett register (t.ex. docker pull ubuntu:latest).
• docker run <image> — skapa och starta en container från en image. Lägg till -d för detach (bakgrund), --name för ett eget namn.
• docker ps — lista aktiva containrar. docker ps -a visar alla containrar, även stoppade.
• docker stop <container> — stoppa en container.
• docker rm <container> — ta bort en container.
• docker images — lista alla nedladdade images.
• docker rmi <image> — ta bort en image.
• docker logs <container> — visa loggar från en container.
• docker exec -it <container> bash — öppna en shell inuti en container.

Prova att köra docker run hello-world. Det är det enklaste sättet att verifiera att Docker fungerar korrekt — du får en hälsning från Docker som bekräftar att installationen är lyckad.

Din första container: Hello World i webbläsaren

Låt oss starta en riktig webbserver i en container. Kör följande kommando:

Detta laddar ner den officiella Nginx-image (alpine-varianten, cirka 20 MB), startar en container i bakgrunden (-d), mappar port 8080 på din dator till port 80 i containern (-p 8080:80), och ger containern namnet min-nginx. Öppna http://localhost:8080 i din webbläsare — du bör se Nginx-välkomstsida.

Stoppa och ta bort containern med docker stop min-nginx && docker rm min-nginx. Detta är grundmönstret för allt Docker-arbete: hämta en image, starta en container med rätt konfiguration, och städa upp när du är klar.

Dockerfile — bygg din egen image

En Dockerfile är ett recept för att bygga en Docker-image. Den innehåller instruktioner för vilket operativsystem som ska användas, vilka filer som ska kopieras, vilka kommandon som ska köras och hur applikationen startas. Här är en enkel Dockerfile för en Node.js-applikation:

Raderna betyder: FROM anger bas-image (Node.js 22 på Alpine Linux), WORKDIR skapar och byter till arbetskatalogen, COPY kopierar först package-filer för att utnyttja Dockers lager-cache, RUN installerar beroenden, COPY kopierar resten av källkoden, EXPOSE dokumenterar vilken port applikationen lyssnar på, och CMD anger vilket kommando som körs när containern startar.

Bygg imagen med docker build -t min-app . och kör den med docker run -p 3000:3000 min-app. Du har nu byggt din första egna Docker-image!

Multi-stage builds — håll imagerna små

När du bygger images är det lätt att de blir stora — speciellt om du inkluderar byggverktyg som TypeScript-kompilatorn eller webpack. Multi-stage builds låter dig använda flera FROM-uttryck och bara kopiera över det som behövs i slutimagen:

Slutimagen innehåller bara det som behövs för att köra applikationen — inte TypeScript-källkod, dev-dependencies eller byggverktyg. För en typisk Node.js-app minskar detta image-storleken från 1,5 GB till under 200 MB.

docker-compose — flera tjänster i en fil

De flesta applikationer består av flera tjänster: en webbserver, en databas, en cache, kanske en köhanterare. Docker Compose låter dig definiera alla tjänster i en enda YAML-fil och starta allt med ett kommando. Skapa en docker-compose.yml:

Starta allt med docker compose up -d. Du får en webbserver och en PostgreSQL-databas som kan prata med varandra via nätverket som Compose automatiskt skapar. Stoppa med docker compose down — datan i volymen pgdata sparas för nästa uppstart.

Volymer — spara data mellan omstarter

Containrar är i grunden temporära — när du tar bort en container försvinner all data som skapats inuti den. För att spara data använder du volymer (volumes) eller bind mounts. Volymer hanteras av Docker och lagras på värden i en speciell katalog. Bind mounts mappar en katalog från värden direkt in i containern.

Skapa en namngiven volym med docker volume create min-data och använd den: docker run -v min-data:/data .... För bind mounts använder du en absolut sökväg: docker run -v /absolute/path:/data .... Bind mounts är utmärkta under utveckling — du kan monta din källkod och se ändringar i realtid utan att bygga om imagen.

I docker-compose definierar du volymer på toppnivå och refererar dem under volumes: för varje tjänst. Docker Compose skapar automatiskt volymerna och hanterar livscykeln.

Docker-nätverk — få containrar att prata med varandra

Docker skapar automatiskt nätverk för att isolera containrar. Som standard kan containrar på samma nätverk hitta varandra via DNS-namn (containernamnet). Du kan skapa egna nätverk: docker network create mitt-nat och koppla containrar till dem med --network mitt-nat.

Docker Compose skapar ett standardnätverk för alla tjänster i filen, så tjänsterna kan referera varandra med sina service-namn (db, app, etc.). För produktion vill du ofta ha flera nätverk — ett för publika tjänster (webbservern) och ett internt för databasen, så att databasen inte är direkt exponerad.

Portmappning med -p eller ports: i compose-filen gör containerns portar tillgängliga på värdmaskinen. Utan portmappning är containern bara åtkomlig inom Docker-nätverket.

Docker Hub och privata register

Docker Hub är det största publika registret för Docker-images. Du kan ladda upp dina egna images med docker push ditt-anvandarnamn/min-app:tag efter att ha loggat in med docker login. Taggar används för versionshantering — använd semantisk versionsnumrering (1.2.3) eller Git-hash för spårbarhet.

För svenska företag som behöver följa GDPR och lagra images inom EU finns flera alternativ: GitHub Container Registry (ghcr.io), Azure Container Registry (ACR), AWS Elastic Container Registry (ECR), eller GitLab Container Registry. Alla dessa stöder privat lagring, åtkomstkontroll och integration med CI/CD-pipelines.

Oavsett register är mönstret detsamma: bygg image, tagga den med registrets URL, logga in och pusha. Pull görs automatiskt av Docker när den inte hittar imagen lokalt.

CI/CD med Docker

Docker är en naturlig del av moderna CI/CD-pipelines. Ett typiskt flöde ser ut så här: utvecklare pushar kod → CI-systemet (GitHub Actions, GitLab CI, Azure DevOps) bygger en Docker-image → imagen pushas till ett register → deployment-verktyget (Kubernetes, Azure Container Apps, AWS ECS) drar den nya imagen och startar om containrar.

I GitHub Actions kan ett enkelt workflow se ut så här: du checkar ut koden, loggar in på ett containerregister, bygger imagen med docker build, och pushar med docker push. Använd alltid unika taggar — byggnumret eller Git-hashen — för att kunna rulla tillbaka vid behov. Undvik att använda latest-taggen i produktion eftersom den gör det omöjligt att veta vilken version som faktiskt körs.

Docker i produktion — vad du behöver tänka på

Att köra Docker i produktion kräver mer disciplin än i utveckling. Här är de viktigaste sakerna att tänka på: använd alltid specifika versioner av bas-images (inte latest), kör inte containrar som root (använd USER i Dockerfile), sätt minnes- och CPU-gränser med --memory och --cpus, använd health checks för att övervaka containrar, och logga till stdout/stderr i stället för filer.

Säkerhet är särskilt viktigt i produktion. Skanna dina images med verktyg som Docker Scout, Trivy eller Snyk för att hitta sårbarheter. Använd secrets-hantering (Docker secrets, Azure Key Vault, AWS Secrets Manager) i stället för miljövariabler för känslig information. Och begränsa nätverksåtkomsten — varje container ska bara ha åtkomst till det den absolut behöver.

Felsökning och vanliga problem

Docker-problem kan ofta lösas med några enkla kontroller. Använd docker logs <container> för att se vad som händer inuti containern. Om en container inte startar, kontrollera docker ps -a för att se status och docker inspect <container> för detaljerad konfiguration. Portkonflikter är vanliga — docker run -p 8080:80 fungerar inte om port 8080 redan är upptagen. Ändra värdporten eller stoppa den andra processen.

Om du får "disk full"-fel från Docker, kör docker system prune för att rensa oanvända containrar, images och volymer. För mer aggressiv rensning, lägg till -a --volumes för att ta bort alla oanvända resurser. Image-bygge som misslyckas beror oftast på fel i Dockerfile — kontrollera att sökvägar stämmer och att alla nödvändiga filer kopieras.

Nästa steg — från utveckling till produktion

När du behärskar grunderna är nästa steg att lära dig Docker Swarm eller Kubernetes för orkestrering av flera containrar över flera maskiner. Kubernetes har blivit standarden för containerorkestrering 2026 och används av allt från startups till storföretag. För svenska team som vill börja enklare är Azure Container Apps eller AWS App Runner bra alternativ — de hanterar orkestreringen åt dig.

Du bör också lära dig mer om image-säkerhet med verktyg som Cosign för image-signering och Notary för att verifiera image-ursprung. Och glöm inte att lära dig Podman — ett daemonlöst alternativ till Docker som blir allt populärare, särskilt i RHEL- och Fedora-miljöer. Podman kör samma Docker-kommandon men kräver ingen bakgrundsdaemon, vilket ger bättre säkerhet och enklare systemd-integration.

Sammanfattning

Docker är en oumbärlig del av den moderna utvecklingsstacken. Med containrar kan du paketera din applikation med alla dess beroenden och köra den identiskt i alla miljöer. Du har nu lärt dig att installera Docker, bygga din första Dockerfile, använda docker-compose för flertjänstapplikationer, hantera volymer och nätverk, och förstå hur Docker passar in i en CI/CD-pipeline. Nästa steg är att containerisera en riktig applikation och börja använda Docker i ditt dagliga utvecklingsarbete.