Construire une fois, déployer partout : approche de promotion d'application

Saurabh Joshi
By Saurabh Joshi
Oct 28, 2026 8 min read

Introduction

La livraison moderne des applications exige des builds fiables, des déploiements cohérents et des processus de mise en production contrôlés. Reconstruire une application pour chaque environnement risque d’entraîner des incohérences et il peut être difficile de garantir que la version de l’application testée par l’équipe QA soit bien celle déployée en Production. L’approche build once, deploy anywhere résout ce problème en construisant l’artefact de l’application une seule fois puis en le faisant évoluer à travers les différents environnements sans reconstruction.

Le processus de déploiement commence par une branche de publication suivie des modifications apportées par les développeurs et des pipelines JAR requis. Jenkins compile l'application et crée une image Docker, poussant cette image vers Amazon Elastic Container Registry (Amazon ECR). L'optimisation des tailles des images Docker durant ce processus de compilation améliore l'efficacité du déploiement, exploration des meilleures pratiques pour réduire la taille des images Docker avec des constructions multi-étapes. 

Le pipeline de déploiement déploie ensuite l’image vers l’environnement de Test. Une fois que l’assurance qualité a terminé un test de cohérence, un pipeline d’approbation est utilisé pour contrôler la promotion vers des environnements supérieurs tels que UAT et Production. Helm, Kubernetes et ArgoCD prennent en charge la configuration et le déploiement spécifiques à chaque environnement. Cette approche sépare la construction de l’application du déploiement et de la promotion, créant ainsi un processus de contrôle des versions cohérent, traçable et maîtrisé.

Points clés

  • Construisez une seule fois : créez l'artefact de l'application et l'image Docker une seule fois pour chaque candidat à la mise en production.
  • Test avant promotion : Effectuez des tests QA de conformité complète avant de promouvoir la version.
  • Réutiliser le même artefact : Promouvoir l’image validée à travers les environnements Test, UAT et Production.
  • Configuration séparée : Utilisez les valeurs Helm pour gérer les paramètres spécifiques à l’environnement.
  • Contrôler les déploiements : Mettre en place des étapes d’approbation pour les environnements supérieurs.
  • Maintenir la traçabilité : Associez chaque image à sa version de déploiement et à la révision source.

Pourquoi adopter une approche build-once ?

Cette approche empêche que les applications développées pour différents environnements génèrent des dépendances variées, des paramètres de build ou des révisions de code source différentes. Par conséquent, l’artefact déployé en production pourrait différer de celui testé par l’assurance qualité. L’approche build-once évite les reconstructions inutiles lors de la promotion. Une fois que Jenkins a créé l’artefact de release, le processus de promotion inclut les phases de test, d’approbation et de déploiement. Le flux de travail est le suivant :

Construire → Tester → Validation QA → Approbation → UAT → Production

Chaque environnement utilise la même image d’application, la configuration de déploiement pouvant varier selon l’environnement. Cette approche améliore la cohérence des artefacts, facilite le dépannage, minimise les opérations de build en double et simplifie la traçabilité des versions.

Comment fonctionne le processus de déploiement

  1. Créer la branche de publication
    Le pipeline de déploiement crée une branche de version. Les développeurs effectuent les modifications nécessaires sur cette branche, qui devient la source pour la prochaine compilation. L’équipe lance ensuite les pipelines JAR requis, JAR 2.0 et JAR 2.2 selon les besoins de la version. La compilation de l’application commence une fois que les étapes de préparation nécessaires ont été réalisées avec succès.
     
  2. Construisez l’application avec Jenkins
    Jenkins gère le processus de construction de l’application. Le pipeline de construction récupère la branche de version, effectue les étapes de construction nécessaires et crée l’artefact de l’application. Le pipeline emballe ensuite l’application dans une image Docker et pousse cette image vers Amazon ECR. L’équipe doit enregistrer la version de la release, le SHA du commit Git, le numéro de build Jenkins et le tag de l’image. Ces informations permettent d’identifier précisément l’artefact associé à une release. Une fois la construction réussie et les contrôles requis validés, le processus de promotion doit réutiliser l’artefact existant au lieu de reconstruire l’application.
     
  3. Stockez l’image Docker dans Amazon ECR
    Amazon ECR est un référentiel centralisé pour le stockage et la récupération des images Docker. Une fois que Jenkins a créé l’image, il la pousse vers le référentiel ECR approprié. Les pipelines de déploiement récupéreront cette image lors du déploiement de l’application dans différents environnements. Un tag d’image unique permet d’identifier chaque version. Utiliser le même tag d’image dans tous les environnements garantit que les environnements de Test, UAT et Production reçoivent le même artefact.

Déploiement en test et finalisation de la validation QA

Une fois l’image stockée dans Amazon ECR, la chaîne de déploiement la déploie en environnement Test. Helm gère la configuration du déploiement Kubernetes tandis qu’ArgoCD synchronise la configuration souhaitée avec l’environnement Kubernetes cible. Le processus de déploiement doit vérifier que l’application a démarré avec succès, que les contrôles d’intégrité ont été validés et que les fonctionnalités critiques fonctionnent comme prévu. L’équipe QA effectuera des tests de validation pour confirmer la version. Si l’application échoue à la validation, l’équipe résout le problème et répète les contrôles nécessaires avant de poursuivre. Un déploiement réussi ne signifie pas que la version est prête pour la promotion. Une fois que QA a terminé les vérifications requises, la version passe à l’étape d’approbation.

Promouvoir la même version vers des environnements supérieurs

La chaîne d’approbation offre un point de contrôle contrôlé avant que la mise en production ne progresse vers des environnements supérieurs. Le processus suit ces étapes :

  • Jenkins construit l’application et publie l’image Docker.
  • Le pipeline de déploiement déploie l’image sur Test.
  • Le contrôle qualité termine les tests de cohérence.
  • Le processus d’approbation demande l’autorisation pour la promotion.
  • Un intervenant autorisé approuve le lancement.
  • Le processus de déploiement promeut la même image vers la recette utilisateur (UAT).
  • L'équipe finalise l'approbation requise pour la Production.
  • Le processus de déploiement promeut l’image approuvée en Production.

L'approbation autorise la promotion, elle ne déclenche pas une nouvelle compilation de l'application. Cette séparation permet de conserver un enregistrement clair de l'artefact qui a passé la validation et est arrivé en Production.

Gestion des déploiements avec Helm, Kubernetes et ArgoCD

Les différents environnements auront des exigences opérationnelles différentes. La production peut nécessiter plus de réplicas et des limites de ressources plus élevées que le test, mais cela n’implique pas une nouvelle image d’application. Les fichiers de valeurs Helm gèrent ces paramètres de déploiement. Les équipes peuvent également configurer séparément les points de terminaison spécifiques à l’environnement et les paramètres des fonctionnalités par rapport à l’artefact de l’application. ArgoCD prend en charge le déploiement basé sur GitOps en synchronisant les environnements Kubernetes avec la configuration souhaitée stockée dans Git.

Chaque outil a une responsabilité distincte :

    1. Jenkins : Compile l’application et publie les images Docker.
    2. Amazon ECR : Stocke les images de l’application.
    3. Helm : Gère la configuration du déploiement.
    4. ArgoCD : synchronise la configuration souhaitée avec Kubernetes.
    5. Kubernetes : Exécute et gère l’application.

 Pour plus d’informations, explorez étapes pour mettre à jour un cluster Amazon EKS

Bienvenue chez TO THE NEW

TO THE NEW est un leader mondial en technologie numérique et services informatiques, dédié à transformer les entreprises grâce à des solutions innovantes et adaptées.

Nos services

  • Développement de logiciels personnalisés
  • Infrastructure cloud avec AWS
  • Transformation digitale et automatisation
  • Design Systems pour une cohérence maximale
  • Gouvernance des agents IA et IA responsable

Nous assurons une croissance à grande échelle pour votre entreprise en intégrant des systèmes de composants cohérents passant à l'échelle, permettant ainsi une évolution durable tout en équilibrant les priorités conflictuelles de vos projets.

Découvrez nos solutionsdurcissement complet des conteneurs sur Amazon EKS.

 

Pipelines Jenkins et leurs responsabilités

La configuration Jenkins est répartie en différentes responsabilités plutôt que d’intégrer l’ensemble du processus de déploiement dans un seul pipeline. Certains des pipelines importants dans ce flux sont :

Pipeline

Objet

canal de déploiement

Crée la branche de déploiement

build-pipeline

Construit l’application

pipeline de déploiement

Déploie la version

pipeline d’approbation

Approuvera le tag pour la promotion vers un environnement supérieur

Chaque pipeline gère une responsabilité spécifique, ce qui facilite le suivi et le dépannage du processus de déploiement. Des dépendances claires empêchent également que des builds échoués ou des contrôles QA non concluants ne progressent vers les étapes suivantes.

Construire une fois vs reconstruire pour chaque environnement

Reconstruit pour chaque environnement

Construire une seule fois

L’application est construite plusieurs fois

L’application est construite une seule fois

Différents artefacts peuvent être générés

Le même artefact est promu

Build est répété pour des environnements supérieurs

Les environnements supérieurs réutilisent la build existante

Plus de dépendance au processus de build lors du déploiement

Le déploiement est séparé de la construction

Plus difficile de garantir que les environnements de Test et de Production utilisent la même version de compilation

Le même artefact peut être promu

L’approche build-once n’élimine pas les tests spécifiques à chaque environnement. Chaque environnement nécessite toujours des contrôles de déploiement et de mise en production appropriés. Elle supprime simplement les reconstructions d’application inutiles du processus de promotion.

Bonnes pratiques pour une promotion fiable des applications

Quelques pratiques permettent de maintenir la cohérence tout au long du cycle de vie de la version.

  1.  Ne reconstruisez jamais pendant la promotion
    Réutilisez l’artefact existant dans tous les environnements. Si une modification de l’application devient nécessaire, créez une nouvelle version et répétez la validation requise.
     
  2. Séparer la configuration du code applicatif
    Gérez les paramètres spécifiques à l’environnement via les valeurs Helm et un mécanisme approprié de gestion des secrets.
     
  3. Utilisez des références d’image immuables
    Enregistrez les balises d’image et utilisez la même référence d’image dans tous les environnements.
     
  4. Appliquer des étapes de validation et d’approbation
    Empêchez les lancements d’avancer lorsque les tests ou approbations requis échouent.
     
  5. Maintenir la traçabilité
    Enregistrez le commit source, le numéro de build Jenkins, la balise de l’image et l’historique de déploiement. 
    Pour les déploiements en production nécessitant une gestion avancée du trafic et une visibilité des services, implémenter une mesh de services comme Istio offre un contrôle précis des communications et de l’observabilité des applications. 
     
  6. Plan de retour en arrière
    Conservez les images approuvées précédemment et conservez les enregistrements de déploiement pour faciliter la récupération lorsqu'une mise en production pose des problèmes.

Conclusion

L’approche « build-once, deploy-anywhere » sépare la construction des applications de leur déploiement et promotion, aidant les équipes à maintenir la cohérence tout au long du cycle de vie de la mise en production. Jenkins construit l’application et publie l’image Docker sur Amazon ECR. La chaîne de déploiement livre l’image dans l’environnement de Test, où l’assurance qualité réalise des tests de principe. Après les validations requises, l’équipe promeut la même image vers les environnements UAT et Production.

Helm gère la configuration du déploiement, Kubernetes exécute l’application, et ArgoCD prend en charge les déploiements basés sur GitOps. Le principe clé est simple : construire une seule fois, valider l’artefact, puis promouvoir ce même artefact à travers les environnements.

En évitant les reconstructions inutiles et en maintenant des contrôles d’approbation clairs, les équipes peuvent améliorer la cohérence des artefacts, simplifier le dépannage et établir un processus de déploiement CI/CD plus fiable. Pour renforcer encore cette fiabilité et optimiser les coûts d’infrastructure, les équipes peuvent également mettre en œuvre une gestion intelligente Stratégies d'autoscaling Kubernetes avec des outils comme Karpenter pour ajuster automatiquement les ressources en fonction de la demande applicative en temps réel.