Kubernetes ist mächtig, aber seine YAML-Manifeste sind ungefähr so spannend wie zuschauen, wie Farbe trocknet. Hier kommt Helm ins Spiel, der Paketmanager für Kubernetes, der uns den Verstand retten soll. Denken Sie an npm für Kubernetes, aber mit weniger existenziellen Krisen.

Hier ist, warum Helm Ihr neuer bester Freund ist:

  • Templating: Verabschieden Sie sich vom Kopieren und Einfügen von YAML-Dateien!
  • Versionierung: Rollen Sie Deployments schneller zurück, als Sie "ups" sagen können
  • Wiederverwendbarkeit: Teilen Sie Ihre Charts und werden Sie der Held, den Ihr Team verdient
  • Einfachheit: Verwalten Sie komplexe Anwendungen mit einem einzigen Befehl

Einrichten Ihrer Quarkus-App für Helm-Großartigkeit

Bevor wir in Helm Charts eintauchen, stellen wir sicher, dass unsere Quarkus-App bereit für ihren Kubernetes-Auftritt ist. Falls noch nicht geschehen, fügen Sie die Kubernetes-Erweiterung zu Ihrem Quarkus-Projekt hinzu:

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

Diese Erweiterung generiert Kubernetes-Manifeste für uns, die wir als Ausgangspunkt für unser Helm Chart verwenden werden. Jetzt erstellen wir eine einfache Dockerfile für unsere Quarkus-App:

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" ]

Erstellen Ihres ersten Helm Charts: Eine Entdeckungsreise

Da unsere Quarkus-App nun containerisiert und einsatzbereit ist, erstellen wir ein Helm Chart, um sie bereitzustellen. Installieren Sie zuerst Helm, falls noch nicht geschehen:

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

Als nächstes erstellen wir ein neues Helm Chart:

helm create quarkus-app

Dieser Befehl erstellt eine Verzeichnisstruktur für Ihr Helm Chart. Die Hauptdateien, mit denen wir arbeiten werden, sind:

  • Chart.yaml: Metadaten über Ihr Chart
  • values.yaml: Standardkonfigurationswerte
  • templates/: Verzeichnis mit Kubernetes-Manifestvorlagen

Anpassen des Charts: Wo die Magie passiert

Passen wir die values.yaml-Datei an unsere Quarkus-App an:

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

Jetzt aktualisieren wir die templates/deployment.yaml-Datei, um diese Werte zu verwenden:

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 }}

Bereitstellen Ihrer Quarkus-App: Der Moment der Wahrheit

Mit unserem Helm Chart bereit, ist es Zeit, unsere Quarkus-App auf Kubernetes bereitzustellen. Stellen Sie zuerst sicher, dass Sie mit Ihrem Kubernetes-Cluster verbunden sind, und führen Sie dann aus:

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

Boom! Ihre Quarkus-App ist jetzt bereitgestellt und läuft in Kubernetes. Um den Status Ihrer Bereitstellung zu überprüfen, verwenden Sie:

kubectl get pods

Upgraden und Zurückrollen: Weil Fehler passieren

Einer der Vorteile von Helm ist, wie einfach es Upgrades und Rollbacks macht. Angenommen, Sie haben einige Änderungen an Ihrer Quarkus-App vorgenommen und möchten eine neue Version bereitstellen. Aktualisieren Sie einfach Ihr Docker-Image-Tag in values.yaml und führen Sie aus:

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

Wenn etwas schiefgeht (wir waren alle schon dort), ist das Zurückrollen so einfach wie:

helm rollback my-quarkus-app

Erweiterte Techniken: Ihr Helm-Spiel auf das nächste Level bringen

Verwendung von Helm Hooks für Datenbankmigrationen

Wenn Ihre Quarkus-App Datenbankmigrationen vor dem Start ausführen muss, können Sie Helm Hooks verwenden, um sicherzustellen, dass dies zur richtigen Zeit geschieht. Fügen Sie eine neue Vorlagendatei namens templates/db-migrate-job.yaml hinzu:

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

Dieser Job wird vor dem Start Ihrer Hauptanwendung ausgeführt und stellt sicher, dass Ihre Datenbank auf dem neuesten Stand ist.

Implementierung von Canary Deployments

Helm Charts können Ihnen auch helfen, fortschrittlichere Bereitstellungsstrategien wie Canary-Releases zu implementieren. Hier ist ein kurzes Beispiel, wie Sie ein Canary-Deployment einrichten könnten:

{{- 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 }}

Diese Vorlage erstellt ein separates Canary-Deployment, wenn es aktiviert ist, sodass Sie einen Prozentsatz des Datenverkehrs auf die neue Version umleiten können.

Fazit: Mit Helm zur Kubernetes-Meisterschaft

Und da haben Sie es! Wir haben die Welt der Helm Charts durchquert und sind auf der anderen Seite mit einer eleganten, handhabbaren Möglichkeit herausgekommen, unsere Quarkus-Anwendungen auf Kubernetes bereitzustellen. Keine YAML-Albträume mehr, keine Bereitstellungskopfschmerzen mehr – nur noch reibungsloses Segeln auf den Kubernetes-Meeren.

Denken Sie daran, Helm ist nur ein Werkzeug in Ihrem Kubernetes-Werkzeugkasten. Während Sie Ihre Reise fortsetzen, möchten Sie vielleicht andere Technologien wie Kustomize oder Operator Frameworks erkunden. Aber für den Moment klopfen Sie sich auf die Schulter – Sie haben einen großen Schritt gemacht, um das Kubernetes-Biest zu zähmen!

"Mit großer Macht kommt große Verantwortung" – Onkel Ben, wahrscheinlich über Helm Charts sprechend

Weiterführende Lektüre und Ressourcen

Gehen Sie nun hinaus und stellen Sie mit Zuversicht bereit! Und denken Sie daran, wenn jemand fragt, sind Sie nicht nur ein Entwickler – Sie sind ein Kubernetes-Bändiger, ein Helm Chart-Künstler und ein Quarkus-Quarterback in einem. Viel Spaß beim Programmieren!