Dockerization en Kubernetes

Bij het bouwen van servertoepassingen zoals die met NestJS is consistentie tussen omgevingen essentieel. Hierbij komt containerisatie met Docker van pas.

Docker verpakt je toepassing en alle afhankelijkheden ervan in één geïsoleerde eenheid die een container wordt genoemd. Hierdoor werkt je app overal op dezelfde manier.

• Consistentie: Werkt hetzelfde in ontwikkeling, staging en productie.
• Isolatie: Voorkomt conflicten tussen apps.
• Overdraagbaarheid: Verplaats apps eenvoudig tussen hosts.

Laten we de twee belangrijkste concepten in Docker bekijken:

• Een Docker-image is een lichtgewicht, zelfstandig uitvoerbaar softwarepakket dat alles bevat wat nodig is om een toepassing uit te voeren: code, runtime, systeemhulpmiddelen, systeembibliotheken en instellingen. Zie het als een blauwdruk of sjabloon.
• Een Docker-container is een uitvoerbare instantie van een image. Je kunt een container maken, starten, stoppen, verplaatsen of verwijderen. Meerdere containers kunnen vanuit dezelfde image worden uitgevoerd.

Images worden opgeslagen in registers zoals Docker Hub.

Een Dockerfile is een tekstbestand met alle opdrachten die een gebruiker op de opdrachtregel kan uitvoeren om een image samen te stellen. Hier is een eenvoudig voorbeeld voor een NestJS-app:

FROM node:18-alpine
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
RUN npm run build
EXPOSE 3000
CMD ["node", "dist/main"]

• FROM: Basisimage.
• WORKDIR: Stelt de werkmap in.
• COPY: Kopieert bestanden.
• RUN: Voert opdrachten uit.
• EXPOSE: Informeert Docker dat de container tijdens runtime op de opgegeven netwerkpoorten luistert.
• CMD: Standaardopdracht die moet worden uitgevoerd.

Zodra je Dockerfile in de hoofdmap van je NestJS-project staat, kun je er een image van bouwen. De opdracht docker build verwerkt het Dockerfile en maakt een Docker-image.

Open je terminal in de hoofdmap van het project en voer het volgende uit:

docker build -t my-nestjs-app .

• -t my-nestjs-app: Geeft de image een naam (my-nestjs-app).
• .: Hiermee geef je de bouwcontext op (de huidige map).

Met deze opdracht wordt elke stap in je Dockerfile uitgevoerd en worden lagen voor je image gemaakt.

Nadat je de image hebt gebouwd, kun je deze als container uitvoeren. Met de opdracht docker run maak je een nieuwe container en start je deze.

Probeer je NestJS-app in een container uit te voeren:

docker run -p 3000:3000 my-nestjs-app

• -p 3000:3000: Koppelt poort 3000 op je hostcomputer aan poort 3000 in de container. Hierdoor krijg je via http://localhost:3000 toegang tot je app.
• my-nestjs-app: De naam van de image die je wilt uitvoeren.

Je NestJS-toepassing zou nu in een Docker-container moeten worden uitgevoerd!

Voor toepassingen met meerdere services, zoals een NestJS-backend en een PostgreSQL-database, vereenvoudigt Docker Compose de lokale ontwikkeling. Hiermee kun je Docker-toepassingen met meerdere containers definiëren en uitvoeren.

Een docker-compose.yml-bestand ziet er als volgt uit:

version: '3.8'
services:
api:
build: .
ports:
- '3000:3000'
depends_on:
- db
db:
image: postgres:13
environment:
POSTGRES_DB: nest
POSTGRES_USER: user
POSTGRES_PASSWORD: pass

Voer het uit met: docker-compose up

Hoewel Docker uitstekend geschikt is voor het verpakken en uitvoeren van afzonderlijke containers, wordt het beheren van veel containers over meerdere servers, vooral in productie, complex. Hiervoor is er Kubernetes (K8s).

Kubernetes is een opensourcesysteem voor het automatiseren van de implementatie, schaalvergroting en het beheer van toepassingen in containers.

• Orkestratie: Beheert de levenscyclus van containers.
• Schaalvergroting: Past resources automatisch aan.
• Zelfherstel: Herstelt van fouten.

De kleinste implementeerbare eenheid in Kubernetes is een Pod. Een pod vertegenwoordigt één instantie van een actief proces in je cluster. Een pod kan een of meer containers bevatten, bijvoorbeeld de container van je NestJS-app en een sidecarcontainer voor logboekregistratie.

Alle containers in een pod delen dezelfde netwerknaamruimte, hetzelfde IP-adres en dezelfde opslagvolumes. Hierdoor kunnen ze zeer efficiënt met elkaar communiceren.

Voorbeeld van een poddefinitie:

apiVersion: v1
kind: Pod
metadata:
name: nestjs-pod
spec:
containers:
- name: nestjs-app
image: my-nestjs-app:latest
ports:
- containerPort: 3000

Een Deployment in Kubernetes biedt declaratieve updates voor pods en ReplicaSets. Je beschrijft een gewenste toestand in een deployment, waarna de Deployment Controller de werkelijke toestand aanpast aan de gewenste toestand.

Deployments worden gebruikt om:

• ReplicaSets te maken die pods opstarten.
• Nieuwe versies van je toepassing uit te rollen.
• Terug te keren naar een eerdere revisie van een deployment.
• Je toepassing op of af te schalen.

Voorbeeld van een deployment:

apiVersion: apps/v1
kind: Deployment
metadata:
name: nestjs-deployment
spec:
replicas: 3
selector:
matchLabels:
app: nestjs-app
template:
metadata:
labels:
app: nestjs-app
spec:
containers:
- name: nestjs-app
image: my-nestjs-app:latest
ports:
- containerPort: 3000

Terwijl deployments pods beheren, definiëren Services in Kubernetes een logische groep pods en een beleid voor toegang ertoe. Services bieden netwerktoegang tot een groep pods.

Pods zijn kortstondig: ze kunnen worden gemaakt en vernietigd, waardoor hun IP-adressen veranderen. Een service biedt een stabiel IP-adres en een stabiele DNS-naam en fungeert als load balancer voor de pods waarop deze gericht is.

Voorbeeld van een service:

apiVersion: v1
kind: Service
metadata:
name: nestjs-service
spec:
selector:
app: nestjs-app
ports:
- protocol: TCP
port: 80
targetPort: 3000
type: LoadBalancer

Hiermee stel je je NestJS-app extern beschikbaar.

Goed gedaan! In deze les heb je geleerd hoe je je NestJS-toepassing met Docker in containers verpakt en hebt je basisstrategieën voor implementatie met Kubernetes verkend.

• Docker helpt je app te verpakken in consistente, geïsoleerde containers.
• Je hebt geleerd Dockerfiles te maken, images te bouwen en containers uit te voeren.
• Docker Compose helpt bij lokale ontwikkeling met meerdere services.
• Kubernetes orkestreert containers op grote schaal met behulp van Pods, Deployments en Services.

Deze hulpmiddelen vormen de basis voor moderne, schaalbare backendontwikkeling!