Docker en Kubernetes voor ontwikkelaars · Les

Applicaties schalen en zelfherstel

Implementeer basisstrategieën voor het schalen van uw deployments en begrijp hoe Kubernetes de beschikbaarheid en veerkracht van applicaties waarborgt.

Les 3 van 411 stappen

Applicaties schalen en zelfherstel is een gratis Docker en Kubernetes voor ontwikkelaars-les op CoddyKit. Dit is les 3 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Docker en Kubernetes voor ontwikkelaars. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Docker en Kubernetes voor ontwikkelaars bevat in totaal 4 lessen.

Introductie tot schalen en zelfherstel

Welkom! In deze les leer je hoe je met Kubernetes je applicaties robuust en responsief maakt.

We bekijken hoe je je apps kunt opschalen om wisselende belastingen aan te kunnen en hoe Kubernetes met zelfherstel automatisch van fouten kan herstellen. Dit is essentieel voor betrouwbare services met hoge beschikbaarheid.

Waarom schalen belangrijk is

Een applicatie schalen betekent dat je de capaciteit aanpast aan de vraag. Stel je een plotselinge toestroom van gebruikers naar je webwinkel voor: zonder schalen kan je app trager worden of crashen.

Verkeer verwerken: verdeel de belasting over meerdere instanties.
Prestaties verbeteren: behoud de reactiesnelheid bij intensief gebruik.
Beschikbaarheid verhogen: als één instantie uitvalt, kunnen andere het overnemen.

Schalen met Deployments

In Kubernetes zijn Deployments essentieel voor schalen. Ze beheren een set identieke Pods en zorgen ervoor dat altijd het gewenste aantal replica's actief is.

Je kunt een Deployment handmatig schalen door het veld replicas te wijzigen. Om een app met de naam my-app bijvoorbeeld naar 3 Pods te schalen:

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

Kennismaking met de Horizontal Pod Autoscaler

Handmatig schalen werkt, maar is niet ideaal voor dynamische workloads. Daar komt de Horizontal Pod Autoscaler (HPA) om de hoek kijken!

HPA past automatisch het aantal Pods in een Deployment (of StatefulSet) aan op basis van waargenomen meetwaarden, zoals CPU-gebruik of aangepaste meetwaarden.

Een HPA configureren

Een HPA-resource definieert het doel voor het schalen van je applicatie. De HPA bewaakt meetwaarden en verhoogt of verlaagt het aantal Pod-replica's binnen vastgestelde minimum- en maximumlimieten.

Hier is een eenvoudig HPA-manifest met een doel van 50% CPU-gebruik:

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: my-app-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: my-app-deployment
  minReplicas: 1
  maxReplicas: 5
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 50

Wat is zelfherstel?

Naast schalen blinkt Kubernetes ook uit in zelfherstel. Dat betekent dat het automatisch fouten in applicaties kan detecteren en herstellen zonder menselijke tussenkomst.

Als een Pod crasht, niet meer reageert of wordt beëindigd, werken de controllers van Kubernetes (zoals de Deployment-controller) eraan om de Pod te vervangen en de gewenste toestand te herstellen.

Liveness-probes: ben je actief?

Liveness-probes laten Kubernetes weten of je applicatie in een container nog actief en gezond is. Als een liveness-probe mislukt, start Kubernetes de container opnieuw.

Dit is essentieel voor apps die vast kunnen lopen of niet meer reageren zonder technisch te zijn gecrasht.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: liveness-demo
spec:
  replicas: 1
  selector:
    matchLabels:
      app: liveness-app
  template:
    metadata:
      labels:
        app: liveness-app
    spec:
      containers:
      - name: liveness-container
        image: busybox
        args:
        - /bin/sh
        - -c
        - touch /tmp/healthy; sleep 30; rm -f /tmp/healthy; sleep 600
        livenessProbe:
          exec:
            command:
            - cat
            - /tmp/healthy
          initialDelaySeconds: 5
          periodSeconds: 5

Readiness-probes: klaar voor verkeer?

Readiness-probes laten Kubernetes weten of je applicatie klaar is om netwerkverkeer te verwerken. Als een readiness-probe mislukt, stopt Kubernetes met het sturen van verkeer naar die Pod.

Zo voorkom je dat nieuwe aanvragen naar een Pod gaan die nog aan het opstarten is, gegevens laadt of tijdelijk ongezond is.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: readiness-demo
spec:
  replicas: 1
  selector:
    matchLabels:
      app: readiness-app
  template:
    metadata:
      labels:
        app: readiness-app
    spec:
      containers:
      - name: readiness-container
        image: nginx:latest
        ports:
        - containerPort: 80
        readinessProbe:
          httpGet:
            path: /index.html
            port: 80
          initialDelaySeconds: 5
          periodSeconds: 5

Synergie tussen schalen en herstel

HPA-, liveness- en readiness-probes werken samen om je applicaties zeer beschikbaar en veerkrachtig te maken.

HPA verwerkt wisselende belasting door het aantal replica's aan te passen.
Liveness-probes zorgen ervoor dat containers opnieuw worden gestart als ze niet meer reageren.
Readiness-probes zorgen ervoor dat verkeer alleen naar volledig operationele Pods gaat.

Deze gecombineerde aanpak verbetert de betrouwbaarheid van applicaties in dynamische omgevingen aanzienlijk.

Korte controle

Welke van de volgende uitspraken over de mechanismen voor schalen en zelfherstel van Kubernetes zijn WAAR?

Beantwoord dit in de interactieve les

Samenvatting en volgende stappen

Goed gedaan! Je hebt geleerd hoe Kubernetes ervoor zorgt dat je applicaties beschikbaar en performant blijven:

Schalen: capaciteit aanpassen met Deployments en HPA.
Zelfherstel: automatisch herstel met liveness- en readiness-probes.

Deze krachtige functies zijn essentieel voor het bouwen van robuuste cloud-native applicaties. Blijf oefenen om ze goed onder de knie te krijgen!

Gratis beginnen

Leer Docker en Kubernetes voor ontwikkelaars met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 12
Lessen: 48

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Applicaties schalen en zelfherstel” gratis?

Ja — de volledige tekst van “Applicaties schalen en zelfherstel” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Docker en Kubernetes voor ontwikkelaars wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Docker en Kubernetes voor ontwikkelaars bevat in totaal 4 lessen.

Wat leer ik in “Applicaties schalen en zelfherstel”?

Implementeer basisstrategieën voor het schalen van uw deployments en begrijp hoe Kubernetes de beschikbaarheid en veerkracht van applicaties waarborgt. Je oefent met Docker en Kubernetes voor ontwikkelaars door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Docker en Kubernetes voor ontwikkelaars te beginnen?

Ervaring vooraf is niet nodig. Docker en Kubernetes voor ontwikkelaars op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 3 van 4.

Hoe lang duurt de les “Applicaties schalen en zelfherstel”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Docker en Kubernetes voor ontwikkelaars?

Ja. Elke les over Docker en Kubernetes voor ontwikkelaars bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

Kubernetes Deployments begrijpen
Applicaties beschikbaar maken met Services
Applicaties schalen en zelfherstel
Rolling updates en rollbacks

← Terug naar Docker en Kubernetes voor ontwikkelaars