Aller au contenu

Packager et valider un Helm Chart dans GitLab CI

Dans le cas ou tu souhaites déployer une application sur un cluster Kubernetes tu vas avoir plusieurs moyens. Lors de l'appel de ce job, assure toi d'avoir en préambule une image docker de ton application de buildé.

Préparer l'application pour Kubernetes: Raw, Helm, Kustomize ?

Tu peux très bien directement embarquer ton application dans un objet Kubernetes type Deployment, StatefulSet, DaemonSet ou encore ReplicaSet afin de la déployer. La façon la plus simple, mais pas vraiment ouf pour gérer du multi-environnement.

Tu peux utiliser Kustomize ou encore Helm qui va te permettre de packager ton application/image docker dans un format qui va pouvoir être customizé. C'est à dire qu'avec un même package et un language de customization, tu vas pouvoir customizer ton application pour être lancé avec un fichier de configuration, appelé values. C'est donc extremement pratique car sur un vrai projet tu vas surement avoir plusieurs environnements :

  • Dev
  • QA
  • Stage1
  • Stage2
  • Prod
  • Etc.

Tu vas pouvoir adapter très facilement le comportement de ton application selon dans quel environnement elle est déployée. En effet, tu souhaites surement dans un env de dev avoir des ressources minimales afin d'économiser des couts de développement. Alors qu'à l'inverse, tu souhaites que ton application si elle est déployée sur un env de prod, qu'elle soit hautement scalable selon les pics de charges d'utilisateurs que tu vas rencontrer. On souhaite simplement suivre la charge de trafic. C'est ce que va te permettre Kustomize et Helm pour t'adapter très simplement.

Ici je vais te montrer comment packager ton application dans un package helm, appellé Helm Chart.

Exemple de code

Package du Chart

Je ne détaille pas ici comme créer un Helm Chart car j'ai déjà fait un chapitre là dessus, non plus sur comment créer un image Docker de ton application. On estime qu'a partir d'ici on a packagé notre chart avece nos values que l'on souhaite.

Ici cette étape est utile si tu souhaites publier ton Helm Chart sur un registry OCI (Harbor, Docker Hub, GitHub Container Registry, etc.) avec helm push, sur un repository d'artifact comme JFrog Artifactory, ou si tu utilises une CD comme FluxCD par exemple. Pas besoin si tu es sous ArgoCD.

Pour faire simple dans cet exemple, je créer un helm chart avec une version fixé à 1.0.0

package:
    stage: package
    image: 
        name: alpine/helm:4.3.1
        entrypoint: [""]
    script:
        - helm lint ./simple-project
        - helm package ./simple-project --version 1.0.0
        # - helm package ./simple-project --version 1.0.0-g${CI_COMMIT_SHORT_SHA}
        # - echo "${REGISTRY_PASSWORD}" | helm registry login <ton-registry> -u "${REGISTRY_USER}" --password-stdin
        # - helm push simple-project-1.0.0.tgz oci://<ton-registry>/charts
    #artifacts:
        #expire_in: 1 day
        #paths:
        #- ${CI_PROJECT_DIR}/simple-project-1.0.0.tgz
        # - ${CI_PROJECT_DIR}/simple-project-1.0.0-g${CI_COMMIT_SHORT_SHA}.tgz
  1. J'utilise une image docker avec Helm 4 de pré-installé (Helm 3 ne reçoit plus de correctifs de sécurité après le 11 novembre 2026). Je surcharge l'entrypoint afin de mettre pour la suite mes propes commandes sh.
  2. J'appelle la commande pour lint mon chart. Cela me permet de vérifier si tout est bien formatté
  3. Je package ensuite, en specifiant le dossier de mon chart
  4. En option, je pousse le .tgz sur un registry OCI : helm registry login puis helm push vers une URL en oci://

Tip

Je te met en commentaire les best-practices à appliquer, à savoir de variabiliser tes packages en suivant le SEMVER. A toi selon si tu veux un chart par commit, ou un par branche, etc. Utilise les variables pré-défini par Gitlab, elles te seront extremement utiles. Attention, Helm refuse une version qui n'est pas du SemVer : --version ${CI_COMMIT_SHA} échoue avec Error: invalid semantic version. Ajoute le SHA en suffixe de pré-release, préfixé d'une lettre (1.0.0-g${CI_COMMIT_SHORT_SHA}, comme le fait git describe) : un SHA court purement numérique commençant par 0 serait lui aussi refusé.

Valider la conformité du Chart

On va aller un peu plus loin ici, en utilisant un outils qui va pouvoir valider si l'utilisation de toute les API que j'utilise dans mon Helm Chart, est conforme avec une version de Kubernetes que je vais lui spécifier. Ainsi en faisant cette opération, je m'assure que mon Helm Chart est 100% compatible avec mon cluster Kubernetes, sur des versions spéficique.

En effet cela m'est déjà arrivé de déployé un Chart sans avoir installé les CRDs qui lui correspondent, me donnant des erreurs assez bizarres dans mon cluster. Il est donc utile de bien s'assurer que tout se passe avant même de deployer notre chart au moment de son packaging avec GitlabCI. Ou encore de vérifier que certaines api en beta ou alpha soit bien prise en compte.

Je vais utiliser ici KubeConform.

Si tu utilises des CRDs, tu peux donner ces mêmes specifications à KubeConform. Ainsi il va pouvoir analyser tes charts qui ont des ressources qui ne sont pas natives à Kubernetes, et ça c'est le feu ! 🔥

1
2
3
4
5
6
7
8
9
validate:
    stage: package
    image:
        name: alpine/helm:4.3.1
        entrypoint: [""]
    before_script:
        - wget -q https://github.com/yannh/kubeconform/releases/download/v0.8.0/kubeconform-linux-amd64.tar.gz && tar -xzf kubeconform-linux-amd64.tar.gz && mv kubeconform /usr/local/bin/
    script:
        - helm template ./simple-project | kubeconform -summary -output json -verbose -kubernetes-version 1.37.0 -ignore-missing-schemas -schema-location default -schema-location 'https://raw.githubusercontent.com/datreeio/CRDs-catalog/main/{{.Group}}/{{.ResourceKind}}_{{.ResourceAPIVersion}}.json'
  1. Ici on combine helm template pour rendre les templates Go du chart en manifestes YAML Kubernetes standards, puis on pipe la sortie vers kubeconform
  2. Les deux -schema-location indiquent à kubeconform d'utiliser les schémas Kubernetes natifs (default) puis le catalogue communautaire de CRDs de Datree pour tes ressources custom. -ignore-missing-schemas évite de faire échouer le job sur une CRD absente du catalogue
  3. Kubeconform ne valide pas directement les fichiers bruts Chart.yaml ou values.yaml (qui ne sont pas des ressources Kubernetes et déclencheraient une erreur missing 'kind' key), mais bien les manifestes Kubernetes finaux générés
  4. -verbose liste aussi les ressources valides dans le rapport JSON, comme dans l'exemple ci-dessous : sans lui, resources ne contient que les ressources en erreur

Je te montre ici un exemple de retour positif que Kubeconform peut te donner :

{
    "resources": [
        {
            "filename": "stdin",
            "kind": "Deployment",
            "name": "simple-project",
            "version": "apps/v1",
            "status": "statusValid"
        },
        {
            "filename": "stdin",
            "kind": "Service",
            "name": "simple-project",
            "version": "v1",
            "status": "statusValid"
        }
    ],
    "summary": {
        "valid": 2,
        "invalid": 0,
        "errors": 0,
        "skipped": 0
    }
}

Pour aller plus loin