Kubernetes is krachtig, maar de YAML-manifesten kunnen net zo saai zijn als naar droogende verf kijken. Hier komt Helm, de pakketbeheerder voor Kubernetes, om ons te redden. Zie het als npm voor Kubernetes, maar dan met minder existentiële crises.

Dit is waarom Helm je nieuwe beste vriend is:

  • Templates: Zeg vaarwel tegen het kopiëren en plakken van YAML-bestanden!
  • Versiebeheer: Draai implementaties sneller terug dan je "oeps" kunt zeggen
  • Herbruikbaarheid: Deel je charts en word de held die je team verdient
  • Eenvoud: Beheer complexe applicaties met één enkel commando

Je Quarkus-app klaarmaken voor Helm-grootheid

Voordat we in Helm Charts duiken, laten we ervoor zorgen dat onze Quarkus-app klaar is voor zijn Kubernetes-debuut. Als je dat nog niet hebt gedaan, voeg de Kubernetes-extensie toe aan je Quarkus-project:

./mvnw quarkus:add-extension -Dextensions="kubernetes"

Deze extensie genereert Kubernetes-manifesten voor ons, die we als startpunt voor onze Helm Chart zullen gebruiken. Laten we nu een basis-Dockerfile voor onze Quarkus-app maken:

FROM registry.access.redhat.com/ubi8/openjdk-17:1.14

ENV LANGUAGE='en_US:en'

COPY target/quarkus-app/lib/ /deployments/lib/
COPY target/quarkus-app/*.jar /deployments/
COPY target/quarkus-app/app/ /deployments/app/
COPY target/quarkus-app/quarkus/ /deployments/quarkus/

EXPOSE 8080
USER 185
ENV JAVA_OPTS="-Dquarkus.http.host=0.0.0.0 -Djava.util.logging.manager=org.jboss.logmanager.LogManager"
ENV JAVA_APP_JAR="/deployments/quarkus-run.jar"

ENTRYPOINT [ "/opt/jboss/container/java/run/run-java.sh" ]

Je eerste Helm Chart maken: Een ontdekkingsreis

Nu onze Quarkus-app is gecontaineriseerd en klaar is om te gaan, laten we een Helm Chart maken om deze te implementeren. Installeer eerst Helm als je dat nog niet hebt gedaan:

curl https://raw.githubusercontent.com/helm/helm/master/scripts/get-helm-3 | bash

Vervolgens maken we een nieuwe Helm Chart aan:

helm create quarkus-app

Dit commando creëert een directorystructuur voor je Helm Chart. De belangrijkste bestanden waarmee we gaan werken zijn:

  • Chart.yaml: Metadata over je chart
  • values.yaml: Standaard configuratiewaarden
  • templates/: Directory met Kubernetes-manifesttemplates

De Chart aanpassen: Waar de magie gebeurt

Laten we het values.yaml-bestand aanpassen aan onze Quarkus-app:

replicaCount: 1

image:
  repository: your-registry/quarkus-app
  pullPolicy: IfNotPresent
  tag: "latest"

service:
  type: ClusterIP
  port: 8080

ingress:
  enabled: true
  className: "nginx"
  hosts:
    - host: quarkus-app.local
      paths:
        - path: /
          pathType: Prefix

resources:
  limits:
    cpu: 500m
    memory: 512Mi
  requests:
    cpu: 250m
    memory: 256Mi

Laten we nu het templates/deployment.yaml-bestand bijwerken om deze waarden te gebruiken:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: {{ include "quarkus-app.fullname" . }}
  labels:
    {{- include "quarkus-app.labels" . | nindent 4 }}
spec:
  replicas: {{ .Values.replicaCount }}
  selector:
    matchLabels:
      {{- include "quarkus-app.selectorLabels" . | nindent 6 }}
  template:
    metadata:
      labels:
        {{- include "quarkus-app.selectorLabels" . | nindent 8 }}
    spec:
      containers:
        - name: {{ .Chart.Name }}
          image: "{{ .Values.image.repository }}:{{ .Values.image.tag | default .Chart.AppVersion }}"
          imagePullPolicy: {{ .Values.image.pullPolicy }}
          ports:
            - name: http
              containerPort: 8080
              protocol: TCP
          resources:
            {{- toYaml .Values.resources | nindent 12 }}

Je Quarkus-app implementeren: Het moment van de waarheid

Met onze Helm Chart klaar, is het tijd om onze Quarkus-app naar Kubernetes te implementeren. Zorg er eerst voor dat je verbonden bent met je Kubernetes-cluster en voer dan uit:

helm install my-quarkus-app ./quarkus-app

Boom! Je Quarkus-app is nu geïmplementeerd en draait in Kubernetes. Om de status van je implementatie te controleren, gebruik:

kubectl get pods

Upgraden en Terugdraaien: Omdat fouten gebeuren

Een van de mooie dingen van Helm is hoe gemakkelijk het upgrades en terugdraaien maakt. Stel dat je enkele wijzigingen hebt aangebracht in je Quarkus-app en een nieuwe versie wilt implementeren. Werk eenvoudig je Docker-image tag bij in values.yaml en voer uit:

helm upgrade my-quarkus-app ./quarkus-app

Als er iets misgaat (we zijn er allemaal geweest), is terugdraaien net zo eenvoudig als:

helm rollback my-quarkus-app

Geavanceerde Technieken: Je Helm-spel naar een hoger niveau tillen

Helm Hooks gebruiken voor Database Migraties

Als je Quarkus-app database migraties moet uitvoeren voordat deze start, kun je Helm hooks gebruiken om ervoor te zorgen dat dit op het juiste moment gebeurt. Voeg een nieuw templatebestand toe genaamd templates/db-migrate-job.yaml:

apiVersion: batch/v1
kind: Job
metadata:
  name: {{ include "quarkus-app.fullname" . }}-db-migrate
  annotations:
    "helm.sh/hook": pre-install,pre-upgrade
    "helm.sh/hook-weight": "-5"
    "helm.sh/hook-delete-policy": hook-succeeded
spec:
  template:
    spec:
      containers:
        - name: db-migrate
          image: "{{ .Values.image.repository }}:{{ .Values.image.tag | default .Chart.AppVersion }}"
          command: ["./migrate-database.sh"]
      restartPolicy: Never
  backoffLimit: 5

Deze Job zal draaien voordat je hoofdapplicatie start, zodat je database up-to-date is.

Canary-implementaties implementeren

Helm Charts kunnen je ook helpen bij het implementeren van meer geavanceerde implementatiestrategieën, zoals canary-releases. Hier is een snel voorbeeld van hoe je een canary-implementatie zou kunnen opzetten:

{{- if .Values.canary.enabled }}
apiVersion: apps/v1
kind: Deployment
metadata:
  name: {{ include "quarkus-app.fullname" . }}-canary
spec:
  replicas: {{ .Values.canary.replicaCount }}
  selector:
    matchLabels:
      {{- include "quarkus-app.selectorLabels" . | nindent 6 }}
      version: canary
  template:
    metadata:
      labels:
        {{- include "quarkus-app.selectorLabels" . | nindent 8 }}
        version: canary
    spec:
      containers:
        - name: {{ .Chart.Name }}-canary
          image: "{{ .Values.image.repository }}:{{ .Values.canary.tag }}"
          # ... rest of the container spec
{{- end }}

Deze template creëert een aparte canary-implementatie wanneer deze is ingeschakeld, zodat je een percentage van het verkeer naar de nieuwe versie kunt leiden.

Conclusie: Je weg naar Kubernetes-meesterschap met Helm

En daar heb je het! We hebben een reis gemaakt door het land van Helm Charts en zijn aan de andere kant uitgekomen met een gestroomlijnde, beheersbare manier om onze Quarkus-applicaties naar Kubernetes te implementeren. Geen YAML-nachtmerries meer, geen implementatiehoofdpijn meer – alleen soepel zeilen op de Kubernetes-zeeën.

Onthoud, Helm is slechts één hulpmiddel in je Kubernetes-gereedschapskist. Terwijl je je reis voortzet, wil je misschien andere technologieën verkennen zoals Kustomize of Operator Frameworks. Maar voor nu, klop jezelf op de schouder – je hebt een grote stap gezet in het temmen van het Kubernetes-beest!

"Met grote kracht komt grote verantwoordelijkheid" – Oom Ben, waarschijnlijk pratend over Helm Charts

Verdere Lezing en Bronnen

Ga nu op pad en implementeer met vertrouwen! En onthoud, als iemand het vraagt, ben je niet alleen een ontwikkelaar meer – je bent een Kubernetes-temmer, een Helm Chart-kunstenaar en een Quarkus-quarterback in één. Veel codeerplezier!