Spring Boot 4-microservices en REST-API's · Les

Implementeren op een Kubernetes-cluster

Leer uw microservices verpakken en implementeren op een Kubernetes-cluster voor schaalbare orkestratie.

Les 1 van 311 stappen

Implementeren op een Kubernetes-cluster is een gratis Spring Boot 4-microservices en REST-API's-les op CoddyKit. Dit is les 1 van 3. 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 Spring Boot 4-microservices en REST-API's. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Spring Boot 4-microservices en REST-API's bevat in totaal 3 lessen.

Waarom Kubernetes voor implementatie?

Je hebt microservices gebouwd en met Docker in containers verpakt. Maar hoe beheer je ze op grote schaal?

Kubernetes is een opensourcesysteem voor het automatiseren van de implementatie, schaalbaarheid en het beheer van toepassingen in containers. Het helpt je om je microservices betrouwbaar uit te voeren.

Je microservice in een container verpakken

Voordat je naar Kubernetes implementeert, moet je Spring Boot-toepassing in een Docker-image worden verpakt. Dit proces maakt je toepassing overdraagbaar.

Een Dockerfile definieert hoe je deze image bouwt. Je kunt het zien als een recept voor je container.

FROM openjdk:17-jdk-slim
ARG JAR_FILE=target/*.jar
COPY ${JAR_FILE} app.jar
ENTRYPOINT ["java","-jar","/app.jar"]

De kern van Kubernetes: Pods

De kleinste implementeerbare eenheid in Kubernetes is een Pod. Een Pod vertegenwoordigt één exemplaar van een actief proces in je cluster.

Een Pod bevat meestal één toepassingscontainer, bijvoorbeeld je Spring Boot-app.
De Pod kan ook sidecarcontainers voor logboekregistratie of monitoring bevatten.
Pods zijn tijdelijk: als een Pod uitvalt, maakt Kubernetes een nieuwe.

De kern van Kubernetes: Deployments

Pods rechtstreeks beheren is lastig. Daar komen Deployments om de hoek kijken! Een Deployment beschrijft de gewenste toestand van je applicatie.

Het beheert een set identieke Pods.
Het verwerkt updates en terugdraaiacties geleidelijk.
Het zorgt ervoor dat er altijd een opgegeven aantal Pod-replica's actief is.

Zie het als de blauwdruk voor de instanties van je applicatie.

Je Deployment YAML maken

Deployments worden gedefinieerd met YAML-bestanden. Dit manifest specificeert details zoals de te gebruiken Docker-installatiekopie, het aantal replica's en de resourcelimieten.

Hier volgt een eenvoudig voorbeeld voor een Spring Boot-microservice:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-spring-app
spec:
  replicas: 2
  selector:
    matchLabels:
      app: my-spring-app
  template:
    metadata:
      labels:
        app: my-spring-app
    spec:
      containers:
      - name: my-spring-app
        image: your-dockerhub-user/my-spring-app:1.0
        ports:
        - containerPort: 8080

De kern van Kubernetes: Services

Pods worden dynamisch gemaakt en verwijderd, waardoor hun IP-adressen veranderen. Hoe vinden andere services of gebruikers ze dan?

Een Service biedt een stabiel netwerkknooppunt voor een set Pods. Het werkt als een load balancer en stuurt verkeer naar gezonde Pods.

Het maakt clients onafhankelijk van Pod-IP-adressen.
Het maakt communicatie tussen microservices mogelijk.

Je app beschikbaar maken met een Service

Om je Spring Boot-applicatie toegankelijk te maken, heb je een Service nodig. We gebruiken het type NodePort, waarmee de service op elke Node via een statische poort beschikbaar wordt gemaakt.

Hierdoor kan extern verkeer je applicatie bereiken.

apiVersion: v1
kind: Service
metadata:
  name: my-spring-app-service
spec:
  selector:
    app: my-spring-app
  ports:
    - protocol: TCP
      port: 8080
      targetPort: 8080
  type: NodePort

Je app implementeren met Kubectl

Zodra je YAML-bestanden voor je Deployment en Service klaar zijn, gebruik je het opdrachtregelprogramma kubectl om ze toe te passen op je Kubernetes-cluster.

kubectl communiceert met de Kubernetes API-server om resources te maken of bij te werken.

kubectl apply -f deployment.yaml
kubectl apply -f service.yaml

Je applicatie controleren en schalen

Nadat je de configuratie hebt toegepast, kun je de status van je deployments en services controleren:

kubectl get deployments
kubectl get pods
kubectl get services

Om je applicatie te schalen, bijvoorbeeld naar 4 instanties:

kubectl scale deployment my-spring-app --replicas=4

Kennistoets over de kernconcepten van Kubernetes

Test je kennis van de basisprincipes van deployments in Kubernetes.

Beantwoord dit in de interactieve les

Samenvatting: implementeren in Kubernetes

In deze les heb je geleerd hoe je je Spring Boot-microservice voorbereidt op implementatie in Kubernetes en welke kernresources daarbij betrokken zijn:

Pods: De kleinste eenheden die je kunt implementeren.
Deployments: Beheren en schalen Pods.
Services: Maken je applicatie betrouwbaar toegankelijk.

Je beschikt nu over de basis om je gecontaineriseerde applicaties in een Kubernetes-cluster te implementeren!

Gratis beginnen

Leer Java 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: 24
Lessen: 93

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Implementeren op een Kubernetes-cluster” gratis?

Ja — de volledige tekst van “Implementeren op een Kubernetes-cluster” 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 Spring Boot 4-microservices en REST-API's wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Spring Boot 4-microservices en REST-API's bevat in totaal 3 lessen.

Wat leer ik in “Implementeren op een Kubernetes-cluster”?

Leer uw microservices verpakken en implementeren op een Kubernetes-cluster voor schaalbare orkestratie. Je oefent met Spring Boot 4-microservices en REST-API's 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 Spring Boot 4-microservices en REST-API's te beginnen?

Ervaring vooraf is niet nodig. Spring Boot 4-microservices en REST-API's 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 1 van 3.

Hoe lang duurt de les “Implementeren op een Kubernetes-cluster”?

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 Spring Boot 4-microservices en REST-API's?

Ja. Elke les over Spring Boot 4-microservices en REST-API's 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

← Terug naar Spring Boot 4-microservices en REST-API's