Le sujet d'aujourd'hui est quelque chose dont presque tout le monde a entendu parler, mais que très peu savent réellement expliquer. GitOps. Vous l'avez probablement déjà vu mentionné dans des offres d'emploi, des conférences ou la documentation Azure. Mais qu'est-ce que c'est exactement ? Juste un énième mot à la mode du DevOps, ou est-ce quelque chose de fondamentalement différent ? Voici la version courte. GitOps est un modèle opérationnel où Git devient la source unique de vérité pour toute votre infrastructure, pas seulement. Votre code applicatif, mais tout ce qui le fait, fonctionner, mais tout ce qui le fait, fonctionne. A la fin de cet épisode, vous comprendrez ce qu'est réellement GitOps, pourquoi c'est devenu la norme pour gérer Kubernetes sur Azure, les retours en arrière aussi simples qu'une seule commande, l'ancienne méthode, les déploiements manuels et la dérive de configuration. Commençons par le problème que GitOps résout. Imaginez que vous gérez un cluster Kubernetes sur Azure, vous avez des développeurs qui poussent du code, un pipeline CI qui construit des images de conteneurs, et quelqu'un exécute qu'un exécute kubectl à Playaco pour déployer ces images. Peut-être vous, peut-être un coéquipier ? Vous cliquez sur un bouton dans Azure DevOps, et dans tous les cas, le déploiement se produit. Cela fonctionne très bien jusqu'à ce que ce ne soit plus le cas. Voici ce qui se passe ensuite. Quelqu'un de votre équipe doit corriger un bug rapide, alors il se connecte en SSH à un nœud, utilise le portail Azure, ou exécute kubectl à l'édit à gueule directement sur un déploiement. Il fait un petit changement comme ajuster une config map, ou modifier une variable d'environnement, et cela semble inoffensif. Enfin, c'est ce qu'il pense. Le problème, c'est que ce changement n'a jamais été répercuté dans Git, donc votre cluster a maintenant une configuration qui ne correspond plus à ce qu'il y a dans votre dépôt. C'est ce qu'on appelle la dérive de configuration drift. La dérive est un tueur silencieux, car tout fonctionne jusqu'au prochain déploiement, quand quelqu'un exécute kubectl à Playqmec le manifeste original, et écrase cette correction rapide. Ou pire, la dérive provoque un comportement inattendu que personne ne peut expliquer. Vous commencez à déboguer, vérifiez les logs, regardez les YAML dans Git, et rien ne semble anormal, mais le cluster fait quelque chose de différent. Vous n'avez aucune idée de ce qui a changé, quand cela a changé, ou qu'il a changé. J'ai déjà vu cela arriver. Un coéquipier se connecte en SSH à un nœud, ajuste une configuration pour tester quelque chose, oublie de l'annuler, et rentre chez lui. Le lendemain, un déploiement échoue, personne ne peut expliquer pourquoi. Le dépôt Git semble propre, mais le cluster est en désordre, et vous restez coincé à passer des heures à essayer de comprendre ce qui s'est passé. Alors voici la question. S'il y avait un moyen de forcer le cluster à toujours correspondre à ce qui se trouve dans Git. Si vous pouviez garantir que tout ce qui se trouve dans votre dépôt est exactement ce qui tourne en production, c'est l'idée centrale derrière GitOps. Ce qui est réellement GitOps ? Alors qu'est-ce que GitOps exactement ? Voici la définition la plus simple que je puisse vous donner. Deviens votre source unique de vérité, non seulement pour votre code, mais pour tout ce dont votre infrastructure a besoin. Chaque configuration, chaque manifeste de déploiement, chaque variable d'environnement, tout réside dans Git. Rien ne s'exécute sur votre cluster si ce n'est pas défini là-bas. GitOps n'est pas un outil que l'on peut acheter. C'est un modèle opérationnel comme DevOps ou DevSecOps. Un ensemble de principes qui guident la gestion de votre infrastructure. Le standard OpenGitOps définit 4 principes fondamentaux et je vais les passer en revue. Premièrement, votre système doit être déclaratif. Cela signifie que vous décrivez l'état final et non les étapes pour y parvenir. Au lieu d'écrire un script qui dit « Créer un déploiement, mettre à 5 répliques, exposer le port 8080 », vous écrivez un fichier YAML qui dit « Je veux 5 répliques sur le port 8080 et le système détermine les étapes. » Et c'est ça, être déclaratif. Deuxièmement, il doit être versionné. Chaque modification apportée à l'état de votre cluster est incombinante. Ainsi, vous obtenez un historique complet de qui a changé, quoi, quand et pourquoi. Plus besoin de deviner ou de fouiller dans les lones. Troisièmement, les changements sont extraits automatiquement. Le cluster contact Git pour voir ce qu'il y a de nouveau. Plus tard, j'expliquerai pourquoi c'est si important. Et quatrièmement, le système est réconcilié en continu. Un agent logiciel s'exécute dans votre cluster et compare constamment ce qui est dans Git avec ce qui tourne, réellement. S'ils ne correspondent pas, ils corrigent la différence. C'est la boucle de réconciliation. Mais il est juste de cette façon. Git est le plan d'autre architecte. Il décrit exactement à quoi doit ressembler le bâtiment, que Bernetta, c'est le chantier de construction. Et l'opérateur GitOps, c'est le chef de chantier. Il se promène avec le plan, vérifiant chaque mur, chaque fenêtre, chaque fenêtre. Si quelque chose ne correspond pas, il le corrige. Supposons qu'un membre de l'équipe fasse une modification non autorisée, il la repère et l'annule. Le plan est toujours la source de vérité. C'est là que le véritable changement opère. Comment fonctionnent réellement les déploiements ? Dans le CISOCD traditionnel, vous poussez les changements vers le cluster. Dans GitOps, le cluster les extrait. Et cette différence est plus importante qu'il n'y paraît. Déploiement par tirage pull versus par poussée pull. Parlons du fonctionnement réel des déploiements, car c'est là que GitOps change tout. Dans le modèle traditionnel par poussée, votre pipeline CI fait tout. Azure Pipelines, Jenkins, GitHub Actions. Il construit le conteneur, exécute les tests, puis pousse l'image directement vers votre cluster Kubernetes. Le pipeline détient des identifiants, lui donnant un accès direct à l'API du cluster. Voici le nouveau déploiement. Applique-le maintenant. Cela fonctionne, mais crée un problème de sécurité. Le souci, c'est que si ce pipeline est compromis, qu'une étape malveillante est injectée, qu'un jeton fuite ou qu'une dépendance est détournée, le pipeline, a une ligne directe vers votre cluster de production. Il peut détruire des déploiements, supprimer des espaces de nom, modifier des configurations. Tout cela avec les permissions que vous lui avez accordées. Regardez maintenant le modèle GitOps. Le flux commence de la même manière. L'intégration continue construit le conteneur et le pouce vers un registre comme Azure Container Restrict. C'est là que l'intégration continue s'arrête. Elle ne touche pas au cluster. Au lieu de cela, l'intégration continue met à jour un dépôt Git avec la nouvelle balise d'images. Elle modifie une seule ligne dans un fichier YAML. La version de l'image est valide. Ce changement, c'est tout. Aucun accès direct au cluster. Ensuite, l'opérateur GitOps, exécuté dans votre cluster, détecte ce changement. Il récupère le dernier état du puits Git et l'applique. C'est le cluster qui contacte Git et non l'inverse. C'est le modèle basé sur le pull. Votre cluster n'expose jamais son API à des systèmes externes, se contente de récupérer données puits Git. Si quelqu'un compromet votre pipeline d'intégration continue, le pire qu'il puisse faire est de modifier un manifeste dans un dépôt. Il ne peut pas toucher directement au cluster. L'opérateur décide de ce qu'il faut appliquer et quand. Il y a un autre avantage. Vous découplez la construction du déploiement. Intégration continue fait ce qu'elle fait de mieux construire, tester, analyser. L'opérateur GitOps gère le déploiement. Chaque système se concentre sur une tâche. Si la construction échoue, rien ne change dans le cluster. Si le déploiement échoue, l'opérateur re-essai ou vous alerte. Une séparation nette. Ainsi, au lieu d'un pipeline qui pousse des changements dans votre cluster, votre cluster extrait son état souhaité depuis Git. Cette simple inversion rend votre infrastructure plus sûre, plus facile à auditer et plus difficile à casser accidentellement. La boucle de réconciliation. Or, comment l'opérateur s'est-il mis à jour ? Il n'attend pas de notification. Il exécute une boucle continue. Surveillez Git, comparez avec le cluster, appliquez les changements si nécessaire, puis recommencez indéfiniment. C'est ce qu'on appelle la boucle de réconciliation. S'exécute en permanence, toutes les quelques secondes ou minutes selon votre configuration. L'opérateur ne cesse jamais de surveiller. Imaginez cela comme un thermostat dans votre maison. Pour régler la température souhaitée, disons 21 de Bc, le thermostat vérifie constamment la température réelle. S'il descend en dessous de 21, le chauffage s'allume. S'il dépasse cette température, le chauffage s'éteint. Il continue de s'ajuster pour correspondre à votre réglage. L'opérateur GitOps fonctionne de la même manière. Git contient l'état souhaité, le cluster possède l'état réel et l'opérateur les compare en continu pour effectuer les ajustements. Alors que se passe-t-il si quelqu'un modifie maintenant un déploiement dans le cluster. Peut-être exécute-t-il kubectl edit pour changer un nombre de réplicas. L'opérateur détecte cette différence lors de son prochain cycle de réconciliation. Le cluster possède maintenant 3 réplicas, mais Git en indique 5. L'opérateur applique donc l'état défini dans Git et le cluster revient à 5 réplicas. La modification n'en autorisée a disparu. Que se passe-t-il lorsque vous envoyez une modification ? Le même processus. L'opérateur détecte la différence et l'applique. Un développeur fusionne une PR qui met à jour la version de l'image de l'AV 1.2 à l'AV 1.3. L'opérateur voit le nouveau manifeste, récupère la nouvelle image et lance les nouveaux pods. En quelques secondes, le cluster correspond nouveau à Git. Et il y a ici une distinction importante. Si un pod plante, l'opérateur ne s'en préoccupe pas. C'est le rôle de Kubernetes, géré par le contrôleur de réplicaset. L'opérateur GitOps ne s'intéresse qu'à la configuration. Si le manifeste de déploiement indique 5 réplicas et l'image V1.3 et que le cluster a 5 réplicas en V1.3, l'opérateur est satisfait, l'opérateur est satisfait. Il se désintéresse du redémarrage d'un pod spécifique. C'est un comportement normal de Kubernetes. Mais si quelqu'un modifie le manifeste dans Git ou modifie directement le cluster et crée une dérive, l'opérateur intervient. C'est ce qui rend GitOps autoréparateur. Il ne se contente pas de déployer des changements. Il empêche activement votre infrastructure de dérivés par rapport à ce qui est défini. Vous avez donc besoin d'un opérateur GitOps exécuté dans votre cluster. C'est là qu'interviennent ArgoCD et Flux. ArgoCD contre Flux. Vous avez besoin d'un opérateur GitOps. Vous avez deux choix principaux. Tous deux excellents. ArgoCD et Flux sont tous deux des projets diplômés de la CNCF, ce qui signifie qu'ils répondent aux critères les plus exigeants en matière de stabilité, de communauté et de préparation à la production. Mais ils abordent le même travail sous des angles différents. ArgoCD a été initialement créé par Intuit et est doté d'une interface web. Lorsque vous installez ArgoCD, vous obtenez un tableau de bord où vous pouvez voir chaque application, son statut de synchronisation, sa santé et son historique de déploiement. Vous pouvez naviguer, visualiser les différences entre Git et le cluster, déclencher manuellement des actions et approuver des changements. Il est conçu pour les équipes qui souhaitent des tableaux de bord visuels et des points de contrôle manuels. Flux provient de WeWorks et il est plus modulaire. Il n'y a pas d'interface U7R par défaut. Vous travaillez depuis la ligne de commande et vous définissez tout comme des ressources personnalisées Kubernetes. Vous créez un objet de dépôt Git qui indique surveille ce dépôt et un objet de personnalisation qui dit applique ce chemin. Flux le détecte et effectue la réconciliation. Cela vous oblige à adopter des flux de travail Git natif car il n'y a pas de tableau de bord pour se rabattre. Voici maintenant ce qui compte pour les utilisateurs d'Azure. Flux est l'option GitOps par défaut sur Azure Kubernetes Service. Microsoft a construit une intégration native autour de Flux V2. Lorsque vous activez GitOps sur un cluster AKS via le portail Azure, vous utilisez Flux en arrière-plan. Azure Arc utilise également Flux pour la gestion multi-cluster. Donc si vous êtes ingénieur Azure, Flux est le point de départ naturel. Argo est cédé à ses propres points forts. Il est plus populaire pour les scénarios d'ingénierie de plateforme où vous voulez un plan de contrôle central gérant plusieurs clusters. L'interface utilisateur facilite la tâche des équipes qui ne sont pas à l'aise avec la ligne de commande. Et il s'intègre étroitement à Argo Rollouts pour la livraison progressive comme les déploiements canaris, bleu slash vert, ce genre de choses. La différence architecturale clé est la suivante. Argo CD fonctionne comme une application autonome avec son propre serveur API. Flux exécute comme un ensemble de contrôleurs Kubernetes plus profondément intégrés dans le cluster lui-même. Flux semble faire partie de votre plan de contrôle Kubernetes tandis qu'Argo CD ressemble à une plateforme distincte située au-dessus. Flux appuie également fortement sur Customize qui est un outil de templating natif de Kubernetes. Argo CD peut utiliser Customize, Helm ou du YAML simple. Les deux prennent en charge Helm mais Flux dispose d'un contrôleur Helm dédié qui gère les releases Helm nativement. Il n'y a pas de mauvais choix ici. Les deux outils font le même travail. Mais pour les ingénieurs Azure, Flux est la voie de la moindre résistance. Vous pouvez activer GitOps avec Flux en quelques clics via le portail Azure, le pointeur vers un dépôt Git et la synchronisation commence. Pas d'installation supplémentaire, pas de serveur séparé à gérer. GitHub sur Azure AKS, Azure Arc et Azure DevOps. Alors à quoi cela ressemble-t-il vraiment quand on l'associe à Azure ? Commençons par AKS. Azure Kubernetes Service dispose d'une prise en charge GitOps intégrée utilisant Flux V2. Dans le portail Azure, vous allez sur votre cluster, trouver la section GitOps et la configurer en la pointant vers un dépôt Git. Azure Repose, GitHub, n'importe où. Flux commence à surveiller et tous les manifestes que vous placez dans ce dépôt sont appliqués automatiquement à votre cluster. AKS n'est qu'une pièce du puzzle. Azure Arc est en GitOps aux clusters qui ne sont pas dans Azure, sur site, dans d'autres clouds ou en périphérie. Connectez-les à Azure Arc et vous les gérez tous avec la même configuration GitOps. Un dépôt, plusieurs clusters, un état cohérent partout. C'est ce que fait Arc. Maintenant, parlons du pipeline. Azure DevOps s'intègre naturellement à ce modèle. Voici le schéma classique. Votre code source réside dans Azure Repo où GitHub et Azure Pipelines gèrent l'intégration continue. Il construit l'image de conteneur, exécute les tests, analyse les vulnérabilités et pousse l'image vers Azure Container Registry. Ensuite, le pipeline met à jour les manifestes dans votre dépôt GitOps en changeant la balise d'image de V1.2 vers V1.3 valide ce changement et le pousse. C'est tout. Le pipeline ne touche jamais au cluster. Flux, exécuté au sein d'AKS, détecte le changement dans Git, récupère le nouveau manifeste, voie la balise d'image mise à jour et applique le déploiement. De nouveaux pods démarrent et le cluster se réconcilie. Vous pouvez utiliser GitHub Actions plutôt qu'Azure Pipeline si vous préférez. Le modèle reste le même. L'intégration continue gère la construction et la mise à jour des manifestes et l'opérateur GitOps gère le déploiement. L'outil importe peu, c'est le modèle qui compte. Voici un détail important. Ne stockez jamais de secret directement dans Git ni clé API, ni chaîne de connexion, ni certificat. Même dans un dépôt privé, les secrets dans Git représentent un risque. Utilisez plutôt Azure Key Vault ou un opérateur de secret externe. Le manifeste référence le secret par son nom et l'opérateur récupère la valeur réelle du coffre au moment du déploiement du déploiement. Vous pouvez également ajouter une couche de stratégie par-dessus. Azure Policy avec Gatekeeper peut appliquer des règles comme l'interdiction des conteneurs privilégiés ou l'utilisation exclusive de registres approuvés. Si quelqu'un tente de déployer un manifeste qui en fera une règle, Gatekeeper le bloque avant qu'il n'atteigne le cluster. L'avantage réel ici réside dans l'imdiation. Avec 50 clusters à caisse, vous ne gérez pas chacun individuellement. Définissez l'état souhaité dans un dépôt. Git unique et chaque cluster se réconcilie sur cet état. Ajoutez un nouveau cluster, pointez-le vers le dépôt et il se configure tout seul. Besoin de mettre à jour une configuration sur tous les clusters ? Modifiez un seul fichier dans Git et les opérateurs s'occupent du reste. C'est la promesse de GitHub sur Azure. Une source unique de vérité. De nombreux clusters occupent dérive. Les avantages clés. Tout cela semble bien en théorie, mais qu'est-ce que cela signifie concrètement pour votre équipe ? Commençons par ce qui retient l'attention de tous. Les retours en arrière deviennent tri. Un mauvais déploiement est effectué, votre application génère des erreurs, les utilisateurs se plaignent. Avant, vous deviez chercher fébrilement la dernière configuration connue, exécuter une série de commandes manuelles et prier pour ne rien oublier. Avec GitHub, vous annulez simplement le communier. C'est tout. Une seule commande. L'opérateur détecte l'annulation, récupère l'état précédent et le cluster revient à ce qui fonctionnait auparavant. Plus besoin de SSH, plus besoin de kubectl et surtout, plus de panique. Une piste d'audit est intégrée automatiquement. Chaque modification de votre infrastructure est un commit. Vous savez qui l'a faite, quand et exactement ce qui a été modifié. Fini les doutes sur qui a modifié un déploiement à 2h du matin sans rien dire. L'historique est là, immuable et consultable. L'autoguerison est une autre fonction qui semble logique jusqu'à ce qu'on la voit à l'œuvre. Quelqu'un modifie manuellement un déploiement dans le cluster. Peut-être un ingénieur junior essaie de réparer quelque chose rapidement. L'opérateur détecte la dérive au prochain cycle de réconciliation et l'annule. Le cluster se répare tout seul sans que vous ne sachiez rien, sans consulter les logs. La cohérence entre les environnements devient automatique. Dev, test, staging, production tous tirent les données du même dépôt Git. Des branches ou dossiers différents mais une source de vérité unique. Fini le cas, ça marche sur ma machine n'est qu'à parce que votre cluster de staging a divergé de la prod. La sécurité s'améliore car le cluster récupère les données depuis Git au lieu de les recevoir. Votre pipeline CI ne détient jamais d'identifiant d'accès direct à la production. Si quelqu'un compromet le pipeline, il ne peut pas toucher au cluster. L'opérateur décide de ce qui est appliqué et quand. Le moins de privilèges par conception. Des données viennent aussi confirmer cela. Selon les recherches d'Aura, les équipes adoptant GitOps réduisent de 25% les erreurs de déploiement avec un temps de rétablissement sous les deux minutes. Ce n'est pas de la théorie, c'est ce que rapportent les entreprises et aussi un avantage en termes de collaboration facile à négliger. Les changements d'infrastructure passent par des pull requests, des revues de code et des tests automatisés comme le code applicatif. Votre équipe Ops et votre équipe dev parlent la même langue, Git. Plus de transferts de tâches, plus de quais déploient ça pour moins vu. Tout le monde travaille de la même manière. Mais il reste des malentendus courants qui vaut mieux dissiper. Mythe courant et premier pas. Commençons par éclaircir certains mythe courant sur GitOps. Tout d'abord, beaucoup pensent que GitOps est réservé à Kubernetes. Certes, cela fonctionne mieux sur Kubernetes et c'est indéniable. Kubernetes repose sur un état déclaratif et une réconciliation donc c'est naturel. Mais voici le point clé, ces principes s'appliquent partout où vous avez des configurations déclaratives. Vous pouvez utiliser GitOps avec Terraform, pull ou mi, voir un cible. Il suffit de stocker ces configs dans Git et de laisser un pipeline les appliquer. L'autoguérison est plus complexe hors de Kubernetes mais la discipline de la source de vérité fonctionne partout. Un autre mythe est qu'il faut absolument argocéder au flux pour faire du GitOps. Si vous voulez le modèle complet, le déploiement par tirage, la réconciliation continue et la détection de dérive, alors oui, vous avez besoin d'un opérateur GitOps. Mais vous pouvez commencer beaucoup plus simplement, placer tous vos manifestes dans Git et utiliser des pull requests pour vos modifications. Cela vous apporte déjà la plupart des avantages en matière d'audit-collaboration. Vous pourrez toujours ajouter un opérateur plus tard lorsque vous aurez besoin de l'automatisation. Enfin, il existe le mythe selon lequel GitOps remplace entièrement le CI CD. Ce n'est pas le cas. Il remplace la partie CD. La CI continue de compiler votre code, d'exécuter des tests, de rechercher des vulnérabilités et d'envoyer les images de conteneurs vers un registre. Tout cela reste identique. Ce qui change, c'est la manière dont ces images sont déployées. Au lieu que le pipeline CI les pousse dans le cluster, l'opérateur GitOps récupère les manifestes mis à jour depuis Git. Ces CI et GitOps fonctionnent ensemble et non l'un à la place de l'autre. Démarrer est en réalité très simple. Choisissez un petit cluster AKS et activez Flux via le portail Azure. Cela ne prend que quelques clics. Ensuite, pointez vers un dépôt Git contenant un simple YAML de déploiement, observez la synchronisation et vous êtes lancé. Essayez de modifier une valeur dans l'YAML, validez le changement et observez la mise à jour du cluster. C'est votre premier flux de travail GitOps. A partir de là, vous pouvez ajouter des environnements, apprendre Customize, car Flux l'utilise beaucoup et configurer des mises à jour d'images automatisées avec des outils comme Renovate ou des Pandabot. Voilà, donc GitOps en quelques mots. Cela transforme votre infrastructure rendant tout traçable, réversible et auto-réparateur. Si vous gérez Kubernetes sur Azure, essayez l'intégration GitOps dans AKS dès aujourd'hui. Cela prend 10 minutes à configurer et changera votre façon d'envisager les déploiements. Abonnez-vous pour plus d'explications simples sur les outils cloud de Microsoft.