L'infrastructure en tant que code : Terraform, Ansible et GitOps
Partie 4 sur 4
8GitOps
Avec GitOps, un dépôt Git contient la description complète de l’état souhaité d’un système, typiquement les applications déployées sur une plateforme Kubernetes et leurs réglages. Un agent installé dans la plateforme, comme Argo CD ou Flux, compare en permanence l’état réel à celui du dépôt, et corrige automatiquement tout écart (figure 3). Pour déployer une nouvelle version, on ne lance aucune commande sur les serveurs : on propose une modification du dépôt, qui est relue, approuvée et fusionnée ; l’agent fait le reste. Une modification manuelle faite directement sur la plateforme est annulée lors de la réconciliation suivante.
Ce modèle « tiré » a un avantage de sécurité notable : les chaînes d’intégration continue n’ont plus besoin de détenir des accès d’administration à la plateforme, puisque c’est l’agent, installé à l’intérieur, qui va chercher les changements. L’historique Git devient le journal complet des déploiements, et revenir en arrière consiste à annuler un enregistrement.
8.1Kubernetes, déclaratif par nature
GitOps s’est développé autour de Kubernetes parce que cette plateforme est elle-même déclarative. On ne lui ordonne pas de lancer trois conteneurs : on lui déclare qu’il doit en exister trois, et des programmes de contrôle internes surveillent en permanence l’état réel pour le rapprocher de cette déclaration, en relançant un conteneur qui s’arrête ou en en déplaçant un quand un serveur tombe. Une déclaration ressemble à ceci :
apiVersion: apps/v1
kind: Deployment
metadata:
name: boutique
spec:
replicas: 3 # trois exemplaires en permanence
selector:
matchLabels: { app: boutique }
template:
metadata:
labels: { app: boutique }
spec:
containers:
- name: boutique
image: registre.example.org/boutique:2.4.1 # version précise
L’agent GitOps ne fait qu’étendre ce principe au dépôt Git : la déclaration de référence n’est plus celle que l’on a envoyée un jour à la plateforme, mais celle qui figure dans le dépôt. Des outils de gabarits permettent de générer ces fichiers pour plusieurs environnements à partir d’une base commune, en ne changeant que les paramètres, comme le nombre d’exemplaires ou les adresses.
9Bonnes pratiques et limites
9.1Bien faire
- Tout passer par le code : interdire, sauf urgence documentée, les modifications manuelles en production, et reporter immédiatement dans le code celles qui ont dû être faites.
- Relire chaque changement, plan joint, avant de l’appliquer, et faire appliquer les changements par une chaîne automatique plutôt que depuis le poste d’un administrateur.
- Séparer les environnements de développement, de test et de production, avec le même code et des paramètres différents.
- Tester : vérification de la syntaxe et du style, analyse automatique des erreurs de sécurité courantes, et règles d’entreprise exprimées elles-mêmes sous forme de code, la politique en tant que code : « aucun stockage public », « tout disque chiffré », « aucune machine sans étiquette de propriétaire ».
- Garder les secrets hors du code, dans un coffre-fort de secrets, et protéger les fichiers d’état.
- Faire de petits changements, fréquents, plutôt que de grandes refontes risquées : un plan court se relit vraiment, un plan de mille lignes se survole.
9.2Les limites
- La complexité : des milliers de lignes de code d’infrastructure demandent les mêmes soins que du code applicatif, avec des développeurs formés.
- Les erreurs à grande échelle : une erreur dans un module partagé se propage partout, et une commande de destruction mal relue peut supprimer un environnement entier en quelques secondes ; les protections contre la suppression des ressources critiques sont indispensables.
- Les dépendances envers les outils, leurs licences et leurs fournisseurs, comme l’a montré le changement de licence de Terraform.
- Les abstractions qui fuient : le même code ne s’applique pas tel quel d’un fournisseur de nuage à l’autre, chacun ayant ses ressources et ses particularités.
9.3Adopter l’infrastructure en tant que code
Peu d’organisations partent de zéro. L’adoption se fait en général par étapes : décrire en code toutes les nouvelles ressources ; importer progressivement les ressources existantes les plus importantes ; automatiser l’application dans une chaîne d’intégration ; puis interdire les modifications manuelles, d’abord en production. La difficulté est autant humaine que technique : les administrateurs doivent apprendre Git, la relecture de code et les tests, les développeurs comprendre les réseaux et la sécurité, et tous accepter qu’une modification urgente passe désormais par une demande de fusion, éventuellement accélérée. C’est l’une des transformations concrètes portées par la démarche DevOps, qui rapproche développement et exploitation (voir DevOps).