Infrastructure as Code et CI/CD — étude de cas
Valerie Wyns · Étude de cas technique · 2023–2025

Infrastructure as Code et CI/CD : conception, automatisation et retour d'expérience

Dans le cadre d'un projet professionnel autour d'une plateforme d'analyse de composition logicielle (SCA), j'ai conçu et automatisé des parties de l'infrastructure AWS avec Terraform ainsi que les pipelines de build et de déploiement via Jenkins et AWS CodeDeploy. Cette étude de cas présente les principes techniques et les arbitrages, avec du recul sur ce que je referais ou changerais aujourd'hui. Les schémas et libellés ont été simplifiés pour une présentation publique.

Étude de cas rétrospective : descriptions, diagrammes et intitulés simplifiés pour illustrer les choix d’ingénierie sans reproduire une configuration exploitable.

Partie A

Terraform : configurations isolées et exécution contrôlée

Les configurations étaient organisées autour de racines Terraform distinctes et de modules réutilisables, avec une exécution centralisée disposant d'une identité IAM dédiée. Pour reprendre des ressources créées précédemment dans la console AWS, j'ai développé des programmes Go capables de générer des déclarations HCL à partir de données exportées. Les diagrammes ci-dessous sont des vues conceptuelles, non des plans d'exploitation.

A1 · Déroulement d'une exécution

Git code Terraform Ingénieur·e exécution documentée Exécuteur Terraform hôte d’exécution dédié identité IAM dédiée outils nécessaires : Terraform · Git outil de déploiement environnement cible Groupes de sécurité ALB, écouteurs, règles Certificat ACM + Route 53 SNS → Lambda (Slack) Applications CodeDeploy EC2, RDS, AMI région AWS (illustrative) état Terraform séparé par contexte backend distant selon usage mise à jour Git lancée depuis configuration validée plan/apply rôle IAM état
L'exécution reposait sur un point de contrôle commun et une identité IAM dédiée, sans diffuser de clés permanentes sur les postes. La gestion de l'état Terraform était un sujet d'architecture à part entière : séparation des environnements, cohérence et verrouillage des changements.

A2 · Organisation du code

Une racine Terraform assemble des modules fonctionnels en utilisant leurs entrées et sorties. Le graphe illustre comment ces références construisent implicitement l'ordre des opérations. Les noms de modules sont génériques et ne reflètent pas une arborescence de production.

Exemple simplifié · les flèches portent les sorties des modules network-security certificate event-topic app-service event-handler deployment-config target-routing load-balancing routage applicatif id SG id cibles de routage id réseau LB certificate_arn topic-arn événements → notifications services applicatifs concernés
Terraform déduit l'ordre à partir des références entre ressources et modules : les règles réseau et les certificats doivent exister avant les services qui les utilisent. Le schéma est volontairement simplifié pour illustrer la gestion des dépendances.

Organisation modulaire : responsabilités principales

domaineresponsabilitéprincipe de conception
RéseauRègles de sécurité et routageRéférences entre modules
AccèsCertificats et identité d'exécutionParamètres propres aux environnements
ServicesCalcul et ressources applicativesDépendances explicites
DéploiementRessources nécessaires à la livraisonSéparation infrastructure / build
ÉvénementsNotifications et intégrationsComposants remplaçables

La configuration pouvait varier selon l'environnement ou la région. Cette représentation synthétique présente les responsabilités plutôt que les noms de ressources, paramètres ou activations internes.

A3 · Reprendre en code des ressources créées dans la console

AWS existant créé dans la console CSV ressources existantes Générateurs Go text/template .tf dans un module relu à la main describe-instances | jq @csv lecture HCL dépendances revues
Des scripts exportaient les caractéristiques de ressources AWS existantes ; des générateurs Go utilisant text/template produisaient des déclarations Terraform relues manuellement. La séparation de certaines règles réseau en ressources autonomes a permis d'éviter des dépendances circulaires. Cette étape produisait le HCL ; la gestion de l'état Terraform restait un sujet distinct.
Partie B

Jenkins : pipelines versionnés et promotion contrôlée

Les pipelines étaient versionnés dans un dépôt d'automatisation commun. Cette organisation facilitait la revue des changements, la standardisation des étapes et la traçabilité. Une bibliothèque partagée regroupait certaines fonctions transversales, comme les notifications de statut.

B1 · Anatomie d'un job

Presque tous les pipelines suivent la même séquence. Les étapes en pointillé n'existent que pour les applications qui en ont besoin.

  1. Notification Slackdébut d’exécution
  2. Checkoutdépôt et révision
  3. Buildbuild selon projet
  4. Liquibasemigrations de base
  5. Auto-analysecontrôles de dépendances
  6. Bundle zipscripts de livraison
  7. S3 + CodeDeploydemande de livraison
  8. poststatut et durée du job

Un contrôle automatisé des dépendances participait à la qualité de la livraison : une violation de politique pouvait bloquer un build avant sa promotion. Cela illustre le principe de quality gate dans la CI.

B2 · Le chemin d'une release (schéma simplifié)

Dépôt Git révision validée Build-CI build, Liquibase, auto-analyse Validation bundle → préproduction Promotion validation et version Déploiement cible autorisée Tests E2E test de bout en bout Tests techniques différents scénarios Stockage d’artefacts · une version validée artefact testé environnement de test artefact promu version identique push tag de version cible de déploiement build job upstream + planification publication promotion create- deployment
Le principe architectural est de construire une seule fois, tester, puis promouvoir le même artefact sans le reconstruire. Une étape contrôlée vérifie les conditions de publication (dont la documentation de version) avant de demander le déploiement. La représentation ne détaille ni les cibles internes ni les règles opérationnelles de l'ancien système.

Familles de pipelines

famillefinalitépratiques mobilisées
ApplicationsConstruire et publier les livrablesBuild, tests, promotion
Services partagésLivrer des composants de plateformeÉtapes réutilisables et versions
Sites et interfacesAutomatiser les livraisons webPackaging et déploiement
ConfigurationGérer des paramètres applicatifsTraçabilité et séparation des responsabilités
TestsVérifier les comportements de bout en boutJobs déclenchés et planifiés
BenchmarksExécuter des évaluations répétablesDocker, paramètres, publication de résultats

Les pipelines d'évaluation SCA permettaient de comparer plusieurs scanners sur un corpus d'essai. Les détails des outils, noms de jobs, cibles et horaires internes ont été omis.

Terraform × Jenkins

Comment les deux se rejoignent

Terraform Jenkins build + bundle S3 bundle zip CodeDeploy service de livraison EC2 outil de déploiement SNS → Lambda Slack crée ressources cloud s3 cp deploy installe événements bibliothèque partagée
Terraform déclare les ressources dont la livraison a besoin ; Jenkins construit et publie l'artefact, puis déclenche son déploiement. Ce découplage évite de confondre gestion de l'infrastructure et logique de construction applicative.
Bilan

Ce que je referais, ce que je changerais

Choix que je défends

  • Un exécuteur Terraform dédié avec rôle IAM. Un seul endroit d'où partent les changements, avec des droits limités et sans clé permanente sur les postes.
  • Une racine par environnement. Une erreur en test ne peut pas toucher l'état de production, et chaque environnement avance à son rythme.
  • Générer le code des ressources existantes. Recréer manuellement de nombreuses ressources AWS aurait été lent et source d'erreurs.
  • Jenkinsfiles centralisés et bibliothèque partagée. Les pipelines sont relus, versionnés et audités au même endroit.
  • Construire une fois, promouvoir le même artefact. Ce qui part en production est exactement ce qui a été testé sur Staging, et la promotion exige des notes de version.

Ce que je ferais autrement aujourd'hui

  • Une bibliothèque de modules, plusieurs racines. Je privilégierais un catalogue de modules partagés et versionnés, avec des paramètres séparés par environnement, pour limiter la divergence.
  • État distant partout, avec verrouillage. Je standardiserais les backends distants, le versionnage et le verrouillage afin de fiabiliser les travaux d'équipe.
  • Terraform dans Jenkins. Je privilégierais un plan partagé en revue suivi d'un apply soumis à approbation, dans une chaîne auditable.
  • Généraliser la bibliothèque partagée. J'extraierais davantage de séquences communes vers des fonctions paramétrables pour réduire les duplications entre pipelines.
  • Agents de build en conteneurs. Je proposerais des agents de build isolés afin de rendre les environnements d'exécution plus prévisibles.
  • Secrets uniquement via le gestionnaire d'identifiants. Je formaliserais une gestion centralisée des secrets, avec des identités à privilèges minimaux et un service dédié pour les valeurs sensibles.
  • Import natif. Les fonctionnalités d'import et de génération de configuration de Terraform peuvent aujourd'hui simplifier le travail de reprise des ressources existantes.