Distribuzione di App Quarkus con Helm Charts

Kubernetes è potente, ma i suoi manifesti YAML possono essere noiosi come guardare la vernice che si asciuga. Entra in scena Helm, il gestore di pacchetti per Kubernetes che è qui per salvare la nostra sanità mentale. Pensalo come npm per Kubernetes, ma con meno crisi esistenziali.

Ecco perché Helm è il tuo nuovo migliore amico:

• Templating: Dì addio al copia-incolla dei file YAML!
• Versioning: Ripristina i deployment più velocemente di quanto tu possa dire "oops"
• Riutilizzabilità: Condividi i tuoi chart e diventa l'eroe che il tuo team merita
• Semplicità: Gestisci applicazioni complesse con un solo comando

Preparare la tua app Quarkus per la grandezza di Helm

Prima di immergerci nei Chart di Helm, assicuriamoci che la nostra app Quarkus sia pronta per il suo debutto su Kubernetes. Se non l'hai già fatto, aggiungi l'estensione Kubernetes al tuo progetto Quarkus:

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

Questa estensione genera manifesti Kubernetes per noi, che useremo come punto di partenza per il nostro Chart di Helm. Ora, creiamo un Dockerfile di base per la nostra app Quarkus:

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

Creare il tuo primo Chart di Helm: Un viaggio di scoperta

Ora che la nostra app Quarkus è containerizzata e pronta, creiamo un Chart di Helm per distribuirla. Prima di tutto, installa Helm se non l'hai già fatto:

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

Successivamente, creiamo un nuovo Chart di Helm:

helm create quarkus-app

Questo comando crea una struttura di directory per il tuo Chart di Helm. I file principali con cui lavoreremo sono:

• Chart.yaml: Metadati sul tuo chart
• values.yaml: Valori di configurazione predefiniti
• templates/: Directory contenente i template dei manifesti Kubernetes

Personalizzare il Chart: Dove avviene la magia

Modifichiamo il file values.yaml per adattarlo alla nostra app Quarkus:

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

Ora, aggiorniamo il file templates/deployment.yaml per utilizzare questi valori:

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

Distribuire la tua app Quarkus: Il momento della verità

Con il nostro Chart di Helm pronto, è il momento di distribuire la nostra app Quarkus su Kubernetes. Prima, assicurati di essere connesso al tuo cluster Kubernetes, quindi esegui:

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

Boom! La tua app Quarkus è ora distribuita e in esecuzione su Kubernetes. Per controllare lo stato del tuo deployment, usa:

kubectl get pods

Aggiornare e ripristinare: Perché gli errori accadono

Una delle bellezze di Helm è quanto sia facile fare aggiornamenti e ripristini. Supponiamo che tu abbia apportato alcune modifiche alla tua app Quarkus e voglia distribuire una nuova versione. Basta aggiornare il tag dell'immagine Docker in values.yaml ed eseguire:

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

Se qualcosa va storto (ci siamo passati tutti), ripristinare è semplice come:

helm rollback my-quarkus-app

Tecniche avanzate: Migliorare il tuo gioco con Helm

Usare i hook di Helm per le migrazioni del database

Se la tua app Quarkus deve eseguire migrazioni del database prima di avviarsi, puoi usare i hook di Helm per assicurarti che ciò avvenga al momento giusto. Aggiungi un nuovo file di template chiamato 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

Questo Job verrà eseguito prima che la tua applicazione principale si avvii, assicurando che il tuo database sia aggiornato.

Implementare i deployment canary

I Chart di Helm possono anche aiutarti a implementare strategie di deployment più avanzate, come i rilasci canary. Ecco un esempio rapido di come potresti impostare un deployment canary:

{{- 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 }}"
          # ... resto della specifica del container
{{- end }}

Questo template crea un deployment canary separato quando abilitato, permettendoti di indirizzare una percentuale di traffico alla nuova versione.

Conclusione: Navigare verso la padronanza di Kubernetes con Helm

Ecco fatto! Abbiamo attraversato il mondo dei Chart di Helm e siamo usciti dall'altra parte con un modo elegante e gestibile per distribuire le nostre applicazioni Quarkus su Kubernetes. Niente più incubi YAML, niente più mal di testa da deployment – solo navigazione tranquilla sui mari di Kubernetes.

Ricorda, Helm è solo uno strumento nel tuo kit di strumenti Kubernetes. Mentre continui il tuo viaggio, potresti voler esplorare altre tecnologie come Kustomize o i Framework Operator. Ma per ora, datti una pacca sulla spalla – hai fatto un grande passo verso il domare la bestia Kubernetes!

"Con grande potere derivano grandi responsabilità" – Zio Ben, probabilmente parlando dei Chart di Helm

Ulteriori letture e risorse

• Documentazione ufficiale di Helm
• Guida Kubernetes di Quarkus
• Repository dei Chart di Helm di Quarkus

Ora vai avanti e distribuisci con fiducia! E ricorda, se qualcuno te lo chiede, non sei solo uno sviluppatore – sei un domatore di Kubernetes, un artista dei Chart di Helm e un quarterback di Quarkus tutto in uno. Buona programmazione!