Är du redo att ta din webbutveckling till nästa nivå? Docker för webbutveckling kan verka komplicerat vid första anblicken, men med rätt vägledning är det enklare än du tror att komma igång. Denna guide är skapad för att ge dig en solid grund för att förstå och implementera Docker i din dagliga arbetsflöde, med fokus på praktisk användning och enkelhet.

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

Innan vi dyker ner i installation och användning är det viktigt att förstå vad Docker är. I grunden är Docker en plattform som gör det möjligt att paketera applikationer och deras beroenden i isolerade miljöer som kallas containers. Tänk på en container som en lättvikts, fristående enhet som innehåller allt som behövs för att köra en specifik mjukvara – operativsystem, kod, runtime, systemverktyg, systembibliotek och inställningar.

Varför är detta revolutionerande för webbutveckling? För det första löser det problemet med "det fungerar på min maskin". Genom att köra din applikation i en Docker container kan du vara säker på att den körs i exakt samma miljö oavsett var den distribueras – på din lokala dator, på en testserver eller i produktion. Detta minskar drastiskt tid som spenderas på felsökning av miljöspecifika problem.

För det andra förenklar Docker hanteringen av olika projekt och deras beroenden. Du kan köra flera applikationer med olika versioner av databaser eller programmeringsspråk sida vid sida utan konflikter. Detta är en enorm fördel när du arbetar med flera projekt samtidigt eller när du samarbetar i team.

Slutligen möjliggör Docker en snabbare och mer konsekvent deployment-process. Genom att bygga en Docker image – en mall för en container – kan du enkelt skapa nya containers som är identiska med varandra. Detta är grunden för moderna DevOps-metoder och CI/CD-pipelines.

Steg 1: Installera Docker

Det första steget för att börja med Docker för webbutveckling är att installera det på din dator. Processen skiljer sig något beroende på ditt operativsystem:

Windows: Ladda ner och kör Docker Desktop för Windows från Dockers officiella webbplats. Följ installationsanvisningarna. Du kan behöva aktivera WSL 2 (Windows Subsystem for Linux) om du inte redan har gjort det.
macOS: Ladda ner och kör Docker Desktop för Mac. Installationsprocessen är liknande Windows.
Linux: Processen varierar beroende på din Linux-distribution. Vanligtvis involverar det att lägga till Dockers officiella repository och sedan installera Docker Engine via din pakethanterare (t.ex. apt för Debian/Ubuntu eller yum/dnf för Fedora/CentOS).

Efter installationen, öppna en terminal eller kommandotolk och kör kommandot docker --version för att verifiera att installationen lyckades. Du bör se Docker-versionen som utskrift.

Steg 2: Förstå Docker Images och Containers

Innan vi skapar vår första container är det bra att förstå skillnaden mellan en Docker image och en Docker container.

En Docker image är ett skrivskyddat mall. Den innehåller instruktioner för att skapa en Docker container. Tänk på det som en ritning eller ett recept. Images byggs i lager, vilket gör dem effektiva och återanvändbara. När du bygger en image specificerar du alla komponenter som din applikation behöver.

En Docker container är en körbar instans av en Docker image. Det är den faktiska, levande miljön där din applikation körs. Du kan starta, stoppa, flytta och ta bort containers. En enda image kan användas för att skapa flera containers.

Steg 3: Hämta en färdig Docker Image

För att snabbt komma igång kan vi hämta en färdig image från Docker Hub, som är Dockers officiella register för images. Låt oss hämta en Node.js-image, eftersom det är vanligt inom webbutveckling.

Öppna din terminal och kör:

docker pull node:latest

Detta kommando laddar ner den senaste officiella Node.js-imagen till din lokala maskin. Du kan se de nedladdade images med kommandot docker images.

Steg 4: Köra din första Docker Container

Nu när vi har en Node.js-image kan vi starta en container från den. Vi ska köra en interaktiv container som ger oss en Linux-shell inuti containern.

docker run -it --rm node:latest bash

Låt oss bryta ner kommandot:

docker run: Kommandot för att skapa och starta en ny container.
-it: Två flaggor kombinerade. -i (interactive) håller STDIN öppen även om den inte är ansluten, och -t (tty) allokerar en pseudo-terminal. Tillsammans gör de att du kan interagera med containern.
--rm: Tar automatiskt bort containern när den avslutas. Detta är användbart för att undvika att samla på sig gamla, avslutade containers.
node:latest: Namnet på imagen vi vill använda.
bash: Kommandot som ska köras inuti containern (i detta fall, att starta ett bash-skal).

När du kör detta kommando kommer du att se en ny prompt, som troligen ser ut ungefär så här: root@<container-id>:/#. Detta indikerar att du nu befinner dig inuti Docker-containern. Du kan köra Linux-kommandon här, som ls eller node -v.

För att lämna containern, skriv exit och tryck Enter. Containern kommer då att avslutas och tas bort tack vare --rm-flaggan.

Steg 5: Skapa en egen Dockerfile

För mer komplexa applikationer vill vi inte bara köra färdiga images, utan bygga egna. Detta görs med en fil som heter Dockerfile. Den innehåller instruktioner för hur Docker ska bygga din image.

Skapa en ny fil i din projektmapp som heter Dockerfile (utan filändelse) och lägg till följande innehåll för en enkel Node.js-app:

# Använd en officiell Node.js runtime som basimage
FROM node:18-alpine

# Sätt arbetsdirectory i containern
WORKDIR /usr/src/app

# Kopiera package.json och package-lock.json
COPY package*.json ./ 

# Installera applikationsberoenden
RUN npm install

# Kopiera resten av applikationskoden
COPY . .

# Exponera porten som applikationen lyssnar på
EXPOSE 3000

# Kommando för att köra applikationen
CMD [ "node", "server.js" ]

För att bygga en image från denna Dockerfile, kör följande kommando i samma mapp som filen:

docker build -t min-node-app .

docker build: Kommandot för att bygga en image.
-t min-node-app: Ger din image ett namn (tagg).
.: Anger att Docker ska leta efter Dockerfile i den aktuella katalogen.

Efter att bygget är klart kan du se din nya image med docker images.

Steg 6: Köra en container från din egen image

Nu kan vi köra en container från den image vi precis byggde. Om din Node.js-applikation lyssnar på port 3000, kan vi mappa den till en port på vår lokala maskin:

docker run -p 8080:3000 min-node-app

-p 8080:3000: Mappar port 8080 på din lokala maskin till port 3000 inuti containern. Nu kan du nå din applikation via http://localhost:8080 i din webbläsare.

Detta är grunden för Docker för webbutveckling. Genom att använda Dockerfiles kan du definiera exakta miljöer för dina applikationer, vilket säkerställer konsistens och förenklar samarbetet.

Sammanfattning

Vi har nu gått igenom grunderna för Docker för webbutveckling. Du har lärt dig vad Docker är, varför det är värdefullt, hur du installerar det, och hur du arbetar med Docker images och containers. Genom att använda Dockerfile kan du skapa anpassade miljöer för dina projekt, vilket leder till en smidigare och mer pålitlig utvecklingsprocess. Detta är ett viktigt steg mot att behärska moderna verktyg som Docker, som kompletterar andra viktiga teknologier som JavaScript, Node.js och versionshantering med Git.

Vad är en Docker container?

En Docker container är en körbar, isolerad instans av en Docker image. Den innehåller allt som behövs för att köra en applikation, inklusive kod, runtime, systemverktyg och bibliotek. Containers är lätta, portabla och konsekventa över olika miljöer.

Hur installerar jag Docker?

Du installerar Docker genom att ladda ner och köra Docker Desktop från Dockers officiella webbplats för Windows och macOS. För Linux involverar det vanligtvis att lägga till Dockers repository och installera Docker Engine via pakethanteraren.

Vad är skillnaden mellan en Docker image och en Docker container?

En Docker image är en skrivskyddad mall eller ritning som innehåller instruktioner för att skapa en container. En Docker container är en körande, levande instans av en image. Du kan skapa många containers från en enda image.

Kom igång med Docker för webbutveckling: Enkel guide