Introduktion till Docker

Containers

En container är som en liten låda som innehåller allt din applikation behöver för att fungera: programkod, bibliotek och konfigurationer. Grundtanken med containers är att säkerställa att applikationen fungerar på exakt samma sätt oavsett var den körs—på din laptop, en kollegas dator eller i molnet.

När Lisa, en ny utvecklare, börjar i teamet förväntar hon sig att det kommer ta flera timmar, kanske en hel dag, att installera alla verktyg och konfigurera sin utvecklingsmiljö. Men det kanske finns en bättre lösning?

“Det finns ett smidigare sätt,” säger en kollega och visar hur teamet använder containers.

Eftersom allt är paketerat i en container, behöver Lisa bara köra ett enda kommando för att få exakt samma utvecklingsmiljö som sina teammedlemmar.

🔹 Vad löser containers?

Alla utvecklare i teamet arbetar i en identisk miljö, vilket minskar ” det funkar ju inte på min dator”-problem.
Nya utvecklare kan starta upp sin miljö på några minuter istället för timmar.
Alla använder exakt samma versioner av tex. C#, Node, databaser och andra beroenden.
Lisas utvecklingsmiljö påverkar inte andra projekt på hennes dator – hon kan arbeta med flera projekt utan att behöva installera om eller ändra inställningar varje gång.

En container är en låda som håller koll på innehållet

Container Images

Om containers är lådorna, så är container images ritningen över vad som ska finnas i lådan. En image specificerar alla filer, inställningar och program som ska ingå när containern startas.

Med container images kan teamet hantera olika versioner av sin applikation:

En stabil version för produktion – säkerställer att kunderna alltid använder en testad och fungerande version.

En testversion för kvalitetssäkring – teamet kan köra tester och upptäcka buggar innan koden når produktionen.

En utvecklingsversion med de senaste funktionerna – utvecklare kan experimentera utan att riskera att påverka den stabila versionen.

🔹 Varför är container images viktiga?

Enklare versionshantering – Lisa kan snabbt växla mellan olika versioner av appen utan att installera om något.
Reproducerbara miljöer – Vid testning testar teamet exakt samma version som kommer att rullas ut i produktion.
Snabb återställning vid fel – om en ny version skapar problem kan teamet enkelt rulla tillbaka till en tidigare fungerande image.
Delning och samarbete – utvecklare kan skapa en image, dela den med teamet och vara säkra på att alla jobbar i samma miljö.

Vi skapar en image och lägger den i lådan för att specifiera innehållet

Docker Registry

När vi har byggt en container image vill vi kunna dela den med resten av teamet eller distribuera den till servrar. Det gör vi via en Docker Registry, som fungerar som ett gemensamt bibliotek där teamet lagrar och hämtar images.

Nu när personerna i teamet sitter och utvecklar olika delar av applikationen är det viktigt att alla snabbt och enkelt kan dela sina ändringar

Maria har uppdaterat API:et med nya funktioner som gör det möjligt att filtrera produkter.
Johan har optimerat databasen för att snabba upp laddningstider.
Rufus och Kurt behöver testa båda ändringarna tillsammans(API:t och databasen) innan ändringarna går vidare till produktion-versionen.

Utan ett registry: Skulle behöva bygga och hantera sina egna versioner av applikationen manuellt, vilket kan leda till förvirring och kompatibilitetsproblem.

Med ett registry: Teamet kan enkelt ladda upp, versionera och dela sina containers.

🔹 Ett typiskt arbetsflöde med registry:

Lisa utvecklar en ny sökfunktion lokalt och testar funktionen i sin utvecklingscontainer.
När allt fungerar bygger hon en ny image: docker build -t searchapi:v2 och laddar upp den till teamets registry.
Hela teamet har nu tillgång och kan nu testa den nya sökfunktionen och sedan verifiera den innan ändringarna går live.

Detta förenklar särskilt:

Kodgranskning (andra kan enkelt testa ändringarna)
Versionshantering (alla versioner finns sparade)
Utrullning (samma image används i alla miljöer)

Vi förvarar våra images i ett Registry så andra behöriga lätt kan komma åt de

Docker Compose

Många moderna applikationer består av flera tjänster som behöver samverka – en backend, en frontend och en databas. Att manuellt starta och koppla ihop alla dessa containers kan vara krångligt, och här kommer Docker Compose till användning.

När Lisa skall starta applikationen teamet jobbar med (e-handelssystem) så märker hon att systemet består av flera delar:

En webbserver för frontend, där kunder kan bläddra bland produkter och lägga beställningar.
Ett backend API, som hanterar orderprocesser och affärslogik.
En SQL-databas, som lagrar produktinformation och kundorder.

Lisa försöker starta systemet manuellt, men stöter på flera problem:

❌ Hon måste starta varje del separat och i rätt ordning.

❌ Backend försöker starta innan databasen är redo, vilket leder till fel.

❌ Varje tjänst behöver rätt konfiguration för att hitta varandra.

❌ Hon behöver hålla reda på flera terminalfönster för att köra allt samtidigt.

Teamet visar Lisa en Docker Compose-fil, som beskriver hela applikationen och hur de olika tjänsterna ska samverka. Med ett enda kommando ( docker-compose up ) kan hon starta allt:

✅ Alla containers startar automatiskt i rätt ordning.

✅ Backend väntar tills databasen är redo innan den startar.

✅ Tjänsterna är redan konfigurerade att prata med varandra.

✅ Lisa kan fokusera på att skriva kod istället för att hantera miljöproblem.

Vi använder Docker compose för att med ett kommando få alla containers att samverka

🔹 Docker Compose binder ihop allt:

Vi definierar hela vår miljö och hur Docker Compose skall initiera alla delarna i en YAML-fil, den kan se ut såhär:

version: '3.8'
services:
  webshop:
    build: ./frontend
    ports:
      - "3000:3000"
    depends_on:
      - api

  api:
    build: ./backend
    ports:
      - "5000:5000"
    depends_on:
      - db
    environment:
      DATABASE_URL: postgres://user:password@db:5432/shop

  db:
    image: postgres:latest
    environment:
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password
      POSTGRES_DB: shop
    volumes:
      - db_data:/var/lib/postgresql/data

volumes:
  db_data:

Nu kan hela teamet:

Starta hela miljön med ett kommando: docker-compose up
Vara säkra på att alla delar är korrekt konfigurerade

Sammanfattning:

En Container är som en låda med viktiga specifikationer av program och inställningar. Lådan kan vi enkelt skicka runt eller dela inom teamet så att alla sitter på likadana program och inställningar.

Container Image är som ett recept som specifierar exakt vad som finns i lådan och skall initieras när lådan börjar köras.

Docker Registry är som ett lager där vi gemensamt förvarar och hämtar våra lådor. Lådorna hålls uppdaterade så att att alla får tillgång till samma miljö.

Docker Compose hjälper oss öppna och köra alla containers samtidigt så att de tillsammans får hela applikationen att fungera.