Gitlab CI CD Maîtriser GitLab CI/CD - BTS SIO

Sommaire

Qu’est-ce que GitLab CI/CD ?
Les pipelines CI/CD
Les runners GitLab
Configuration initiale
Création d’un pipeline de base
Étendre le pipeline
Scénarios avancés
Sécurité et bonnes pratiques
Déploiement continu
Monitoring et troubleshooting
- Surveillance des pipelines
- Résolution des erreurs communes
Conclusion
Ressources supplémentaires

Qu’est-ce que GitLab CI/CD ?

GitLab CI/CD est un outil d’intégration et de déploiement continus intégré directement dans GitLab. Il permet d’automatiser les processus de construction, de test et de déploiement du code, ce qui réduit les erreurs humaines et accélère le cycle de développement. En l’utilisant, les équipes peuvent collaborer plus efficacement et livrer des logiciels de haute qualité plus rapidement.

Les pipelines CI/CD

Un pipeline est une série de jobs (tâches) qui s’exécutent dans un ordre spécifique. Les pipelines sont définis dans un fichier .gitlab-ci.yml à la racine du dépôt. Ils peuvent être déclenchés par divers événements tels que des commits, des merges ou des tags. Les pipelines sont composés de stages (étapes) et de jobs, où chaque stage peut contenir plusieurs jobs qui s’exécutent en parallèle.

Les runners GitLab

Les runners sont des agents qui exécutent les jobs définis dans vos pipelines. Ils peuvent être hébergés sur vos propres serveurs ou utiliser les runners partagés de GitLab. Les runners peuvent être configurés pour utiliser différents exécutants tels que Docker, Shell, ou Kubernetes, offrant une grande flexibilité dans l’environnement d’exécution.

Configuration initiale de GitLab CI/CD

Installation de GitLab Runner

Pour utiliser un runner, vous devez installer GitLab Runner sur une machine qui exécutera les jobs. Voici comment procéder sur une machine Linux :

1. Télécharger le binaire de GitLab Runner :

curl -L --output gitlab-runner https://gitlab-runner-downloads.s3.amazonaws.com/latest/binaries/gitlab-runner-linux-amd64

2. Rendre le binaire exécutable :

chmod +x gitlab-runner

3. Déplacer le binaire vers le répertoire global :

sudo mv gitlab-runner /usr/local/bin/

4. Créer un utilisateur pour GitLab Runner :

sudo useradd --comment 'GitLab Runner' --create-home gitlab-runner --shell /bin/bash

5. Installer et démarrer le service :

sudo gitlab-runner install --user=gitlab-runner --working-directory=/home/gitlab-runner sudo gitlab-runner start

Enregistrement d’un runner avec votre projet GitLab

Après l’installation, vous devez enregistrer le runner avec votre projet:

1. Obtenir le token d’enregistrement :

Allez dans votre projet.
Naviguez vers Settings > CI/CD > Runners.
Copiez le token sous Specific Runners.

2. Exécuter la commande d’enregistrement :

sudo gitlab-runner register

3. Fournir les informations requises :

URL de GitLab : https://gitlab.com/ ou l’URL de votre instance auto-hébergée.
Token d’enregistrement : Collez le token copié précédemment.
Description du runner : Donnez un nom descriptif.
Tags : (Optionnel) Pour cibler le runner lors de l’exécution des jobs.
Exécuteur : Choisissez entre shell, docker, docker+machine, etc.

Configuration des variables d’environnement dans GitLab

Les variables d’environnement sont essentielles pour stocker des informations sensibles ou des configurations spécifiques. Pour les définir :

Allez dans Settings > CI/CD > Variables.
Cliquez sur Add Variable.
Entrez le Key (nom de la variable) et le Value (valeur).
Vous pouvez masquer la variable pour qu’elle ne soit pas affichée dans les logs.

Création d’un pipeline de base avec GitLab CI/CD

Structure du fichier .gitlab-ci.yml

Le fichier .gitlab-ci.yml définit les pipelines et est composé de jobs, de stages, et de configurations globales. Voici une structure de base :

stages:
  - build
  - test
  - deploy

variables:
  PROJECT_NAME: "mon-application"

before_script:
  - echo "Démarrage du pipeline pour $PROJECT_NAME"

after_script:
  - echo "Fin du pipeline"

build_job:
  stage: build
  script:
    - echo "Compilation du code..."
    - make build

test_job:
  stage: test
  script:
    - echo "Exécution des tests..."
    - make test

deploy_job:
  stage: deploy
  script:
    - echo "Déploiement de l'application..."
    - make deploy

Les jobs et les stages

Jobs : Représentent des tâches individuelles à exécuter (compilation, tests, déploiement).
Stages : Groupent les jobs en phases du pipeline (build, test, deploy). Les jobs d’un même stage s’exécutent en parallèle.

Exemple simple de pipeline

Dans l’exemple ci-dessus, le pipeline comporte trois stages :

Build : Compile le code source.
Test : Exécute les tests unitaires.
Deploy : Déploie l’application si les étapes précédentes sont réussies.

Étendre l’utilisation de pipelines dans Gitlab

Utilisation des artifacts

Les artifacts sont des fichiers générés par un job et transmis aux jobs suivants ou stockés pour téléchargement. Pour les utiliser :

build_job:
  stage: build
  script:
    - make build
  artifacts:
    paths:
      - build/
    expire_in: 1 week

Définition des dépendances entre jobs

Vous pouvez spécifier les dépendances entre jobs pour contrôler l’ordre d’exécution et l’utilisation des artifacts :

test_job:
  stage: test
  script:
    - make test
  dependencies:
    - build_job

Utilisation des caches pour accélérer les builds

Le cache stocke des fichiers entre les jobs pour réduire le temps de téléchargement ou de compilation :

cache:
  paths:
    - .m2/repository  # Pour les dépendances Maven
    - node_modules/   # Pour les dépendances Node.js

Scénarios avancés

Pipelines multi-projets

Les pipelines multi-projets permettent de déclencher un pipeline dans un autre projet :

trigger_downstream:
  stage: deploy
  trigger:
    project: groupe/autre-projet
    branch: master

Pipelines déclenchés

Vous pouvez déclencher des pipelines manuellement ou via des API externes. Pour un déclenchement manuel :

manual_job:
  stage: deploy
  script:
    - echo "Déploiement manuel"
  when: manual

Utilisation des templates et des includes

Pour réutiliser du code entre plusieurs pipelines, utilisez l’instruction include :

include:
  - template: 'Workflows/Maven.gitlab-ci.yml'

Sécurité et bonnes pratiques

Gestion des secrets et variables protégées dans Gitlab CI CD

Variables protégées : Ne sont accessibles que dans les pipelines des branches protégées.
Masquage des variables : Les valeurs ne sont pas affichées dans les logs.

Mise en place des règles de protection des branches

Empêcher les commits directs sur master ou main.
Exiger des merge requests et des approbations pour les modifications.

Audit et conformité avec Gitlab CI CD

Activer les logs d’audit pour suivre les actions des utilisateurs.
Utiliser des outils de scanning de sécurité intégrés pour détecter les vulnérabilités.

Déploiement continu dans Gitlab CI CD

Déploiement vers des environnements de staging et de production

Configurer des environnements permet de gérer les déploiements vers différents stages :

deploy_staging:
  stage: deploy
  script:
    - make deploy-staging
  environment:
    name: staging
    url: https://staging.example.com
  only:
    - develop

deploy_production:
  stage: deploy
  script:
    - make deploy-production
  environment:
    name: production
    url: https://www.example.com
  only:
    - main

Stratégies de déploiement: blue/green et canary releases

Blue/Green Deployment : Maintenir deux environnements identiques et basculer le trafic après les tests.
Canary Releases : Déployer progressivement la nouvelle version à un sous-ensemble d’utilisateurs pour limiter l’impact des éventuels problèmes.

Intégration avec Kubernetes pour le déploiement

GitLab CI/CD s’intègre facilement avec Kubernetes pour le déploiement d’applications conteneurisées.

Étapes pour l’intégration :

Ajouter le cluster Kubernetes à GitLab :
- Naviguez vers Operations > Kubernetes dans votre projet.
- Cliquez sur Add Kubernetes cluster.
Configurer le déploiement dans .gitlab-ci.yml :

deploy_to_kubernetes:
  stage: deploy
  image: bitnami/kubectl:latest
  script:
    - kubectl apply -f k8s/
  environment:
    name: production

Representation integration ci cd et kubernetes

Monitoring et troubleshooting

Surveillance des pipelines

Utilisez l’interface de GitLab pour surveiller l’état des pipelines.
Intégrez des outils de monitoring comme Prometheus pour une surveillance approfondie.

Résolution des erreurs communes dans Gitlab CI CD

Erreurs de syntaxe dans .gitlab-ci.yml : Validez le fichier avec le linter intégré de GitLab.
Problèmes de permissions : Vérifiez les droits d’accès aux runners et aux ressources externes.
Échecs intermittents : Identifiez les dépendances non stables ou les problèmes de ressources.

Optimisation des performances

Paralléliser les jobs : Utilisez plusieurs runners pour exécuter des jobs en parallèle.
Utiliser des images Docker optimisées : Réduisez la taille des images pour accélérer les téléchargements.
Mettre en cache les dépendances : Évitez de retélécharger les mêmes dépendances à chaque exécution.

Conclusion

GitLab est un outil puissant qui, lorsqu’il est utilisé efficacement, peut transformer la façon dont on peut livrer un logiciel. En exploitant ses fonctionnalités avancées, on peut automatiser l’intégralité du cycle de développement, du code au déploiement, tout en maintenant des normes élevées de qualité et de sécurité.

Ressources supplémentaires