Kubernetes est puissant, mais ses manifestes YAML peuvent être aussi amusants que de regarder de la peinture sécher. Voici Helm, le gestionnaire de paquets pour Kubernetes qui est là pour nous sauver la mise. Pensez-y comme à npm pour Kubernetes, mais avec moins de crises existentielles.

Voici pourquoi Helm est votre nouveau meilleur ami :

  • Modèles : Dites adieu au copier-coller des fichiers YAML !
  • Versioning : Rétablissez les déploiements plus vite que vous ne pouvez dire "oups"
  • Réutilisabilité : Partagez vos charts et devenez le héros que votre équipe mérite
  • Simplicité : Gérez des applications complexes avec une seule commande

Préparer votre application Quarkus pour la grandeur avec Helm

Avant de plonger dans les Charts Helm, assurons-nous que notre application Quarkus est prête pour ses débuts sur Kubernetes. Si ce n'est pas déjà fait, ajoutez l'extension Kubernetes à votre projet Quarkus :

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

Cette extension génère des manifestes Kubernetes pour nous, que nous utiliserons comme point de départ pour notre Chart Helm. Maintenant, créons un Dockerfile de base pour notre application 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" ]

Créer votre premier Chart Helm : Un voyage de découverte

Maintenant que notre application Quarkus est conteneurisée et prête à partir, créons un Chart Helm pour la déployer. Tout d'abord, installez Helm si ce n'est pas déjà fait :

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

Ensuite, créons un nouveau Chart Helm :

helm create quarkus-app

Cette commande crée une structure de répertoires pour votre Chart Helm. Les principaux fichiers avec lesquels nous allons travailler sont :

  • Chart.yaml : Métadonnées sur votre chart
  • values.yaml : Valeurs de configuration par défaut
  • templates/ : Répertoire contenant les modèles de manifestes Kubernetes

Personnaliser le Chart : Là où la magie opère

Modifions le fichier values.yaml pour l'adapter à notre application 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

Maintenant, mettons à jour le fichier templates/deployment.yaml pour utiliser ces valeurs :

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

Déployer votre application Quarkus : Le moment de vérité

Avec notre Chart Helm prêt, il est temps de déployer notre application Quarkus sur Kubernetes. Tout d'abord, assurez-vous d'être connecté à votre cluster Kubernetes, puis exécutez :

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

Boom ! Votre application Quarkus est maintenant déployée et fonctionne sur Kubernetes. Pour vérifier l'état de votre déploiement, utilisez :

kubectl get pods

Mise à niveau et retour en arrière : Parce que les erreurs arrivent

L'une des beautés de Helm est la facilité avec laquelle il permet les mises à niveau et les retours en arrière. Disons que vous avez apporté des modifications à votre application Quarkus et que vous souhaitez déployer une nouvelle version. Mettez simplement à jour votre tag d'image Docker dans values.yaml et exécutez :

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

Si quelque chose ne va pas (nous y sommes tous passés), revenir en arrière est aussi simple que :

helm rollback my-quarkus-app

Techniques avancées : Élever votre niveau avec Helm

Utiliser les hooks Helm pour les migrations de base de données

Si votre application Quarkus doit exécuter des migrations de base de données avant de démarrer, vous pouvez utiliser les hooks Helm pour vous assurer que cela se produit au bon moment. Ajoutez un nouveau fichier de modèle appelé 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

Ce Job s'exécutera avant le démarrage de votre application principale, garantissant que votre base de données est à jour.

Mettre en œuvre des déploiements canari

Les Charts Helm peuvent également vous aider à mettre en œuvre des stratégies de déploiement plus avancées, comme les déploiements canari. Voici un exemple rapide de la façon dont vous pourriez configurer un déploiement canari :

{{- 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 }}"
          # ... reste de la spécification du conteneur
{{- end }}

Ce modèle crée un déploiement canari séparé lorsqu'il est activé, vous permettant de diriger un pourcentage de trafic vers la nouvelle version.

Conclusion : Maîtriser Kubernetes avec Helm

Et voilà ! Nous avons parcouru le monde des Charts Helm et en sommes sortis avec une méthode élégante et gérable pour déployer nos applications Quarkus sur Kubernetes. Plus de cauchemars YAML, plus de maux de tête de déploiement – juste une navigation en douceur sur les mers de Kubernetes.

Rappelez-vous, Helm n'est qu'un outil dans votre boîte à outils Kubernetes. Au fur et à mesure de votre progression, vous pourriez vouloir explorer d'autres technologies comme Kustomize ou les frameworks d'opérateurs. Mais pour l'instant, félicitez-vous – vous avez fait un grand pas vers la maîtrise de la bête Kubernetes !

"Avec un grand pouvoir vient une grande responsabilité" – Oncle Ben, probablement en parlant des Charts Helm

Lectures complémentaires et ressources

Maintenant, allez de l'avant et déployez avec confiance ! Et rappelez-vous, si quelqu'un vous le demande, vous n'êtes plus seulement un développeur – vous êtes un dompteur de Kubernetes, un artiste des Charts Helm, et un stratège Quarkus tout en un. Bon codage !