Pipelines CI/CD pour Kubernetes utilisant GitLab CI

Le développement logiciel moderne exige des cycles de déploiement rapides, une évolutivité et une résilience. Kubernetes est devenu la plateforme d’orchestration incontournable, permettant la gestion d’applications conteneurisées évolutives. Lorsqu’il est combiné avec les pipelines CI/CD de GitLab, les déploiements Kubernetes deviennent automatisés, répétables et fiables.

Cet article explore les détails techniques de la configuration des pipelines CI/CD pour Kubernetes en utilisant GitLab CI.

Conditions préalables

Avant de configurer votre pipeline CI/CD, assurez-vous que les exigences suivantes sont satisfaites :

• Compte GitLab : Accès à un dépôt GitLab où le pipeline CI/CD sera configuré.
• Cluster Kubernetes : Un cluster Kubernetes existant tel que Minikube (pour des tests locaux) ou des clusters gérés comme Google Kubernetes Engine (GKE), Amazon EKS ou Azure AKS.
• kubectl : L’outil en ligne de commande Kubernetes doit être installé et configuré pour l’interaction avec le cluster.
• Helm (facultatif) : Gestionnaire de packages Kubernetes pour déployer et gérer des applications.
• GitLab Runner : Assurez-vous que GitLab Runner est installé et enregistré avec votre projet pour l’exécution des tâches CI/CD.
• Docker : Requis pour construire et pousser des images de conteneurs vers un registre de conteneurs.

Configuration de l’intégration Kubernetes avec GitLab

Connecter le cluster Kubernetes

L’intégration de Kubernetes avec GitLab permet un déploiement fluide et une gestion des ressources directement depuis votre pipeline. Suivez ces étapes :

1. Rendez-vous sur le tableau de bord de votre projet GitLab.
2. Naviguez jusqu’à Infrastructure > Clusters Kubernetes.
3. Cliquez sur Ajouter un Cluster Kubernetes et connectez un cluster existant ou créez-en un nouveau en utilisant des fournisseurs de cloud.
4. Attribuez les autorisations appropriées à GitLab en utilisant le Contrôle d’Accès Basé sur les Rôles (RBAC).

Configuration RBAC

RBAC définit les autorisations d’accès aux ressources Kubernetes. Voici un exemple de configuration YAML pour mettre en place le RBAC :

apiVersion: v1

kind: ServiceAccount

metadata:

  name: gitlab-sa

  namespace: default

---

apiVersion: rbac.authorization.k8s.io/v1

kind: ClusterRoleBinding

metadata:

  name: gitlab-cluster-admin

roleRef:

  apiGroup: rbac.authorization.k8s.io

  kind: ClusterRole

  name: cluster-admin

subjects:

- kind: ServiceAccount

  name: gitlab-sa

  namespace: default

Appliquer la Configuration

Appliquez le fichier YAML en utilisant kubectl :

kubectl apply -f gitlab-rbac.yaml

Générer un Token pour l’Authentification

Extrayez le token du compte de service nécessaire pour GitLab :

kubectl -n default get secret $(kubectl -n default get sa/gitlab-sa -o jsonpath='{.secrets[0].name}') -o jsonpath='{.data.token}' | base64 --decode

Collez ce token dans les paramètres de configuration Kubernetes de GitLab.

Configuration du Pipeline CI/CD de GitLab

Définir .gitlab-ci.yml

Le fichier de configuration CI de GitLab définit les étapes du pipeline, les variables et les commandes. Voici un exemple de configuration :

image: docker:20.10

​

stages:

  - build

  - test

  - deploy

​

variables:

  KUBE_NAMESPACE: default

  KUBECONFIG: "/root/.kube/config"

  IMAGE_TAG: $CI_COMMIT_SHA

  REGISTRY: registry.gitlab.com/username/project

​

services:

  - docker:dind

​

before_script:

  - apk add --no-cache curl jq bash git

  - curl -LO https://storage.googleapis.com/kubernetes-release/release/v1.22.0/bin/linux/amd64/kubectl

  - chmod +x ./kubectl && mv ./kubectl /usr/local/bin/kubectl

  - echo "$KUBE_CONFIG" | base64 -d > $KUBECONFIG

  - chmod 600 $KUBECONFIG

​

build:

  stage: build

  script:

    - docker build -t $REGISTRY:$IMAGE_TAG .

    - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY

    - docker push $REGISTRY:$IMAGE_TAG

​

unit-test:

  stage: test

  script:

    - echo "Running tests..."

    - ./run-tests.sh

​

deploy:

  stage: deploy

  script:

    - kubectl set image deployment/my-app my-app=$REGISTRY:$IMAGE_TAG -n $KUBE_NAMESPACE

  only:

    - main

Explication de la Configuration 

• Étapes: Le pipeline est divisé en étapes de construction, de test et de déploiement pour une exécution modulaire.
• Variables: Les variables d’environnement telles que les balises d’image et les espaces de noms simplifient la gestion de la configuration.
• before_script: Installe les dépendances et configure l’authentification Kubernetes.
• Étiquetage des images: Utilise le SHA du commit pour identifier de manière unique chaque version de l’image.
• Déploiement: Met à jour le déploiement Kubernetes en définissant l’image du conteneur.

Gestion des secrets

GitLab CI prend en charge une gestion sécurisée des secrets en utilisant des variables:

1. Accédez à Paramètres > CI/CD > Variables.
2. Ajoutez les variables requises telles que KUBE_CONFIG, CI_REGISTRY_USER et CI_REGISTRY_PASSWORD.

Encodez kubeconfig avant de l’ajouter en tant que variable:

cat ~/.kube/config | base64 | tr -d '\n'

Ajoutez le résultat en tant que KUBE_CONFIG dans GitLab.

Déploiement Helm

Helm simplifie les déploiements Kubernetes avec des graphiques réutilisables. Exemple de configuration Helm:

apiVersion: v2

name: my-app

version: 1.0.0

appVersion: 1.0.0

​

image:

  repository: registry.gitlab.com/username/project

  tag: latest

​

service:

  type: ClusterIP

  port: 80

Ajoutez les commandes Helm au pipeline:

deploy:

  stage: deploy

  script:

    - helm upgrade --install my-app ./helm-chart --set image.tag=$IMAGE_TAG

Outils de surveillance et de débogage

Suivez l’état du pipeline dans GitLab sous CI/CD > Pipelines. Utilisez des outils tels que:

• Prometheus et Grafana: Pour les métriques et la visualisation.
• Tableau de bord Kubernetes: Gestion de cluster.
• kubectl logs: Obtenir les journaux du déploiement.

kubectl logs -f deployment/my-app

Conclusion

Cet article décrit la configuration des pipelines CI/CD pour Kubernetes avec GitLab CI. Il couvre les prérequis, les configurations YAML, la gestion des secrets, les déploiements Helm et les outils de surveillance. Avec cette configuration, les développeurs peuvent construire, tester et déployer des applications conteneurisées de manière efficace et fiable.