Un guide simple pour GitOps

Vous avez probablement entendu parler de DevOps (Developer Operations), qui automatise les processus de déploiement des applications. Si vous êtes un professionnel des données, vous connaissez probablement MLOps (Machine Learning Operations), qui rationalise le déploiement des modèles. Mais qu'en est-il de GitOps?

Dans ce blog, nous allons explorer GitOps, pourquoi il est important, les différents modèles de GitOps, et enfin, comment intégrer GitOps dans un grand projet de modèle de langage. 

Image par l'auteur

Vous pouvez également apprendre la théorie derrière les concepts DevOps et MLOps en suivant deux de nos meilleures formations courtes, Concepts DevOps et Concepts MLOps.

Qu'est-ce que GitOps ?

GitOps est un cadre opérationnel qui étend les principes DevOps à l'automatisation de l'infrastructure. Il met l'accent sur les enseignements clés de DevOps, tels que le contrôle des versions, la collaboration et la conformité, CI/CDet l'observabilité, et les applique au provisionnement et à la gestion de l'infrastructure, en particulier dans les environnements cloud modernes.

À la base, GitOps automatise la gestion de l'infrastructure en traitant les configurations comme du code, souvent appelé Infrastructure as Code (IaC). Tout comme les équipes de développement utilisent le code source pour créer des binaires d'application de manière cohérente, les équipes d'exploitation utilisent des fichiers de configuration stockés dans des référentiels Git pour s'assurer que le même environnement d'infrastructure est déployé à chaque fois. Cette approche garantit la cohérence, la fiabilité et la reproductibilité.

Composants clés d'un flux de travail GitOps :

1. Dépôt Git: Stocke à la fois le code source de l'application et les fichiers de configuration de l'infrastructure.
2. Pipeline de livraison continue (CD) : Automatise la construction, les tests et le déploiement des changements apportés à l'application et à l'infrastructure.
3. Outil de déploiement d'applications : Veille à ce que les applications soient déployées correctement et efficacement sur la base des configurations contenues dans le référentiel Git.
4. Système de surveillance : Cursus des performances et de l'état de santé des applications afin de maintenir la fiabilité du système.

Pourquoi utiliser GitOps ?

La gestion de l'infrastructure est traditionnellement manuelle, mais le cloud moderne exige l'automatisation pour gérer la vitesse et l'échelle des applications natives du cloud. Avec GitOps, l'infrastructure devient élastique et fiable, ce qui permet aux équipes de déployer les changements rapidement et de manière cohérente. Il élimine les erreurs manuelles, améliore l'efficacité et garantit que l'infrastructure et les applications sont toujours synchronisées, répondant ainsi aux besoins rapides des flux de développement modernes.

Principaux avantages de GitOps :

1. Contrôle des versions : Toutes les modifications apportées à l'infrastructure et aux applications sont contrôlées par version dans Git, ce qui permet de revenir facilement en arrière et de disposer de pistes d'audit complètes.
2. Amélioration de la collaboration : Les équipes peuvent collaborer plus efficacement en utilisant les flux de travail familiers de Git, tels que les demandes d'extraction.
3. Fiabilité accrue : Les configurations déclaratives garantissent que l'état souhaité du système peut être automatiquement rétabli en cas de défaillance.
4. Automatisation : Il minimise la nécessité d'une intervention manuelle, réduisant ainsi le risque d'erreur humaine.
5. La sécurité : L'historique des livraisons de Git constitue un enregistrement immuable, ce qui renforce la sécurité et la traçabilité.

Modèle GitOps basé sur le Pull ou le Push

Dans l'approche GitOps, il existe deux modèles principaux pour le déploiement et la gestion des configurations d'infrastructure et d'application : le modèle "pull-based " et le modèle "push-based". Ces modèles diffèrent par la manière dont ils traitent les changements de configuration et les appliquent à l'environnement cible.

Modèle basé sur l'extraction (GitOps typique)

L'approche "pull-based" repose sur le stockage de l'état souhaité du système dans un dépôt Git. Un opérateur GitOps, tel que Flux ou Argo CD, surveille en permanence les modifications apportées au dépôt. Lorsque des mises à jour sont détectées, l'opérateur extrait automatiquement la configuration mise à jour et l'applique à l'environnement cible. 

Le modèle basé sur l'extraction permet également de détecter les dérives et de s'auto-réparer, car le cluster "tire" continuellement l'état souhaité de Git. Ainsi, toute modification involontaire ou dérive de configuration dans l'environnement est automatiquement corrigée, ce qui permet de maintenir la cohérence et la stabilité.

Modèle basé sur la poussée (utilisation d'outils CI/CD)

L'approche basée sur le push s'appuie sur des outils tels que GitHub Actions ou d'autres services CI/CD pour pousser les mises à jour vers le cluster à chaque fois que des modifications sont apportées. Contrairement au modèle basé sur la traction, l'approche basée sur la poussée manque de réconciliation continue, ce qui signifie qu'il n'y a pas de détection de dérive intégrée ou de retour en arrière automatisé. Cela la rend moins résistante aux changements involontaires de l'environnement. Cependant, le modèle basé sur le "push" est souvent plus simple à mettre en œuvre et permet un contrôle granulaire des déploiements.

Intégrer GitOps dans le projet LLM 

Nous nous concentrerons sur une approche GitOps basée sur le push en utilisant les GitHub Actionscar elle est plus simple à mettre en place et ne nécessite qu'un minimum de connaissances préalables. Bien qu'un système basé sur le push n'offre pas tous les avantages d'une approche basée sur le pull, il fournit néanmoins des fonctionnalités GitOps essentielles telles que des configurations contrôlées par version, des déploiements automatisés et des retours en arrière simplifiés.

Dans cette section, nous appliquerons les principes GitOps au projet du tutoriel How to Deploy LLM Applications Using Docker : Un guide étape par étape. Ce projet comprend le code d'une application Gradio, un fichier Docker et requirements.txt. Elle montre comment déployer une application d'IA dans le cloud à l'aide de Docker.

Source : Comment déployer des applications LLM en utilisant Docker : Un guide pas à pas

Adoptez un état d'esprit MLOps pour former, documenter, maintenir et développer efficacement vos modèles d'apprentissage automatique en vous inscrivant à ce cours, Développer des modèles d'apprentissage automatique pour la production avec un état d'esprit MLOps.

Structure du projet

Ce projet GitOps est conçu pour déployer des applications de grand modèle linguistique (LLM) à l'aide de Docker, Kubernetes et des actions GitHub. Le projet organise tous les fichiers du projet LLM dans le dossier app, crée un dossier infra pour les configurations Kubernetes, et utilise .github/workflows/ pour l'automatisation CI/CD avec GitHub Actions.

• Docker veille à ce que l'application fonctionne de manière cohérente dans tous les environnements en l'empaquetant avec toutes les dépendances.
• Kubernetes automatise le déploiement, la mise à l'échelle et la gestion de l'application.
• Les actions GitHub automatisent les tests, la construction et le déploiement de l'application.

Suivez le cours Introduction à Kubernetes Apprenez les bases de Kubernetes et déployez et orchestrez des conteneurs à l'aide de Manifests et d'instructions kubectl.

Cette structure garantit des déploiements automatisés, évolutifs et spécifiques à l'environnement pour votre application LLM, en suivant les principes modernes de GitOps.

Deploying-LLM-Applications-with-Docker/
├── app/
│   ├── requirements.txt      <-- Python dependencies for your LLM app
│   ├── main.py               <-- Your LLM application code
│   └── Dockerfile            <-- Docker instructions for building the app
├── infra/
│   ├── dev/                  <-- Dev environment configs (YAML or Helm)
│   ├── staging/              <-- Staging environment configs
│   └── production/           <-- Production environment configs
└── .github/
    └── workflows/
        ├── ci.yaml           <-- GitHub Actions workflow for continuous integration
        └── cd.yaml           <-- GitHub Actions workflow for continuous deployment

Voici une ventilation simple :

• app/: Contient le code de l'application (main.py), les dépendances (requirements.txt) et un fichier Docker pour construire l'application dans un conteneur.
• infra/: Contient des configurations Kubernetes pour différents environnements :
• les dossiers dev/, staging/ et production/ pour les paramètres spécifiques à l'environnement.
• .github/workflows/: Automatise le CI/CD avec les actions GitHub :
• ci.yaml : Construit l'application et l'image docker.
• cd.yaml : Déploie l'application en poussant des images Docker et en appliquant des configurations Kubernetes.

Découvrez la différence entre Kubernetes et Docker en lisant l'article sur la différence entre Kubernetes et Docker. Kubernetes vs Docker .

Aperçu du flux de travail des actions GitHub

C'est ce qui se passe dans le flux de travail des actions GitHub :

Developer commits code + config to GitHub
               |
               v
      GitHub Actions CI (ci.yaml)
       - Builds Docker image
       - (Optional) pushes Docker image
               |
               v
     GitHub Actions CD (cd.yaml)
       - Deploys updated app/config
       - kubectl apply or helm upgrade
               |
               v
      Kubernetes Cluster Updated

1. Le développeur apporte des modifications : Les mises à jour du code et de la configuration sont poussées sur GitHub.
2. CI Pipeline (ci.yaml):
• Construit l'image Docker.
• Il est possible d'ajouter l'image au registre des conteneurs.
• Exécutez des tests pour valider l'application.
3. CD Pipeline (cd.yaml):
• Déploie l'application ou la configuration mise à jour.
• Exécute kubectl apply ou helm upgrade pour mettre à jour les manifestes Kubernetes.
4. Mise à jour de Kubernetes Cluster : Le cluster exécute la nouvelle version de l'application.

Apprenez à automatiser l'entraînement, l'évaluation, la gestion des versions et le déploiement des modèles à l'aide des actions GitHub et créez un fichier en suivant les instructions ci-dessous. Guide de CI/CD pour l'apprentissage automatique à l'intention des débutants pour l'apprentissage automatique.

Principaux avantages et compromis de l'utilisation d'une approche GitOps basée sur le Push

Si vous avez une expérience préalable des actions GitHub, la mise en place d'une méthodologie GitOps utilisant une approche basée sur le push peut être simple. Il vous suffit d'ajouter les fichiers de configuration de l'infrastructure, de configurer les pipelines CI/CD et vous êtes prêt à partir. Cependant, bien que cette approche soit simple, il y a plusieurs compromis importants à prendre en compte.

Avantages

• Simple: Vous n'avez besoin que d'Actions GitHub pour mettre en œuvre cette approche - il n'y a pas besoin d'un opérateur GitOps supplémentaire comme Argo CD ou Flux.
• Guichet unique: GitHub Actions offre une plateforme unique pour construire, tester et déployer votre application, rationalisant ainsi l'ensemble du processus.

Compromis

• Ce n'est pas vrai: Contrairement aux outils GitOps basés sur les flux (pull) comme Argo CD, cette approche ne permet pas une "réconciliation continue". Cela signifie que l'état du cluster n'est pas automatiquement contrôlé et réconcilié avec l'état souhaité dans Git.
• Pas de détection de dérive: Si quelqu'un modifie manuellement des ressources dans le cluster, ces modifications ne seront pas automatiquement annulées pour correspondre au dépôt Git. Cela peut entraîner une dérive de la configuration au fil du temps.
• Sécurité: Pour permettre aux actions GitHub de se déployer dans votre cluster, vous devez stocker les informations d'identification du cluster dans les secrets GitHub ou utiliser une méthode d'authentification basée sur OIDC. Les deux approches nécessitent une manipulation prudente pour éviter les risques de sécurité.

Passage à un modèle basé sur la traction

Lorsque votre projet prend de l'ampleur ou que vos besoins deviennent plus exigeants, la transition vers un modèle GitOps basé sur le tirage peut offrir des avantages significatifs. Si votre équipe a besoin de fonctionnalités telles que l'autoréparation, la réconciliation continue ou un tableau de bord visuel, l'adoption d'un outil basé sur les flux (pull-based) tel qu'Argo CD ou Flux pourrait être la prochaine étape logique.

• Autocicatrisation: Revenez automatiquement sur l'état des clusters s'ils dérivent.
• Rapprochement continu: Surveillez votre dépôt Git pour les changements de configuration 24 heures sur 24, 7 jours sur 7.
• Tableau de bord visuel: Pour vérifier l'état des applications et les journaux.

Vous pouvez passer à un outil basé sur la traction comme Argo CD ou Flux. Ils surveilleront constamment votre dépôt et veilleront à ce que le cluster corresponde toujours à ce qui se trouve dans Git - aucune étape manuelle de "push" n'est nécessaire après le commit initial.

Conclusion

Pour mettre en œuvre efficacement GitOps, il est préférable de commencer à petite échelle et d'adopter progressivement ses technologies. Commencez par un simple fichier Docker pour conteneuriser votre application et la déployer dans le cloud. Ensuite, présentez Kubernetes pour permettre l'évolutivité et la fiabilité grâce à un déploiement et une gestion automatisés. 

Une fois à l'aise, adoptez une approche GitOps basée sur le push en utilisant des outils comme GitHub Actions pour automatiser à la fois l'infrastructure du cloud et le déploiement des applications. Enfin, lorsque votre projet arrive à maturité et nécessite une stabilité au niveau de la production, passez à un modèle basé sur le tirage avec des outils tels qu'Argo CD ou Flux pour obtenir une réconciliation continue, une détection des dérives et des capacités d'autoréparation. 

Cette progression pas à pas garantit une courbe d'apprentissage en douceur tout en exploitant le plein potentiel de GitOps pour les applications cloud-natives modernes.

Dans ce blog, nous avons exploré GitOps, son importance, les différents modèles GitOps et comment intégrer GitOps dans un projet d'IA. Si vous êtes novice en matière d'IA, nous vous recommandons vivement de suivre le cours Fondamentaux de l'IA qui couvre les fondamentaux de l'IA, approfondit les modèles tels que GPT-4o, et découvre les secrets de l'IA générative pour naviguer dans le paysage évolutif de l'IA.