Mettre en place un pipeline CI/CD pour Kubernetes : guide complet

TL;DR : Un pipeline CI/CD Kubernetes automatise la construction, les tests et le déploiement de vos applications conteneurisées. Ce guide vous accompagne étape par étape, de la configuration de votre environnement à la mise en production, avec des commandes vérifiables et des solutions aux problèmes courants.

Pour maîtriser ces compétences, découvrez la formation LFS458 Administration Kubernetes.

Qu'est-ce qu'un pipeline CI/CD pour Kubernetes ?

Un pipeline CI/CD Kubernetes est un ensemble automatisé de processus qui compile votre code, construit des images conteneur, exécute des tests et déploie vos applications sur un cluster Kubernetes sans intervention manuelle. Pour tout ingénieur infrastructure suivant une formation Kubernetes, cette compétence constitue un prérequis fondamental.

Selon le rapport State of Kubernetes 2025 de Spectro Cloud, 80% des organisations exécutent Kubernetes en production avec une moyenne de plus de 20 clusters. Sans automatisation CI/CD, vous ne pouvez pas gérer cette complexité.

À retenir : Le déploiement continu Kubernetes réduit les erreurs humaines et accélère votre time-to-market. Les équipes IT passent en moyenne 34 jours ouvrés par an à résoudre des problèmes Kubernetes (Cloud Native Now).

Prérequis avant de commencer

Avant de configurer votre pipeline, vérifiez que vous disposez de :

Exécutez cette commande pour valider votre environnement :

kubectl cluster-info && docker info --format '{{.ServerVersion}}' && helm version --short
# Résultat attendu :
# Kubernetes control plane is running at https://your-cluster:6443
# 24.0.7
# v3.14.0+g3fc9f4b

Vous devez également disposer d'un compte sur un registre d'images (Docker Hub, Harbor, ou votre registre privé) et d'un accès à une plateforme CI/CD (GitLab CI, GitHub Actions, Jenkins, ou ArgoCD).

Étape 1 : Préparer votre cluster pour le déploiement continu

Créer un namespace dédié

Isolez vos déploiements CI/CD dans un namespace spécifique. Vous évitez ainsi les conflits avec vos autres workloads :

kubectl create namespace cicd-demo
kubectl config set-context --current --namespace=cicd-demo
# Résultat attendu :
# namespace/cicd-demo created
# Context "your-context" modified.

Configurer les secrets pour le registre d'images

Votre pipeline doit pouvoir pousser et tirer des images. Créez un secret Docker :

kubectl create secret docker-registry regcred \
  --docker-server=https://index.docker.io/v1/ \
  --docker-username=VOTRE_USERNAME \
  --docker-password=VOTRE_TOKEN \
  --docker-email=votre@email.com \
  -n cicd-demo
# Résultat attendu :
# secret/regcred created

Vérification : Confirmez que votre secret existe :

kubectl get secrets -n cicd-demo
# NAME      TYPE                             DATA   AGE
# regcred   kubernetes.io/dockerconfigjson   1      10s

À retenir : Ne stockez jamais vos credentials en clair dans vos fichiers YAML. Utilisez des secrets Kubernetes ou un gestionnaire externe comme Vault.

Étape 2 : Structurer votre application pour Kubernetes

Créer un Dockerfile optimisé

Un Dockerfile est un fichier texte contenant les instructions pour construire une image conteneur. Voici un exemple multi-stage qui réduit la taille de votre image :

# Build stage
FROM golang:1.22-alpine AS builder
WORKDIR /app
COPY go.mod go.sum ./
RUN go mod download
COPY . .
RUN CGO_ENABLED=0 GOOS=linux go build -o main .

# Production stage
FROM alpine:3.19
RUN apk --no-cache add ca-certificates
WORKDIR /root/
COPY --from=builder /app/main .
EXPOSE 8080
CMD ["./main"]

Préparer les manifestes Kubernetes

Créez un fichier deployment.yaml pour votre application :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: demo-app
  namespace: cicd-demo
spec:
  replicas: 3
  selector:
    matchLabels:
      app: demo-app
  template:
    metadata:
      labels:
        app: demo-app
    spec:
      imagePullSecrets:
        - name: regcred
      containers:
        - name: demo-app
          image: votre-registry/demo-app:latest
          ports:
            - containerPort: 8080
          resources:
            requests:
              memory: "64Mi"
              cpu: "100m"
            limits:
              memory: "128Mi"
              cpu: "200m"

Pour approfondir les stratégies de déploiement, consultez notre guide sur la gestion multi-environnements Kubernetes.

Étape 3 : Configurer votre pipeline CI avec GitHub Actions

Créer le workflow de build

Un workflow CI est une série d'étapes automatisées déclenchées par un événement Git (push, pull request). Créez .github/workflows/ci.yaml :

name: CI Pipeline
on:
  push:
    branches: [main, develop]
  pull_request:
    branches: [main]

env:
  REGISTRY: ghcr.io
  IMAGE_NAME: ${{ github.repository }}

jobs:
  build-and-test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      
      - name: Run tests
        run: go test -v ./...
      
      - name: Build image
        run: docker build -t ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ github.sha }} .
      
      - name: Login to registry
        uses: docker/login-action@v3
        with:
          registry: ${{ env.REGISTRY }}
          username: ${{ github.actor }}
          password: ${{ secrets.GITHUB_TOKEN }}
      
      - name: Push image
        run: docker push ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ github.sha }}

Vérification : Après un push, vérifiez l'exécution dans l'onglet Actions de votre repository GitHub.

Pour une comparaison détaillée des outils, consultez notre comparatif des outils CI/CD pour Kubernetes en 2026.

Étape 4 : Automatiser le déploiement avec ArgoCD

Installer ArgoCD sur votre cluster

ArgoCD est un outil GitOps qui synchronise automatiquement l'état de votre cluster avec votre repository Git. Installez-le :

kubectl create namespace argocd
kubectl apply -n argocd -f https://raw.githubusercontent.com/argoproj/argo-cd/stable/manifests/install.yaml
# Résultat attendu :
# namespace/argocd created
# customresourcedefinition.apiextensions.k8s.io/applications.argoproj.io created
# [...plusieurs ressources créées...]

Attendez que tous les pods soient prêts :

kubectl wait --for=condition=Ready pods --all -n argocd --timeout=300s

Configurer votre première application

Créez une Application ArgoCD qui pointe vers votre repository :

apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: demo-app
  namespace: argocd
spec:
  project: default
  source:
    repoURL: https://github.com/votre-org/demo-app.git
    targetRevision: main
    path: k8s
  destination:
    server: https://kubernetes.default.svc
    namespace: cicd-demo
  syncPolicy:
    automated:
      prune: true
      selfHeal: true

Appliquez cette configuration :

kubectl apply -f argocd-app.yaml
# Résultat attendu :
# application.argoproj.io/demo-app created

Pour comprendre les différences entre les outils GitOps, lisez notre analyse ArgoCD vs FluxCD.

À retenir : Avec GitOps, votre repository Git devient la source de vérité unique. Chaque modification passe par une pull request, ce qui garantit traçabilité et auditabilité.

Étape 5 : Implémenter les tests et validations dans votre pipeline CI/CD Kubernetes

Ajouter des tests de sécurité

Intégrez Trivy pour scanner vos images avant déploiement :

- name: Scan image with Trivy
  uses: aquasecurity/trivy-action@master
  with:
    image-ref: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ github.sha }}
    format: 'table'
    exit-code: '1'
    severity: 'CRITICAL,HIGH'

Selon Orca Security 2025, 70% des organisations utilisent Kubernetes dans le cloud, majoritairement avec Helm. Vous devez scanner vos charts Helm également.

Valider vos manifestes avec Kustomize

Un Kustomize build est une commande qui génère et valide vos manifestes Kubernetes avant déploiement :

kustomize build k8s/overlays/production | kubectl apply --dry-run=client -f -
# Résultat attendu :
# deployment.apps/demo-app configured (dry run)
# service/demo-app configured (dry run)

Cette validation vous permet de détecter les erreurs de syntaxe avant qu'elles n'atteignent votre cluster.

Étape 6 : Surveiller et dépanner votre pipeline

Configurer les notifications

Ajoutez des alertes Slack pour suivre vos déploiements :

- name: Notify Slack
  if: always()
  uses: 8398a7/action-slack@v3
  with:
    status: ${{ job.status }}
    fields: repo,message,commit,author,action,eventName,workflow
  env:
    SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK }}

Vérifier l'état de vos déploiements

Utilisez ces commandes pour diagnostiquer vos déploiements :

# Statut du déploiement
kubectl rollout status deployment/demo-app -n cicd-demo
# Résultat attendu :
# deployment "demo-app" successfully rolled out

# Historique des révisions
kubectl rollout history deployment/demo-app -n cicd-demo

# Logs des pods récents
kubectl logs -l app=demo-app -n cicd-demo --tail=50

Pour approfondir le monitoring, consultez notre section sur le monitoring et dépannage Kubernetes.

Selon Grafana Labs, 75% des équipes utilisent Prometheus et Grafana pour surveiller leurs clusters Kubernetes.

Dépannage : résoudre les problèmes courants

# Diagnostic rapide d'un pod en erreur
kubectl describe pod <nom-pod> -n cicd-demo | grep -A 10 "Events:"

Pour les ingénieurs qui préparent leur certification, ces compétences en déploiement continu sont couvertes dans la formation LFD459 pour développeurs.

Bonnes pratiques pour votre formation Kubernetes ingénieur infrastructure

Appliquez ces principes dans votre pipeline :

• Immutabilité : Chaque build produit une image avec un tag unique (commit SHA)
• Déclaratif : Vos manifestes décrivent l'état souhaité, pas les étapes pour y arriver
• Versionné : Tout votre code infrastructure est dans Git

Pour aller plus loin dans les principes GitOps, explorez notre guide GitOps et Kubernetes : principes, outils et mise en œuvre.

Prochaines étapes pour automatiser votre déploiement Kubernetes

Vous avez maintenant un pipeline CI/CD fonctionnel. Pour consolider vos compétences :

1. Ajoutez des environnements : staging, production avec des overlays Kustomize
2. Implémentez des rollbacks automatiques : ArgoCD peut annuler les déploiements qui échouent les health checks
3. Intégrez la sécurité : policy-as-code avec OPA Gatekeeper

Découvrez les retours d'expérience dans nos avis formation Kubernetes et consultez notre guide complet Formation Kubernetes.

---

Accélérez votre montée en compétences

SFEIR Institute propose des formations officielles Linux Foundation pour maîtriser le déploiement continu Kubernetes :

• LFS458 Administration Kubernetes : 4 jours pour préparer la certification CKA
• LFD459 Kubernetes pour les développeurs : 3 jours pour préparer la certification CKAD
• Kubernetes, les fondamentaux : 1 jour pour découvrir Kubernetes. Pour approfondir, consultez notre formation déploiement et mise en production kubernetes paris présentiel. Pour approfondir, consultez notre formation déploiement et mise en production kubernetes bordeaux présentiel. Pour approfondir, consultez notre formation déploiement et mise en production kubernetes lille présentiel.

Prochaines sessions disponibles : consultez le calendrier des formations ou contactez nos conseillers pour un parcours personnalisé.