CI/CD Helm : automatiser le packaging, lint et promotion des charts

Automatiser le cycle de vie des charts Helm en CI/CD garantit la qualité (lint, tests), la reproductibilité (versioning automatique), et la traçabilité (qui a publié quoi, quand). Ce module présente une pipeline complète avec GitLab CI et GitHub Actions, ainsi que les patterns de promotion dev → staging → prod.

Prérequis

Un repo Git contenant vos charts
Accès à un registry OCI (Harbor, GHCR, ECR)
Module 10 — OCI registries
Module 11 — Provenance (optionnel)

Architecture d’une pipeline Helm

Workflow standard

Workflow CI/CD Helm : Lint, Test, Package, Publish, puis Deploy optionnel vers dev, staging et prod

Ce que fait chaque étape

Étape	Outils	Objectif
Lint	`helm lint`, `ct lint`	Syntaxe YAML, bonnes pratiques
Test	`helm template`, `kubeval`, `kubeconform`	Manifests K8s valides
Package	`helm package`	Créer le `.tgz` versionné
Publish	`helm push`	Pousser sur registry OCI
Deploy	`helm upgrade --install` ou GitOps	Déployer sur cluster

Étape 1 : Lint et validation

helm lint (basique)

# Lint un chart
helm lint ./charts/my-app

# Lint strict (warnings = erreurs)
helm lint ./charts/my-app --strict

Chart Testing (ct) — recommandé

Chart Testing (ct) est l’outil officiel pour tester des charts en CI :

# Installer ct
pip install chart-testing

# Lint tous les charts modifiés
ct lint --config .ct.yaml

# Lint tous les charts
ct lint --all --config .ct.yaml

Configuration .ct.yaml :

chart-dirs:
  - charts
validate-maintainers: false
validate-chart-schema: true
lint-conf:
  - --strict

Validation du schema (values)

# Si values.schema.json existe
helm lint ./charts/my-app  # Valide automatiquement les values

Étape 2 : Tests de chart

helm template (rendu local)

# Générer les manifests sans cluster
helm template my-app ./charts/my-app -f values-test.yaml > rendered.yaml

# Vérifier que ça génère du YAML valide
helm template my-app ./charts/my-app > /dev/null
echo $?  # 0 = OK

Validation des manifests K8s

kubeconform
kubeval

# Installer kubeconform (rapide, maintenu)
# https://github.com/yannh/kubeconform

helm template my-app ./charts/my-app | kubeconform -strict -summary

# Installer kubeval
# https://github.com/instrumenta/kubeval

helm template my-app ./charts/my-app | kubeval --strict

Tests helm (intégration)

Si votre chart définit des tests dans templates/tests/ :

# Déployer puis tester
helm install my-app ./charts/my-app -n test --wait
helm test my-app -n test
helm uninstall my-app -n test

Étape 3 : Package et versioning

Versioning automatique

Option 1 : Version depuis Chart.yaml (manuelle)

version: 1.2.3  # Incrémenter manuellement
appVersion: "2.0.0"

Option 2 : Version depuis Git tag

# Récupérer la version depuis le tag Git
VERSION=$(git describe --tags --abbrev=0 2>/dev/null || echo "0.0.0")

# Remplacer dans Chart.yaml
sed -i "s/^version:.*/version: $VERSION/" charts/my-app/Chart.yaml

# Packager
helm package ./charts/my-app

Option 3 : Semantic Release

# .releaserc.yaml pour semantic-release
plugins:
  - "@semantic-release/commit-analyzer"
  - "@semantic-release/release-notes-generator"
  - ["@semantic-release/exec", {
      "prepareCmd": "sed -i 's/^version:.*/version: ${nextRelease.version}/' charts/my-app/Chart.yaml"
    }]

Package avec métadonnées

# Packager
helm package ./charts/my-app

# Résultat : my-app-1.2.3.tgz

Étape 4 : Publish sur registry

Push OCI

# Login (une fois par job)
echo "$REGISTRY_PASSWORD" | helm registry login $REGISTRY_URL -u $REGISTRY_USER --password-stdin

# Push
helm push my-app-1.2.3.tgz oci://$REGISTRY_URL/charts

Vérification post-push

# Vérifier que le chart est accessible
helm show chart oci://$REGISTRY_URL/charts/my-app --version 1.2.3

Pipeline complète GitLab CI

stages:
  - lint
  - test
  - package
  - publish

variables:
  HELM_VERSION: "3.14.0"
  CHART_PATH: "charts/my-app"
  REGISTRY_URL: "harbor.example.com/charts"

.helm-base:
  image: alpine/helm:${HELM_VERSION}
  before_script:
    - helm version

lint:
  extends: .helm-base
  stage: lint
  script:
    - helm lint ${CHART_PATH} --strict
    - helm template test ${CHART_PATH} > /dev/null
  rules:
    - if: $CI_PIPELINE_SOURCE == "merge_request_event"
    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH

test:
  extends: .helm-base
  stage: test
  image: alpine:latest
  before_script:
    - apk add --no-cache helm curl
    - curl -sL https://github.com/yannh/kubeconform/releases/latest/download/kubeconform-linux-amd64.tar.gz | tar xz
    - mv kubeconform /usr/local/bin/
  script:
    - helm template test ${CHART_PATH} | kubeconform -strict -summary
  rules:
    - if: $CI_PIPELINE_SOURCE == "merge_request_event"
    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH

package:
  extends: .helm-base
  stage: package
  script:
    # Version depuis le tag Git ou CI_COMMIT_TAG
    - |
      if [ -n "$CI_COMMIT_TAG" ]; then
        VERSION=$CI_COMMIT_TAG
      else
        VERSION="0.0.0-${CI_COMMIT_SHORT_SHA}"
      fi
    - sed -i "s/^version:.*/version: $VERSION/" ${CHART_PATH}/Chart.yaml
    - helm package ${CHART_PATH}
  artifacts:
    paths:
      - "*.tgz"
    expire_in: 1 week
  rules:
    - if: $CI_COMMIT_TAG
    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH

publish:
  extends: .helm-base
  stage: publish
  script:
    - echo "${REGISTRY_PASSWORD}" | helm registry login ${REGISTRY_URL} -u ${REGISTRY_USER} --password-stdin
    - helm push *.tgz oci://${REGISTRY_URL}
  dependencies:
    - package
  rules:
    - if: $CI_COMMIT_TAG

Pipeline complète GitHub Actions

name: Helm CI/CD

on:
  push:
    branches: [main]
    tags: ['v*']
  pull_request:
    branches: [main]

env:
  CHART_PATH: charts/my-app
  REGISTRY: ghcr.io
  REGISTRY_PATH: ${{ github.repository_owner }}/charts

jobs:
  lint:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Set up Helm
        uses: azure/setup-helm@v3
        with:
          version: '3.14.0'

      - name: Lint chart
        run: |
          helm lint ${{ env.CHART_PATH }} --strict
          helm template test ${{ env.CHART_PATH }} > /dev/null

  test:
    runs-on: ubuntu-latest
    needs: lint
    steps:
      - uses: actions/checkout@v4

      - name: Set up Helm
        uses: azure/setup-helm@v3

      - name: Install kubeconform
        run: |
          curl -sL https://github.com/yannh/kubeconform/releases/latest/download/kubeconform-linux-amd64.tar.gz | tar xz
          sudo mv kubeconform /usr/local/bin/

      - name: Validate manifests
        run: helm template test ${{ env.CHART_PATH }} | kubeconform -strict -summary

  publish:
    runs-on: ubuntu-latest
    needs: test
    if: startsWith(github.ref, 'refs/tags/v')
    permissions:
      contents: read
      packages: write
    steps:
      - uses: actions/checkout@v4

      - name: Set up Helm
        uses: azure/setup-helm@v3

      - name: Get version from tag
        id: version
        run: echo "VERSION=${GITHUB_REF#refs/tags/v}" >> $GITHUB_OUTPUT

      - name: Update Chart.yaml version
        run: |
          sed -i "s/^version:.*/version: ${{ steps.version.outputs.VERSION }}/" ${{ env.CHART_PATH }}/Chart.yaml

      - name: Package chart
        run: helm package ${{ env.CHART_PATH }}

      - name: Login to GHCR
        run: echo "${{ secrets.GITHUB_TOKEN }}" | helm registry login ${{ env.REGISTRY }} -u ${{ github.actor }} --password-stdin

      - name: Push chart
        run: helm push *.tgz oci://${{ env.REGISTRY }}/${{ env.REGISTRY_PATH }}

Promotion multi-environnements

Pattern : même chart, values différents

Répertoirecharts/
- Répertoiremy-app/
  - Chart.yaml
  - values.yaml Defaults
  - Répertoiretemplates/
    …
- Répertoirevalues/
  - values-dev.yaml Dev overrides
  - values-staging.yaml
  - values-prod.yaml

Déploiement par environnement

# Dev (automatique sur main)
helm upgrade --install my-app oci://registry/charts/my-app \
  --version 1.2.3 \
  -f values/values-dev.yaml \
  -n dev

# Staging (manuel ou tag)
helm upgrade --install my-app oci://registry/charts/my-app \
  --version 1.2.3 \
  -f values/values-staging.yaml \
  -n staging

# Prod (approval + tag)
helm upgrade --install my-app oci://registry/charts/my-app \
  --version 1.2.3 \
  -f values/values-prod.yaml \
  -n prod

Pipeline avec gates

# GitLab CI - promotion avec approval
deploy-staging:
  stage: deploy
  script:
    - helm upgrade --install my-app oci://${REGISTRY}/my-app --version ${VERSION} -f values/values-staging.yaml -n staging
  environment:
    name: staging
  rules:
    - if: $CI_COMMIT_TAG

deploy-prod:
  stage: deploy
  script:
    - helm upgrade --install my-app oci://${REGISTRY}/my-app --version ${VERSION} -f values/values-prod.yaml -n prod
  environment:
    name: production
  when: manual  # Approval requis
  rules:
    - if: $CI_COMMIT_TAG

Intégration GitOps

Argo CD avec Helm

# Application Argo CD
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: my-app
  namespace: argocd
spec:
  project: default
  source:
    repoURL: oci://harbor.example.com/charts
    chart: my-app
    targetRevision: 1.2.3
    helm:
      valueFiles:
        - values-prod.yaml
  destination:
    server: https://kubernetes.default.svc
    namespace: prod
  syncPolicy:
    automated:
      prune: true
      selfHeal: true

Flux avec HelmRelease

# HelmRelease Flux
apiVersion: helm.toolkit.fluxcd.io/v2beta1
kind: HelmRelease
metadata:
  name: my-app
  namespace: prod
spec:
  interval: 5m
  chart:
    spec:
      chart: my-app
      version: "1.2.3"
      sourceRef:
        kind: HelmRepository
        name: my-charts
        namespace: flux-system
  values:
    replicaCount: 3
    # ... prod values

Lab C3 — Pipeline CI/CD complète

Objectif : Créer une pipeline qui lint, package et publie un chart sur push vers main ou tag.

Structure du repo

mkdir helm-cicd-lab && cd helm-cicd-lab
git init

# Créer un chart
mkdir -p charts
helm create charts/my-app

# Créer les values par env
mkdir -p values
cp charts/my-app/values.yaml values/values-dev.yaml
cp charts/my-app/values.yaml values/values-prod.yaml

Créer la pipeline (GitLab ou GitHub selon votre environnement)

Copier le fichier .gitlab-ci.yml ou .github/workflows/helm.yml ci-dessus.
Configurer les secrets
- GitLab : Settings → CI/CD → Variables
  - REGISTRY_URL
  - REGISTRY_USER
  - REGISTRY_PASSWORD
- GitHub : Settings → Secrets and variables → Actions
  - GITHUB_TOKEN est automatique pour GHCR

Pousser et déclencher

git add .
git commit -m "feat: initial chart"
git push origin main

# Créer un tag pour publish
git tag v0.1.0
git push origin v0.1.0

Vérifier
- Pipeline lint/test passe
- Chart publié sur le registry
- helm show chart oci://registry/charts/my-app --version 0.1.0

Critères de réussite :

Pipeline déclenchée sur push
helm lint exécuté sans erreur
Manifests validés avec kubeconform
Chart packagé et versionné depuis le tag
Publication automatique vers registry OCI

À retenir

Lint : helm lint --strict + ct lint pour la qualité
Test : helm template + kubeconform pour valider les manifests
Package : versioning automatique depuis Git tag
Publish : helm push vers registry OCI
Promotion : même chart, values différents par environnement
GitOps : Argo CD / Flux pour les déploiements prod (recommandé)

Prochaines étapes

Formation Helm — Index Retour à la page principale de la formation

GitLab CI/CD Formation complète GitLab CI/CD

GitHub Actions Automatiser avec GitHub Actions