[{"data":1,"prerenderedAt":1176},["ShallowReactive",2],{"/en-us/blog/tags/ci-cd/":3,"navigation-fr-fr":20,"banner-fr-fr":440,"footer-fr-fr":453,"CI/CD-tag-page-fr-fr":664},{"_path":4,"_dir":5,"_draft":6,"_partial":6,"_locale":7,"content":8,"config":11,"_id":13,"_type":14,"title":15,"_source":16,"_file":17,"_stem":18,"_extension":19},"/en-us/blog/tags/ci-cd","tags",false,"",{"tag":9,"tagSlug":10},"CI/CD","ci-cd",{"template":12},"BlogTag","content:en-us:blog:tags:ci-cd.yml","yaml","Ci Cd","content","en-us/blog/tags/ci-cd.yml","en-us/blog/tags/ci-cd","yml",{"_path":21,"_dir":22,"_draft":6,"_partial":6,"_locale":7,"data":23,"_id":436,"_type":14,"title":437,"_source":16,"_file":438,"_stem":439,"_extension":19},"/shared/fr-fr/main-navigation","fr-fr",{"logo":24,"freeTrial":29,"sales":34,"login":39,"items":44,"search":377,"minimal":413,"duo":427},{"config":25},{"href":26,"dataGaName":27,"dataGaLocation":28},"/fr-fr/","gitlab logo","header",{"text":30,"config":31},"Commencer un essai gratuit",{"href":32,"dataGaName":33,"dataGaLocation":28},"https://gitlab.com/-/trial_registrations/new?glm_source=about.gitlab.com&glm_content=default-saas-trial/","free trial",{"text":35,"config":36},"Contacter l'équipe commerciale",{"href":37,"dataGaName":38,"dataGaLocation":28},"/fr-fr/sales/","sales",{"text":40,"config":41},"Connexion",{"href":42,"dataGaName":43,"dataGaLocation":28},"https://gitlab.com/users/sign_in/","sign in",[45,89,187,192,298,358],{"text":46,"config":47,"cards":49,"footer":72},"Plateforme",{"dataNavLevelOne":48},"platform",[50,56,64],{"title":46,"description":51,"link":52},"La plateforme DevSecOps alimentée par l'IA la plus complète",{"text":53,"config":54},"Découvrir notre plateforme",{"href":55,"dataGaName":48,"dataGaLocation":28},"/fr-fr/platform/",{"title":57,"description":58,"link":59},"GitLab Duo (IA)","Créez des logiciels plus rapidement en tirant parti de l'IA à chaque étape du développement",{"text":60,"config":61},"Découvrez GitLab Duo",{"href":62,"dataGaName":63,"dataGaLocation":28},"/fr-fr/gitlab-duo/","gitlab duo ai",{"title":65,"description":66,"link":67},"Choisir GitLab","10 raisons pour lesquelles les entreprises choisissent GitLab",{"text":68,"config":69},"En savoir plus",{"href":70,"dataGaName":71,"dataGaLocation":28},"/fr-fr/why-gitlab/","why gitlab",{"title":73,"items":74},"Démarrer avec",[75,80,85],{"text":76,"config":77},"Ingénierie de plateforme",{"href":78,"dataGaName":79,"dataGaLocation":28},"/fr-fr/solutions/platform-engineering/","platform engineering",{"text":81,"config":82},"Expérience développeur",{"href":83,"dataGaName":84,"dataGaLocation":28},"/fr-fr/developer-experience/","Developer experience",{"text":86,"config":87},"MLOps",{"href":88,"dataGaName":86,"dataGaLocation":28},"/fr-fr/topics/devops/the-role-of-ai-in-devops/",{"text":90,"left":91,"config":92,"link":94,"lists":98,"footer":169},"Produit",true,{"dataNavLevelOne":93},"solutions",{"text":95,"config":96},"Voir toutes les solutions",{"href":97,"dataGaName":93,"dataGaLocation":28},"/fr-fr/solutions/",[99,124,147],{"title":100,"description":101,"link":102,"items":107},"Automatisation","CI/CD et automatisation pour accélérer le déploiement",{"config":103},{"icon":104,"href":105,"dataGaName":106,"dataGaLocation":28},"AutomatedCodeAlt","/solutions/delivery-automation/","automated software delivery",[108,111,115,120],{"text":9,"config":109},{"href":110,"dataGaLocation":28,"dataGaName":9},"/fr-fr/solutions/continuous-integration/",{"text":112,"config":113},"Développement assisté par l'IA",{"href":62,"dataGaLocation":28,"dataGaName":114},"AI assisted development",{"text":116,"config":117},"Gestion du code source",{"href":118,"dataGaLocation":28,"dataGaName":119},"/fr-fr/solutions/source-code-management/","Source Code Management",{"text":121,"config":122},"Livraison de logiciels automatisée",{"href":105,"dataGaLocation":28,"dataGaName":123},"Automated software delivery",{"title":125,"description":126,"link":127,"items":132},"Securité","Livrez du code plus rapidement sans compromettre la sécurité",{"config":128},{"href":129,"dataGaName":130,"dataGaLocation":28,"icon":131},"/fr-fr/solutions/security-compliance/","security and compliance","ShieldCheckLight",[133,138,143],{"text":134,"config":135},"Application Security Testing",{"href":136,"dataGaName":137,"dataGaLocation":28},"/solutions/application-security-testing/","Application security testing",{"text":139,"config":140},"Sécurité de la chaîne d'approvisionnement logicielle",{"href":141,"dataGaLocation":28,"dataGaName":142},"/fr-fr/solutions/supply-chain/","Software supply chain security",{"text":144,"config":145},"Software Compliance",{"href":146,"dataGaName":144,"dataGaLocation":28},"/solutions/software-compliance/",{"title":148,"link":149,"items":154},"Mesures",{"config":150},{"icon":151,"href":152,"dataGaName":153,"dataGaLocation":28},"DigitalTransformation","/fr-fr/solutions/visibility-measurement/","visibility and measurement",[155,159,164],{"text":156,"config":157},"Visibilité et mesures",{"href":152,"dataGaLocation":28,"dataGaName":158},"Visibility and Measurement",{"text":160,"config":161},"Gestion de la chaîne de valeur",{"href":162,"dataGaLocation":28,"dataGaName":163},"/fr-fr/solutions/value-stream-management/","Value Stream Management",{"text":165,"config":166},"Données d'analyse et informations clés",{"href":167,"dataGaLocation":28,"dataGaName":168},"/fr-fr/solutions/analytics-and-insights/","Analytics and insights",{"title":170,"items":171},"GitLab pour",[172,177,182],{"text":173,"config":174},"Entreprises",{"href":175,"dataGaLocation":28,"dataGaName":176},"/fr-fr/enterprise/","enterprise",{"text":178,"config":179},"PME",{"href":180,"dataGaLocation":28,"dataGaName":181},"/fr-fr/small-business/","small business",{"text":183,"config":184},"Secteur public",{"href":185,"dataGaLocation":28,"dataGaName":186},"/fr-fr/solutions/public-sector/","public sector",{"text":188,"config":189},"Tarifs",{"href":190,"dataGaName":191,"dataGaLocation":28,"dataNavLevelOne":191},"/fr-fr/pricing/","pricing",{"text":193,"config":194,"link":196,"lists":200,"feature":285},"Ressources",{"dataNavLevelOne":195},"resources",{"text":197,"config":198},"Afficher toutes les ressources",{"href":199,"dataGaName":195,"dataGaLocation":28},"/fr-fr/resources/",[201,234,257],{"title":202,"items":203},"Premiers pas",[204,209,214,219,224,229],{"text":205,"config":206},"Installation",{"href":207,"dataGaName":208,"dataGaLocation":28},"/fr-fr/install/","install",{"text":210,"config":211},"Guides de démarrage rapide",{"href":212,"dataGaName":213,"dataGaLocation":28},"/fr-fr/get-started/","quick setup checklists",{"text":215,"config":216},"Apprentissage",{"href":217,"dataGaLocation":28,"dataGaName":218},"https://university.gitlab.com/","learn",{"text":220,"config":221},"Documentation sur le produit",{"href":222,"dataGaName":223,"dataGaLocation":28},"https://docs.gitlab.com/","product documentation",{"text":225,"config":226},"Vidéos sur les bonnes pratiques",{"href":227,"dataGaName":228,"dataGaLocation":28},"/fr-fr/getting-started-videos/","best practice videos",{"text":230,"config":231},"Intégrations",{"href":232,"dataGaName":233,"dataGaLocation":28},"/fr-fr/integrations/","integrations",{"title":235,"items":236},"Découvrir",[237,242,247,252],{"text":238,"config":239},"Histoires de succès client",{"href":240,"dataGaName":241,"dataGaLocation":28},"/fr-fr/customers/","customer success stories",{"text":243,"config":244},"Blog",{"href":245,"dataGaName":246,"dataGaLocation":28},"/fr-fr/blog/","blog",{"text":248,"config":249},"Travail à distance",{"href":250,"dataGaName":251,"dataGaLocation":28},"https://handbook.gitlab.com/handbook/company/culture/all-remote/","remote",{"text":253,"config":254},"TeamOps",{"href":255,"dataGaName":256,"dataGaLocation":28},"/fr-fr/teamops/","teamops",{"title":258,"items":259},"Connecter",[260,265,270,275,280],{"text":261,"config":262},"Services GitLab",{"href":263,"dataGaName":264,"dataGaLocation":28},"/fr-fr/services/","services",{"text":266,"config":267},"Communauté",{"href":268,"dataGaName":269,"dataGaLocation":28},"/community/","community",{"text":271,"config":272},"Forum",{"href":273,"dataGaName":274,"dataGaLocation":28},"https://forum.gitlab.com/","forum",{"text":276,"config":277},"Événements",{"href":278,"dataGaName":279,"dataGaLocation":28},"/events/","events",{"text":281,"config":282},"Partenaires",{"href":283,"dataGaName":284,"dataGaLocation":28},"/partners/","partners",{"backgroundColor":286,"textColor":287,"text":288,"image":289,"link":293},"#2f2a6b","#fff","L'avenir du développement logiciel. Tendances et perspectives.",{"altText":290,"config":291},"carte promo The Source",{"src":292},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1758208064/dzl0dbift9xdizyelkk4.svg",{"text":294,"config":295},"Lire les articles les plus récents",{"href":296,"dataGaName":297,"dataGaLocation":28},"/fr-fr/the-source/","the source",{"text":299,"config":300,"lists":302},"Société",{"dataNavLevelOne":301},"company",[303],{"items":304},[305,310,316,318,323,328,333,338,343,348,353],{"text":306,"config":307},"À propos",{"href":308,"dataGaName":309,"dataGaLocation":28},"/fr-fr/company/","about",{"text":311,"config":312,"footerGa":315},"Emplois",{"href":313,"dataGaName":314,"dataGaLocation":28},"/jobs/","jobs",{"dataGaName":314},{"text":276,"config":317},{"href":278,"dataGaName":279,"dataGaLocation":28},{"text":319,"config":320},"Leadership",{"href":321,"dataGaName":322,"dataGaLocation":28},"/company/team/e-group/","leadership",{"text":324,"config":325},"Équipe",{"href":326,"dataGaName":327,"dataGaLocation":28},"/company/team/","team",{"text":329,"config":330},"Manuel",{"href":331,"dataGaName":332,"dataGaLocation":28},"https://handbook.gitlab.com/","handbook",{"text":334,"config":335},"Relations avec les investisseurs",{"href":336,"dataGaName":337,"dataGaLocation":28},"https://ir.gitlab.com/","investor relations",{"text":339,"config":340},"Centre de confiance",{"href":341,"dataGaName":342,"dataGaLocation":28},"/fr-fr/security/","trust center",{"text":344,"config":345},"Centre pour la transparence de l'IA",{"href":346,"dataGaName":347,"dataGaLocation":28},"/fr-fr/ai-transparency-center/","ai transparency center",{"text":349,"config":350},"Newsletter",{"href":351,"dataGaName":352,"dataGaLocation":28},"/company/contact/","newsletter",{"text":354,"config":355},"Presse",{"href":356,"dataGaName":357,"dataGaLocation":28},"/press/","press",{"text":359,"config":360,"lists":361},"Nous contacter",{"dataNavLevelOne":301},[362],{"items":363},[364,367,372],{"text":35,"config":365},{"href":37,"dataGaName":366,"dataGaLocation":28},"talk to sales",{"text":368,"config":369},"Aide",{"href":370,"dataGaName":371,"dataGaLocation":28},"/support/","get help",{"text":373,"config":374},"Portail clients GitLab",{"href":375,"dataGaName":376,"dataGaLocation":28},"https://customers.gitlab.com/customers/sign_in/","customer portal",{"close":378,"login":379,"suggestions":386},"Fermer",{"text":380,"link":381},"Pour rechercher des dépôts et des projets, connectez-vous à",{"text":382,"config":383},"gitlab.com",{"href":42,"dataGaName":384,"dataGaLocation":385},"search login","search",{"text":387,"default":388},"Suggestions",[389,392,397,399,404,409],{"text":57,"config":390},{"href":62,"dataGaName":391,"dataGaLocation":385},"GitLab Duo (AI)",{"text":393,"config":394},"Suggestions de code (IA)",{"href":395,"dataGaName":396,"dataGaLocation":385},"/fr-fr/solutions/code-suggestions/","Code Suggestions (AI)",{"text":9,"config":398},{"href":110,"dataGaName":9,"dataGaLocation":385},{"text":400,"config":401},"GitLab sur AWS",{"href":402,"dataGaName":403,"dataGaLocation":385},"/fr-fr/partners/technology-partners/aws/","GitLab on AWS",{"text":405,"config":406},"GitLab sur Google Cloud ",{"href":407,"dataGaName":408,"dataGaLocation":385},"/fr-fr/partners/technology-partners/google-cloud-platform/","GitLab on Google Cloud",{"text":410,"config":411},"Pourquoi utiliser GitLab ?",{"href":70,"dataGaName":412,"dataGaLocation":385},"Why GitLab?",{"freeTrial":414,"mobileIcon":419,"desktopIcon":424},{"text":415,"config":416},"Commencer votre essai gratuit",{"href":417,"dataGaName":33,"dataGaLocation":418},"https://gitlab.com/-/trials/new/","nav",{"altText":420,"config":421},"Icône GitLab",{"src":422,"dataGaName":423,"dataGaLocation":418},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1758203874/jypbw1jx72aexsoohd7x.svg","gitlab icon",{"altText":420,"config":425},{"src":426,"dataGaName":423,"dataGaLocation":418},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1758203875/gs4c8p8opsgvflgkswz9.svg",{"freeTrial":428,"mobileIcon":432,"desktopIcon":434},{"text":429,"config":430},"En savoir plus sur GitLab Duo",{"href":62,"dataGaName":431,"dataGaLocation":418},"gitlab duo",{"altText":420,"config":433},{"src":422,"dataGaName":423,"dataGaLocation":418},{"altText":420,"config":435},{"src":426,"dataGaName":423,"dataGaLocation":418},"content:shared:fr-fr:main-navigation.yml","Main Navigation","shared/fr-fr/main-navigation.yml","shared/fr-fr/main-navigation",{"_path":441,"_dir":22,"_draft":6,"_partial":6,"_locale":7,"title":442,"titleMobile":442,"button":443,"config":448,"_id":450,"_type":14,"_source":16,"_file":451,"_stem":452,"_extension":19},"/shared/fr-fr/banner","La plateforme GitLab Duo Agent est maintenant disponible en version bêta publique !",{"text":444,"config":445},"Essayer la version bêta",{"href":446,"dataGaName":447,"dataGaLocation":28},"/fr-fr/gitlab-duo/agent-platform/","duo banner",{"layout":449},"release","content:shared:fr-fr:banner.yml","shared/fr-fr/banner.yml","shared/fr-fr/banner",{"_path":454,"_dir":22,"_draft":6,"_partial":6,"_locale":7,"data":455,"_id":660,"_type":14,"title":661,"_source":16,"_file":662,"_stem":663,"_extension":19},"/shared/fr-fr/main-footer",{"text":456,"source":457,"edit":463,"contribute":468,"config":473,"items":478,"minimal":651},"Git est une marque déposée de Software Freedom Conservancy et notre utilisation de « GitLab » est sous licence",{"text":458,"config":459},"Afficher le code source de la page",{"href":460,"dataGaName":461,"dataGaLocation":462},"https://gitlab.com/gitlab-com/marketing/digital-experience/about-gitlab-com/","page source","footer",{"text":464,"config":465},"Modifier cette page",{"href":466,"dataGaName":467,"dataGaLocation":462},"https://gitlab.com/gitlab-com/marketing/digital-experience/about-gitlab-com/-/blob/main/content/","web ide",{"text":469,"config":470},"Veuillez contribuer",{"href":471,"dataGaName":472,"dataGaLocation":462},"https://gitlab.com/gitlab-com/marketing/digital-experience/about-gitlab-com/-/blob/main/CONTRIBUTING.md/","please contribute",{"twitter":474,"facebook":475,"youtube":476,"linkedin":477},"https://twitter.com/gitlab","https://www.facebook.com/gitlab","https://www.youtube.com/channel/UCnMGQ8QHMAnVIsI3xJrihhg","https://www.linkedin.com/company/gitlab-com",[479,502,556,588,622],{"title":46,"links":480,"subMenu":485},[481],{"text":482,"config":483},"Plateforme DevSecOps",{"href":55,"dataGaName":484,"dataGaLocation":462},"devsecops platform",[486],{"title":188,"links":487},[488,492,497],{"text":489,"config":490},"Voir les forfaits",{"href":190,"dataGaName":491,"dataGaLocation":462},"view plans",{"text":493,"config":494},"Pourquoi choisir GitLab Premium ?",{"href":495,"dataGaName":496,"dataGaLocation":462},"/fr-fr/pricing/premium/","why premium",{"text":498,"config":499},"Pourquoi choisir GitLab Ultimate ?",{"href":500,"dataGaName":501,"dataGaLocation":462},"/fr-fr/pricing/ultimate/","why ultimate",{"title":503,"links":504},"Solutions",[505,510,513,515,520,525,529,532,535,540,542,544,546,551],{"text":506,"config":507},"Transformation digitale",{"href":508,"dataGaName":509,"dataGaLocation":462},"/fr-fr/topics/digital-transformation/","digital transformation",{"text":511,"config":512},"Sécurité et conformité",{"href":136,"dataGaName":137,"dataGaLocation":462},{"text":121,"config":514},{"href":105,"dataGaName":106,"dataGaLocation":462},{"text":516,"config":517},"Développement agile",{"href":518,"dataGaName":519,"dataGaLocation":462},"/fr-fr/solutions/agile-delivery/","agile delivery",{"text":521,"config":522},"Transformation cloud",{"href":523,"dataGaName":524,"dataGaLocation":462},"/fr-fr/topics/cloud-native/","cloud transformation",{"text":526,"config":527},"SCM",{"href":118,"dataGaName":528,"dataGaLocation":462},"source code management",{"text":9,"config":530},{"href":110,"dataGaName":531,"dataGaLocation":462},"continuous integration & delivery",{"text":160,"config":533},{"href":162,"dataGaName":534,"dataGaLocation":462},"value stream management",{"text":536,"config":537},"GitOps",{"href":538,"dataGaName":539,"dataGaLocation":462},"/fr-fr/solutions/gitops/","gitops",{"text":173,"config":541},{"href":175,"dataGaName":176,"dataGaLocation":462},{"text":178,"config":543},{"href":180,"dataGaName":181,"dataGaLocation":462},{"text":183,"config":545},{"href":185,"dataGaName":186,"dataGaLocation":462},{"text":547,"config":548},"Formation",{"href":549,"dataGaName":550,"dataGaLocation":462},"/fr-fr/solutions/education/","education",{"text":552,"config":553},"Services financiers",{"href":554,"dataGaName":555,"dataGaLocation":462},"/fr-fr/solutions/finance/","financial services",{"title":193,"links":557},[558,560,562,564,567,569,572,574,576,578,580,582,584,586],{"text":205,"config":559},{"href":207,"dataGaName":208,"dataGaLocation":462},{"text":210,"config":561},{"href":212,"dataGaName":213,"dataGaLocation":462},{"text":215,"config":563},{"href":217,"dataGaName":218,"dataGaLocation":462},{"text":220,"config":565},{"href":222,"dataGaName":566,"dataGaLocation":462},"docs",{"text":243,"config":568},{"href":245,"dataGaName":246},{"text":570,"config":571},"Histoires de réussite client",{"href":240,"dataGaLocation":462},{"text":238,"config":573},{"href":240,"dataGaName":241,"dataGaLocation":462},{"text":248,"config":575},{"href":250,"dataGaName":251,"dataGaLocation":462},{"text":261,"config":577},{"href":263,"dataGaName":264,"dataGaLocation":462},{"text":253,"config":579},{"href":255,"dataGaName":256,"dataGaLocation":462},{"text":266,"config":581},{"href":268,"dataGaName":269,"dataGaLocation":462},{"text":271,"config":583},{"href":273,"dataGaName":274,"dataGaLocation":462},{"text":276,"config":585},{"href":278,"dataGaName":279,"dataGaLocation":462},{"text":281,"config":587},{"href":283,"dataGaName":284,"dataGaLocation":462},{"title":299,"links":589},[590,592,594,596,598,600,602,606,611,613,615,617],{"text":306,"config":591},{"href":308,"dataGaName":301,"dataGaLocation":462},{"text":311,"config":593},{"href":313,"dataGaName":314,"dataGaLocation":462},{"text":319,"config":595},{"href":321,"dataGaName":322,"dataGaLocation":462},{"text":324,"config":597},{"href":326,"dataGaName":327,"dataGaLocation":462},{"text":329,"config":599},{"href":331,"dataGaName":332,"dataGaLocation":462},{"text":334,"config":601},{"href":336,"dataGaName":337,"dataGaLocation":462},{"text":603,"config":604},"Sustainability",{"href":605,"dataGaName":603,"dataGaLocation":462},"/sustainability/",{"text":607,"config":608},"Diversité, inclusion et appartenance (DIB)",{"href":609,"dataGaName":610,"dataGaLocation":462},"/fr-fr/diversity-inclusion-belonging/","Diversity, inclusion and belonging",{"text":339,"config":612},{"href":341,"dataGaName":342,"dataGaLocation":462},{"text":349,"config":614},{"href":351,"dataGaName":352,"dataGaLocation":462},{"text":354,"config":616},{"href":356,"dataGaName":357,"dataGaLocation":462},{"text":618,"config":619},"Déclaration de transparence sur l'esclavage moderne",{"href":620,"dataGaName":621,"dataGaLocation":462},"https://handbook.gitlab.com/handbook/legal/modern-slavery-act-transparency-statement/","modern slavery transparency statement",{"title":359,"links":623},[624,627,629,631,636,641,646],{"text":625,"config":626},"Échanger avec un expert",{"href":37,"dataGaName":38,"dataGaLocation":462},{"text":368,"config":628},{"href":370,"dataGaName":371,"dataGaLocation":462},{"text":373,"config":630},{"href":375,"dataGaName":376,"dataGaLocation":462},{"text":632,"config":633},"Statut",{"href":634,"dataGaName":635,"dataGaLocation":462},"https://status.gitlab.com/","status",{"text":637,"config":638},"Conditions d'utilisation",{"href":639,"dataGaName":640},"/terms/","terms of use",{"text":642,"config":643},"Déclaration de confidentialité",{"href":644,"dataGaName":645,"dataGaLocation":462},"/fr-fr/privacy/","privacy statement",{"text":647,"config":648},"Préférences en matière de cookies",{"dataGaName":649,"dataGaLocation":462,"id":650,"isOneTrustButton":91},"cookie preferences","ot-sdk-btn",{"items":652},[653,655,658],{"text":637,"config":654},{"href":639,"dataGaName":640,"dataGaLocation":462},{"text":656,"config":657},"Politique de confidentialité",{"href":644,"dataGaName":645,"dataGaLocation":462},{"text":647,"config":659},{"dataGaName":649,"dataGaLocation":462,"id":650,"isOneTrustButton":91},"content:shared:fr-fr:main-footer.yml","Main Footer","shared/fr-fr/main-footer.yml","shared/fr-fr/main-footer",{"allPosts":665,"featuredPost":1155,"totalPagesCount":1174,"initialPosts":1175},[666,696,717,736,758,782,803,824,843,867,889,913,935,960,982,1003,1025,1046,1066,1090,1115,1137],{"_path":667,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":668,"content":676,"config":689,"_id":692,"_type":14,"title":693,"_source":16,"_file":694,"_stem":695,"_extension":19},"/fr-fr/blog/automating-container-image-migration-from-amazon-ecr-to-gitlab",{"title":669,"description":670,"ogTitle":669,"ogDescription":670,"noIndex":6,"ogImage":671,"ogUrl":672,"ogSiteName":673,"ogType":674,"canonicalUrls":672,"schema":675},"Comment automatiser la migration des images de conteneurs d'Amazon ECR vers GitLab","Suivez ce guide étape par étape pour automatiser le processus de migration de vos images de conteneurs d’Amazon ECR vers GitLab.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749663129/Blog/Hero%20Images/blog-image-template-1800x945__28_.png","https://about.gitlab.com/blog/automating-container-image-migration-from-amazon-ecr-to-gitlab","https://about.gitlab.com","article","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Comment automatiser la migration des images de conteneurs d'Amazon ECR vers GitLab\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Tim Rizzi\"}],\n        \"datePublished\": \"2025-02-13\",\n      }\n                  ",{"title":669,"description":670,"authors":677,"heroImage":671,"date":679,"body":680,"category":681,"tags":682,"updatedDate":688},[678],"Tim Rizzi","2025-02-13","« Nous devons migrer des centaines d'images de conteneurs d'Amazon Elastic Container Registry (ECR) vers GitLab. Pouvez-vous nous aider ? » Cette question revenait sans cesse lors de nos échanges avec des ingénieurs de plateforme. En pleine modernisation de leur chaîne d'outils DevSecOps avec GitLab, ils se retrouvaient bloqués au moment de déplacer leurs images de conteneurs. D’un point de vue technique, chaque transfert est simple. Mais, l'opération était longue et fastidieuse en raison du volume considérable d'images.\n\nUn ingénieur de plateforme a parfaitement résumé la situation : « Je connais parfaitement le processus : effectuer un pull, retagger, effectuer un push. Le problème, c'est que je gère 200 microservices, chacun contenant plusieurs tags. Je ne peux pas passer plusieurs semaines sur cette migration alors que j'ai des tâches critiques à effectuer au niveau de l'infrastructure. »\n\n## Le défi\n\nCette conversation nous a fait réfléchir et a donné naissance à une idée. Et si nous pouvions automatiser l'ensemble du processus ? Lorsqu'une équipe de plateforme DevOps transfère ses [pipelines CI/CD](https://about.gitlab.com/fr-fr/topics/ci-cd/cicd-pipeline/ \"Qu'est-ce qu'un pipeline CI/CD ?\") vers GitLab, la migration des images de conteneurs ne devrait pas poser de difficulté particulière. Le processus manuel est rudimentaire, mais répétitif : il s'agit d'effectuer un pull de chaque image, de la retagger et d'effectuer un push pour la migrer vers le registre de conteneurs de GitLab. Réaliser cette même opération pour des dizaines de dépôts et plusieurs tags par image requiert des jours ou des semaines de travail chronophage.\n\n## La solution\n\nNous avons donc entrepris de créer un pipeline GitLab qui effectuerait automatiquement cette lourde tâche. L'objectif était clair : fournir aux ingénieurs de plateforme un outil qu'ils pourraient configurer en quelques minutes et qui, en une seule nuit, parviendrait à migrer toutes leurs images.\n\n### Configuration des accès\n\nCommençons par l'essentiel : les aspects liés à la sécurité. Nous voulions nous assurer que les équipes puissent exécuter cette migration avec un minimum d'autorisations sur AWS. Voici la politique de gestion des identités et des accès (IAM) en lecture seule dont vous avez besoin :\n\n```json\n{\n    \"Version\": \"2012-10-17\",\n    \"Statement\": [\n        {\n            \"Effect\": \"Allow\",\n            \"Action\": [\n                \"ecr:GetAuthorizationToken\",\n                \"ecr:BatchCheckLayerAvailability\",\n                \"ecr:GetDownloadUrlForLayer\",\n                \"ecr:DescribeRepositories\",\n                \"ecr:ListImages\",\n                \"ecr:DescribeImages\",\n                \"ecr:BatchGetImage\"\n            ],\n            \"Resource\": \"*\"\n        }\n    ]\n}\n```\n\n### Configuration de GitLab\n\nUne fois la sécurité en place, l'étape suivante consiste à configurer GitLab. Nous avons volontairement réduit cela au strict minimum : il vous suffit de configurer les variables suivantes dans les paramètres CI/CD de votre projet :\n\n```\nAWS_ACCOUNT_ID: Your AWS account number\nAWS_DEFAULT_REGION: Your ECR region\nAWS_ACCESS_KEY_ID: [Masked]\nAWS_SECRET_ACCESS_KEY: [Masked]\nBULK_MIGRATE: true\n```\n\n### Le pipeline de migration \n\nPassons maintenant à la partie la plus intéressante. Nous avons créé le pipeline en utilisant Docker-in-Docker pour gérer toutes les opérations liées aux images de manière fiable :\n\n```yaml\nimage: docker:20.10\nservices:\n  - docker:20.10-dind\n\nbefore_script:\n  - apk add --no-cache aws-cli jq\n  - aws sts get-caller-identity\n  - aws ecr get-login-password | docker login --username AWS --password-stdin\n  - docker login -u ${CI_REGISTRY_USER} -p ${CI_REGISTRY_PASSWORD} ${CI_REGISTRY}\n```\n\nLe pipeline fonctionne en trois phases, chacune s'appuyant sur la précédente :\n\n1. Identification\n\nDans un premier temps, il détecte l'ensemble de vos dépôts :\n\n```bash\nREPOS=$(aws ecr describe-repositories --query 'repositories[*].repositoryName' --output text)\n```\n\n2. Énumération des tags\n\nEnsuite, pour chaque dépôt, il récupère l'ensemble des tags :\n\n```bash\nTAGS=$(aws ecr describe-images --repository-name $repo --query 'imageDetails[*].imageTags[]' --output text)\n```\n\n3. Transfert\n\nEnfin, il gère la migration proprement dite :\n\n```bash\ndocker pull ${AWS_ACCOUNT_ID}.dkr.ecr.${AWS_DEFAULT_REGION}.amazonaws.com/${repo}:${tag}\ndocker tag ${AWS_ACCOUNT_ID}.dkr.ecr.${AWS_DEFAULT_REGION}.amazonaws.com/${repo}:${tag} ${CI_REGISTRY_IMAGE}/${repo}:${tag}\ndocker push ${CI_REGISTRY_IMAGE}/${repo}:${tag}\n```\n\n## Résultats\n\nVoici ce que cette solution offre comme avantages aux ingénieurs de plateforme qui ne veulent pas passer plusieurs semaines sur la migration :\n\n- Identification et migration automatisées de l'ensemble des dépôts et tags\n- Dénomination cohérente des images entre ECR et GitLab\n- Gestion des échecs de transferts\n- Journalisation claire pour suivre la progression\n\nAu lieu d'écrire des scripts et de surveiller la migration, l'ingénieur de plateforme peut se concentrer sur des tâches à plus grande valeur ajoutée.\n\n## Utilisation\n\nLa première étape est très simple :\n\n1. Copiez le fichier `.gitlab-ci.yml` dans votre dépôt.\n2. Configurez les variables AWS et GitLab.\n3. Définissez `BULK_MIGRATE` sur « true » pour déclencher la migration.\n\n## Bonnes pratiques\n\nEn accompagnant plusieurs équipes dans leur migration, nous avons tiré quelques enseignements pratiques :\n\n- Exécutez la migration en dehors des heures de pointe pour réduire au maximum l'impact sur votre équipe.\n- Consultez les logs de pipeline qui vous indiqueront si un élément nécessite votre attention.\n- Ne désactivez pas votre registre ECR avant d'avoir vérifié que toutes les images ont bien été transférées.\n- Pour les migrations à grande échelle, envisagez d'ajouter une limite de débit pour éviter de saturer votre réseau.\n\nNous mettons ce pipeline à disposition en open source dans notre dépôt GitLab public, car nous sommes convaincus que les ingénieurs de plateforme devraient passer leur temps à créer de la valeur, plutôt qu'à copier des images de conteneurs. N'hésitez pas à l'adapter à vos besoins ou à poser vos questions sur sa mise en œuvre. Consultez notre documentation pour en savoir plus sur les [catalogues CI/CD](https://gitlab.com/explore/catalog/components/package \"Catalogues CI/CD\"). ","engineering",[9,683,684,685,686,687],"AWS","tutorial","DevSecOps platform","product","solutions architecture","2025-04-07",{"slug":690,"featured":91,"template":691},"automating-container-image-migration-from-amazon-ecr-to-gitlab","BlogPost","content:fr-fr:blog:automating-container-image-migration-from-amazon-ecr-to-gitlab.yml","Automating Container Image Migration From Amazon Ecr To Gitlab","fr-fr/blog/automating-container-image-migration-from-amazon-ecr-to-gitlab.yml","fr-fr/blog/automating-container-image-migration-from-amazon-ecr-to-gitlab",{"_path":697,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":698,"content":704,"config":711,"_id":713,"_type":14,"title":714,"_source":16,"_file":715,"_stem":716,"_extension":19},"/fr-fr/blog/building-a-gitlab-ci-cd-pipeline-for-a-monorepo-the-easy-way",{"title":699,"description":700,"ogTitle":699,"ogDescription":700,"noIndex":6,"ogImage":701,"ogUrl":702,"ogSiteName":673,"ogType":674,"canonicalUrls":702,"schema":703},"GitLab CI/CD : comment créer facilement un pipeline pour un monorepo","Découvrez comment configurer un pipeline CI/CD dans GitLab pour un dépôt monorepo et simplifier l'hébergement de plusieurs applications dans un seul dépôt.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749660151/Blog/Hero%20Images/blog-image-template-1800x945__26_.png","https://about.gitlab.com/blog/building-a-gitlab-ci-cd-pipeline-for-a-monorepo-the-easy-way","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"GitLab CI/CD : comment créer facilement un pipeline pour un monorepo\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Sam Morris\"}],\n        \"datePublished\": \"2024-07-30\",\n      }\n                  ",{"title":699,"description":700,"authors":705,"heroImage":701,"date":707,"body":708,"category":681,"tags":709,"updatedDate":710},[706],"Sam Morris","2024-07-30","Les monorepos permettent d’héberger le code de plusieurs applications au sein d'un seul dépôt. Dans GitLab, cela consiste à organiser le code source de chaque application dans des répertoires distincts au sein d'un même projet. Bien que cette approche facilite le [contrôle de version](https://about.gitlab.com/fr-fr/topics/version-control/ \"Qu'est-ce que le contrôle de version ? \") pour l'ensemble du code, tirer parti des capacités avancées des [pipelines CI/CD](https://about.gitlab.com/fr-fr/topics/ci-cd/cicd-pipeline/ \"Qu'est-ce qu'un pipeline CI/CD ? \") de GitLab pouvait s'avérer complexe... jusqu'à l'arrivée d'une nouvelle fonctionnalité dans GitLab 16.4 !\n\n## Le cas idéal : des pipelines CI/CD indépendants pour un monorepo\n\nLorsque plusieurs applications coexistent dans un même dépôt, il est logique de vouloir disposer de pipelines CI/CD distincts pour chacune d'elles. Par exemple, si l'un de vos projets regroupe une application .NET et une application Spring, chacune d'elle nécessitera des jobs de compilation et de test différents. L'idéal serait donc de pouvoir découpler ces pipelines pour qu'ils s'exécutent uniquement lorsque des modifications sont apportées au code source de l'application concernée.\n\nTechniquement, cela revient à configurer un fichier de pipeline `.gitlab-ci.yml` au niveau du projet, qui inclut des fichiers YAML spécifiques basés sur les modifications détectées dans certains répertoires. Le fichier de pipeline `.gitlab-ci.yml` agit comme un plan de contrôle qui déclenche le pipeline approprié en fonction des modifications apportées au code.\n\n## Ancienne approche : le contournement\n\nAvant l'introduction de nouvelles fonctionnalités dans GitLab 16.4, il n'était pas possible d'inclure directement un fichier YAML en fonction des modifications apportées à un répertoire ou un fichier spécifique. Une solution de contournement était toutefois disponible. \n\nPrenons un exemple concret : un monorepo avec deux répertoires, `java` et `python`, contenant respectivement le code source d'une application Java et d'une application Python. Chaque répertoire disposait d'un fichier YAML propre à l'application pour gérer sa compilation. Le fichier de pipeline principal du projet incluait simplement les deux fichiers YAML des applications, mais une logique de gestion des modifications devait être directement intégrée dans ces fichiers.\n\n`.gitlab-ci.yml` :\n\n```\nstages:\n  - build\n  - test\n  - deploy\n\ntop-level-job:\n  stage: build\n  script:\n    - echo \"Hello world...\"\n\ninclude:\n  - local: '/java/j.gitlab-ci.yml'\n  - local: '/python/py.gitlab-ci.yml'\n\n```\n\nPour chaque application, il était nécessaire de créer un job masqué (par exemple, .java-common ou .python-common), qui ne s'exécutait qu'en présence de modifications apportées au répertoire correspondant. Les [jobs masqués](https://docs.gitlab.com/ee/ci/jobs/#hide-jobs) ne s'exécutaient pas par défaut. Ils servaient à centraliser la logique de déclenchement et à la réutiliser dans d'autres jobs. Cependant, cela impliquait d'étendre le job masqué dans chaque pipeline afin de respecter les règles de détection des modifications, qui déclenchaient alors le job d'exécution du pipeline. \n\n'j.gitlab-ci.yml':\n\n'''\nstages:\n  - build\n  - test\n  - deploy\n\n.java-common:\n  rules:\n    - changes:\n      - ../java/*'\n\njava-build-job:\n  extends: .java-common\n  stage: build\n  script:\n    - echo \"Building Java\"\n\njava-test-job:\n  extends: .java-common\n  stage: test\n  script:\n    - echo \"Testing Java\"\n\n'''\n\n'py.gitlab-ci.yml':\n\n'''\nstages:\n  - build\n  - test\n  - deploy\n\n.python-common:\n  rules:\n    - changes:\n      - \"../python/*\"\n\npython-build-job:\n  extends: .python-common\n  stage: build\n  script:\n    - echo \"Building Python\"\n\npython-test-job:\n  extends: .python-common\n  stage: test\n  script:\n    - echo \"Testing Python\"\n\n'''\n\nCette méthode fonctionnait, mais présentait des inconvénients majeurs. En effet, chaque pipeline devait étendre le job masqué pour chaque autre job dans le fichier YAML afin de respecter les règles de déclenchement. Elle avait pour conséquence la création de code redondant et l'augmentation du risque d'erreur humaine. De plus, les jobs étendus n'acceptaient pas de clés en double. Vous ne pouviez donc pas définir votre propre logique de règles (`rules`), car cela entraînait des conflits de clés et leurs [valeurs n'étaient pas fusionnées](https://docs.gitlab.com/ee/ci/yaml/index.html#extends). \n\nMalgré tout, avec cette méthode, le pipeline est opérationnel, incluant les jobs j.gitlab-ci.yml dès que le répertoire `java/` est mis à jour, et les jobs py.gitlab-ci.yml dès que le répertoire `python/` est mis à jour. \n\n## Nouvelle approche : l'inclusion conditionnelle des fichiers de pipeline\n\n\u003C!-- blank line -->\n\u003Cfigure class=\"video_container\">\n  \u003Ciframe src=\"https://www.youtube.com/embed/6phvk8jioAo?si=y6ztZODvUtM-cHmZ\" frameborder=\"0\" allowfullscreen=\"true\"> \u003C/iframe>\n\u003C/figure>\n\u003C!-- blank line ->\n\nAvec le lancement de GitLab 16.4, nous avons introduit une nouvelle fonctionnalité : la possibilité d'utiliser le terme [`include` avec `rules:changes` dans les pipelines CI/CD](https://docs.gitlab.com/ee/ci/yaml/includes.html#include-with-ruleschanges). Auparavant, vous pouviez utiliser l'option `include` avec `rules:if`, mais pas avec `rules:changes`. Cette nouvelle version est donc une amélioration majeure. Désormais, vous pouvez simplement utiliser le terme `include` et définir les règles du monorepo dans la configuration du pipeline de votre projet. \n\nNouveau fichier `.gitlab-ci.yml` :\n\n```\nstages:\n  - build\n  - test\n\ntop-level-job:\n  stage: build\n  script:\n    - echo \"Hello world...\"\n\ninclude:\n  - local: '/java/j.gitlab-ci.yml'\n    rules:\n      - changes:\n        - 'java/*'\n  - local: '/python/py.gitlab-ci.yml'\n    rules:\n      - changes:\n        - 'python/*'\n\n```\n\nAinsi, le fichier YAML de chaque application se concentre exclusivement sur les jobs nécessaires à cette application, comme la compilation et le test du code, sans avoir à étendre à plusieurs reprises un job masqué. Cette approche permet une plus grande flexibilité dans les définitions de job et les ingénieurs n'ont plus besoin de réécrire le code des configurations.\n\nNouveau fichier `j.gitlab-ci.yml` (Java) :\n\n```\nstages:\n  - build\n  - test\n  - deploy\n\njava-build-job:\n  stage: build\n  script:\n    - echo \"Building Java\"\n\njava-test-job:\n  stage: test\n  script:\n    - echo \"Testing Java\"\n\n```\n\nNouveau fichier `py.gitlab-ci.yml` (Python) :\n```\nstages:\n  - build\n  - test\n  - deploy\n\npython-build-job:\n  stage: build\n  script:\n    - echo \"Building Python\"\n\npython-test-job:\n  stage: test\n  script:\n    - echo \"Testing Python\"\n\n```\n\nCette méthode permet d'inclure les jobs Java et Python uniquement lorsque leurs répertoires respectifs sont modifiés. Cependant, il convient de noter que [les jobs peuvent s'exécuter de manière inattendue lors de l'utilisation de `changes`](https://docs.gitlab.com/ee/ci/jobs/job_troubleshooting.html#jobs-or-pipelines-run-unexpectedly-when-using-changes). La règle de déclenchement des modifications est toujours évaluée comme vraie lors du push d'une nouvelle branche ou d'un nouveau tag dans GitLab. Ainsi, tous les jobs inclus dans le pipeline s'exécuteront lors du premier push d'une branche, même si des règles `rules:changes` spécifiques sont définies. Vous pouvez résoudre ce problème en créant d'abord votre branche de fonctionnalité, puis en ouvrant une merge request pour commencer votre développement, car le premier push vers la branche lors de sa création forcera l'exécution de tous les jobs.\n\nEn fin de compte, les monorepos constituent une stratégie adaptée à GitLab et à l'approche CI/CD. La fonctionnalité `include` avec `rules:changes` est une bonne pratique que nous recommandons lors de l'utilisation de GitLab CI avec des monorepos. Pour utiliser les monorepos, commencez par essayer Gitlab Ultimate gratuitement dès aujourd'hui.\n",[9,684],"2025-05-27",{"slug":712,"featured":6,"template":691},"building-a-gitlab-ci-cd-pipeline-for-a-monorepo-the-easy-way","content:fr-fr:blog:building-a-gitlab-ci-cd-pipeline-for-a-monorepo-the-easy-way.yml","Building A Gitlab Ci Cd Pipeline For A Monorepo The Easy Way","fr-fr/blog/building-a-gitlab-ci-cd-pipeline-for-a-monorepo-the-easy-way.yml","fr-fr/blog/building-a-gitlab-ci-cd-pipeline-for-a-monorepo-the-easy-way",{"_path":718,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":719,"content":722,"config":730,"_id":732,"_type":14,"title":733,"_source":16,"_file":734,"_stem":735,"_extension":19},"/fr-fr/blog/ci-cd-inputs-secure-and-preferred-method-to-pass-parameters-to-a-pipeline",{"noIndex":6,"title":720,"description":721},"Intrants CI/CD : transmission de paramètres aux pipelines","Les intrants CI/CD de GitLab remplacent les variables par des paramètres typés et validés pour transmettre des instructions fiables et sécurisées aux pipelines.",{"heroImage":723,"body":724,"authors":725,"updatedDate":727,"date":728,"title":720,"tags":729,"description":721,"category":686},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1749658912/Blog/Hero%20Images/blog-image-template-1800x945__20_.png","Les intrants CI/CD représentent une avancée majeure dans la gestion des\npipelines. \n\nSpécialement conçus pour passer des paramètres typés, validés et sécurisés, ils instaurent des contrats explicites et une sécurité renforcée entre les composants de vos workflows et résolvent enfin les limites structurelles auxquelles les équipes de développement font face depuis des années avec les variables traditionnelles.\n\n\nLes variables CI/CD ont été détournées de leur usage initial. Historiquement, elles étaient conçues pour stocker des paramètres de configuration, et non comme un mécanisme sophistiqué de transmission de paramètres dans le cadre de workflows complexes. Ce décalage a entraîné son lot de problèmes : manque de fiabilité, failles de sécurité, complexité croissante en termes de maintenance.\n\n\nDans cet article, découvrez pourquoi les intrants CI/CD sont désormais l'approche recommandée pour passer des paramètres à vos pipelines, ainsi que leurs nombreux avantages (sécurité des types, prévention des échecs de pipeline, élimination des conflits entre variables, automatisation simplifiée). Des exemples concrets illustreront leur mise en œuvre et les problèmes qu'ils résolvent, dans l'espoir de vous convaincre d'abandonner les solutions de contournement à base de variables au profit d'une approche plus fiable et structurée.\n\n\n## Les coûts cachés de la transmission de paramètres via des variables\n\n\nUtiliser des variables pour passer des paramètres aux pipelines peut sembler pratique, mais cette approche peut être source de frustration et poser de nombreux risques. \n\n\n**Absence de validation des types**\n\n\nLes variables sont des chaînes de caractères. Sans validation des types, un pipeline peut recevoir accidentellement une chaîne à la place d'une valeur booléenne ou d'un nombre et entraîner des échecs inattendus. Un workflow de déploiement de production critique peut par exemple échouer quelques heures après son démarrage, car une vérification booléenne dans une variable n'a pas été transmise correctement.\n\n\n**Mutabilité pendant l'exécution**\n\n\nLes variables peuvent être modifiées à tout moment lors de l'exécution du pipeline, ce qui génère des comportements imprévisibles lorsque plusieurs jobs tentent de modifier les mêmes valeurs. Par exemple, deploy_job_a définit `DEPLOY_ENV=staging`, mais deploy_job_b attribue la valeur `production` à `DEPLOY_ENV`. \n\n\n**Risques de sécurité**\n\n\nLes variables utilisées comme de simples paramètres héritent souvent des mêmes autorisations d'accès que les secrets sensibles, ce qui entraîne des problèmes de sécurité. Il n'existe aucun contrat définissant les paramètres attendus par un pipeline, leurs types ou leurs valeurs par défaut. Ainsi, un paramètre apparemment anodin comme `BUILD_TYPE` peut soudainement se retrouver à tort avec un accès à des secrets de production simplement parce que les variables ne font pas intrinsèquement la distinction entre les paramètres et les données sensibles.\n\n\nPire encore, les erreurs ne sont détectées qu'au moment de l'exécution du pipeline, parfois après plusieurs minutes, voire plusieurs heures. Une simple variable mal configurée peut ainsi provoquer l'échec d'un pipeline, avec à la clé la perte de précieuses ressources [CI/CD](https://about.gitlab.com/fr-fr/topics/ci-cd/ \"Qu'est-ce que le CI/CD ?\") et une perte de temps pour l'équipe de développement. Pour limiter ces risques, les équipes recourent alors à des solutions de contournement, telles que des scripts de validation maison, une documentation excessive ou des conventions de nommage complexes, autant de tentatives pour renforcer du mieux possible la fiabilité de la transmission de paramètres basée sur des variables.\n\n\nNombreux sont les utilisateurs qui ont exprimé le besoin de disposer de fonctionnalités de débogage local pour tester les configurations de leurs pipelines avant le déploiement. Bien que cette solution semble logique, elle se révèle rapidement inefficace dans la pratique. Les workflows CI/CD s'appuient sur des dizaines de systèmes tiers (fournisseurs de services cloud, dépôts d'artefacts, scanners de sécurité, cibles de déploiement), qui ne peuvent tout simplement pas être répliqués localement. Même dans cette éventualité, la complexité rendrait les environnements de test locaux presque impossibles à maintenir. Face à ces limites, une remise en question s'imposait. Au lieu de chercher à mieux tester les pipelines localement, nous avons cherché à comprendre comment nous pouvions éviter les erreurs de configuration liées à la transmission de paramètres via des variables avant même l'exécution du workflow d'automatisation CI/CD.\n\n\n## Le casse-tête de la priorité des variables\n\n\nLe système de variables de GitLab comprend plusieurs [niveaux de priorité](https://docs.gitlab.com/ci/variables/#cicd-variable-precedence) qui offrent une grande flexibilité en fonction des cas d'utilisation rencontrés. Bien que ce système soit utile dans de nombreux scénarios, comme permettre aux administrateurs de définir des valeurs par défaut à l'échelle de l'instance ou du groupe tout en autorisant les projets individuels à les remplacer si nécessaire, il peut créer des difficultés lors de la construction de composants de pipeline réutilisables.\n\n\nLorsque vous développez des composants ou des templates destinés à être partagés dans différents projets et groupes, la hiérarchie de priorité des variables peut rendre leur comportement moins prévisible. Par exemple, un template qui fonctionne parfaitement dans un projet peut produire des résultats différents dans un autre, simplement parce que certaines variables ont été redéfinies au niveau du groupe ou de l'instance et ne sont pas visibles dans la configuration locale du pipeline.\n\n\nLorsque vous combinez plusieurs templates, il devient alors difficile de savoir quelles variables sont définies ainsi qu'où et comment elles interagissent.\n\n\nEn outre, les auteurs de composants doivent non seulement documenter les variables que leur template utilise, mais également identifier les risques de conflits avec des variables susceptibles d'être définies à des niveaux de priorité plus élevés.\n\n\n### Exemples de hiérarchie de priorité des variables\n\n\n**Fichier de pipeline principal (`.gitlab-ci.yml`) :**\n\n\n```yaml\n\nvariables:\n  ENVIRONMENT: production  # Top-level default for all jobs\n  DATABASE_URL: prod-db.example.com\n\ninclude:\n  - local: 'templates/test-template.yml'\n  - local: 'templates/deploy-template.yml'\n```\n\n\n**Template de test (`templates/test-template.yml`) :**\n\n\n```yaml\n\nrun-tests:\n  variables:\n    ENVIRONMENT: test  # Job-level variable overrides the default\n  script:\n    - echo \"Running tests in $ENVIRONMENT environment\"  \n    - echo \"Database URL is $DATABASE_URL\"  # Still inherits prod-db.example.com!\n    - run-integration-tests --env=$ENVIRONMENT --db=$DATABASE_URL\n    `# Issue: Tests run in \"test\" environment but against production database`\n```\n\n\n**Template de déploiement (`templates/deploy-template.yml`) :**\n\n\n```yaml\n\ndeploy-app:\n  script:\n    - echo \"Deploying to $ENVIRONMENT\"  # Uses production (top-level default)\n    - echo \"Database URL is $DATABASE_URL\"  # Uses prod-db.example.com\n    - deploy --target=$ENVIRONMENT --db=$DATABASE_URL\n    # This will deploy to production as intended\n```\n\n\n**Défis dans cet exemple :**\n\n\n1. Héritage partiel : le job de test hérite bien de `ENVIRONMENT=test`, mais conserve `DATABASE_URL=prod-db.example.com`.  \n\n2. Coordination complexe : les auteurs de templates doivent connaître l'ensemble des variables définies en amont pour éviter les conflits.  \n\n3. Remplacement imprévisible : lorsqu'une variable définie au niveau du job porte le même nom qu'une variable globale, elle la remplace — un comportement qui peut être difficile à anticiper. \n\n4. Dépendances cachées : les templates dépendent des noms de variables définis dans le pipeline principal.\n\n\nPour relever ces défis, GitLab a introduit les [intrants CI/CD](https://docs.gitlab.com/ee/ci/inputs/ \"Qu'est-ce qu'un intrant CI/CD ?\"), une solution dédiée à la transmission des paramètres aux pipelines, qui offre des paramètres typés, validés dès la création du pipeline et non au moment de son exécution.\n\n\n## Principes de base des intrants CI/CD\n\n\nLes intrants CI/CD permettent de définir des paramètres typés pour des pipelines réutilisables, avec une validation intégrée dès leur création. Conçus spécifiquement pour fournir des valeurs au moment de l'exécution du pipeline, ils instaurent un contrat explicite entre le pipeline et ses utilisateurs : chaque paramètre attendu y est clairement défini, ainsi que son type et ses contraintes.\n\n\n### Flexibilité et portée de la configuration\n\n\nL'un des avantages des intrants CI/CD est leur flexibilité en termes de temps de configuration. Évalués et interpolés dès la création du pipeline à l'aide du format d'interpolation `$[[ inputs.input-id ]]`, ils peuvent être utilisés dans toutes les parties de la configuration de votre pipeline, y compris les noms de jobs, les conditions de règles, les images de conteneurs et tout autre élément du fichier de configuration YAML. Ils contournent ainsi les limites liées à l'interpolation des variables dans certains contextes.\n\n\nVoici un cas d'utilisation courant : vous définissez des noms de jobs comme suit : `test-$[[ inputs.environment ]]-deployment`.\n\n\nEn intégrant des intrants CI/CD dans les noms de jobs, vous évitez les conflits lorsqu'un composant est inclus plusieurs fois dans un même pipeline. Sinon, le fait d'inclure le même composant deux fois entraînerait des conflits de noms de jobs, la deuxième inclusion écrasant la première. Les intrants CI/CD permettent au contraire de générer des noms de jobs uniques à chaque inclusion.\n\n\n**Voici le script sans les intrants CI/CD :**\n\n\n```yaml\n\ntest-service:\n  variables:\n    SERVICE_NAME: auth-service\n    ENVIRONMENT: staging\n  script:\n    - run-tests-for $SERVICE_NAME in $ENVIRONMENT\n```\n\n\n**Voici le script avec les intrants CI/CD :**\n\n\n```yaml\n\nspec:\n  inputs:\n    environment:\n      type: string\n    service_name:\n      type: string\n\ntest-$[[ inputs.service_name ]]-$[[ inputs.environment ]]:\n  script:\n    - run-tests-for $[[ inputs.service_name ]] in $[[ inputs.environment ]]\n```\n\n\nLorsqu'un composant est inclus plusieurs fois avec des intrants différents, il génère des jobs tels que `test-auth-service-staging`, `test-payment-service-production` et `test-notification-service-development`. Chaque job porte ainsi un nom unique et explicite qui indique clairement son objectif, ce qui renforce la visualisation du pipeline : en effet, cela évite que plusieurs jobs avec des noms identiques se remplacent les uns les autres.\n\n\nRevenons maintenant au premier exemple présenté au début de cet article, cette fois en tirant parti des intrants CI/CD. Premier avantage immédiat : au lieu de gérer plusieurs fichiers de templates, nous pouvons désormais n'en maintenir qu'un seul et le réutiliser avec des valeurs d'intrant personnalisées :\n\n\n```yaml\n\nspec:\n  inputs:\n    environment:\n      type: string\n    database_url:\n      type: string\n    action:\n      type: string\n---\n\n\n$[[ inputs.action ]]-$[[ inputs.environment ]]:\n  script:\n    - echo \"Running $[[ inputs.action ]] in $[[ inputs.environment ]] environment\"\n    - echo \"Database URL is $[[ inputs.database_url ]]\"\n    - run-$[[ inputs.action ]] --env=$[[ inputs.environment ]] --db=$[[ inputs.database_url ]]\n```\n\n\nDans le fichier principal `gitlab-ci.yml`, nous pouvons l'inclure deux fois (ou plus) avec des valeurs différentes, en veillant à éviter les conflits de noms.\n\n\n```yaml\n\ninclude:\n  - local: 'templates/environment-template.yml'\n    inputs:\n      environment: test\n      database_url: test-db.example.com\n      action: tests\n  - local: 'templates/environment-template.yml'\n    inputs:\n      environment: production\n      database_url: prod-db.example.com\n      action: deploy\n```\n\n\n**Résultat :** au lieu de maintenir des fichiers YAML distincts pour les jobs de test et de déploiement, vous disposez désormais d'un template réutilisable unique qui gère les deux cas d'utilisation en toute sécurité. Cette approche s'adapte à un nombre illimité d'environnements ou de types de jobs, ce qui réduit les frais de maintenance, élimine la duplication du code et garantit la cohérence de l'ensemble de la configuration de votre pipeline. Vous n'avez qu'un seul template à maintenir au lieu de plusieurs, sans risque de conflit de variables ni de dérive de configuration.\n\n\n### Validation et sécurité des types\n\n\nL'un des grands atouts des intrants CI/CD par rapport aux variables réside dans les capacités de validation des types. Ils prennent en charge différents types de valeurs, notamment les chaînes, les nombres, les valeurs booléennes et les tableaux, et la validation a lieu dès la création du pipeline. Si vous définissez un intrant CI/CD en tant que valeur booléenne, mais que vous passez une chaîne, GitLab rejette le pipeline avant l'exécution de tout job, ce qui vous permet d'économiser du temps et des ressources.\n\n\nVoici un exemple illustrant l'énorme avantage de la validation des types.\n\n\n**Sans validation des types (variables) :**\n\n\n```yaml\n\nvariables:\n  ENABLE_TESTS: \"true\"  # Always a string\n  MAX_RETRIES: \"3\"      # Always a string\n\ndeploy_job:\n  script:\n    - if [ \"$ENABLE_TESTS\" = true ]; then  # This fails!\n        echo \"Running tests\"\n      fi\n    - retry_count=$((MAX_RETRIES + 1))      # String concatenation: \"31\"\n```\n\n\n**Problème :** la vérification booléenne échoue, car « `true` » (chaîne) n'est pas égal à `true` (valeur booléenne).\n\n\n**Avec validation des types (intrants CI/CD) :**\n\n\n```yaml\n\nspec:\n  inputs:\n    enable_tests:\n      type: boolean\n      default: true\n    max_retries:\n      type: number\n      default: 3\n\n\n\n      \ndeploy_job:\n  script:\n    - if [ \"$[[ inputs.enable_tests ]]\" = true ]; then  # Works correctly\n        echo \"Running tests\"\n      fi\n    - retry_count=$(($[[ inputs.max_retries ]] + 1))    # Math works: 4\n```\n\n\n**Impact réel d'un échec de validation des types via des variables** : imaginons qu'un développeur ou processus déclenche un pipeline GitLab CI/CD avec `ENABLE_TESTS = yes` au lieu de `true`. Supposons qu'il faille en moyenne 30 minutes avant que le job de déploiement ne commence : lorsque ce job démarre, au bout de 30 minutes d'exécution du pipeline ou plus, le script de déploiement tente d'évaluer la valeur booléenne et échoue.  \n\n\nCela a un impact non seulement sur le délai de mise sur le marché, mais également sur le temps de débogage requis pour trouver la raison de l'échec d'un job de déploiement apparemment basique.\n\n\nAvec les intrants CI/CD basés sur la validation des types, GitLab CI/CD génère immédiatement une erreur et fournit un message d'erreur explicite concernant l'incompatibilité de type.\n\n\n### Sécurité et contrôle d'accès\n\n\nLes intrants CI/CD renforcent la sécurité, car ils contrôlent de façon stricte la transmission de paramètres avec des contrats explicites qui définissent précisément les valeurs attendues et autorisées. Ainsi, les limites sont claires entre les paramètres et la logique du pipeline. De plus, une fois le pipeline démarré, les intrants ne peuvent pas être modifiés pendant l'exécution, ce qui garantit un comportement prévisible tout au long du cycle de vie du pipeline et permet d'éliminer les risques de sécurité liés à la manipulation des variables en cours de route.\n\n\n### Portée et cycle de vie\n\n\nLes variables définies à l'aide du mot-clé `variables:` au niveau supérieur de votre fichier `.gitlab-ci.yml` s'appliquent par défaut à tous les jobs de votre pipeline. Lorsque vous incluez des templates, vous devez tenir compte de ces variables globales, car elles peuvent interagir avec le comportement attendu du template en raison de l'ordre de priorité des variables propre à GitLab.\n\n\nÀ l'inverse, les intrants CI/CD sont définis dans les fichiers de configuration CI (par exemple, les composants ou les templates), puis des valeurs leur sont attribuées lorsqu'un pipeline est déclenché, ce qui vous permet de personnaliser les configurations CI réutilisables. Ils servent uniquement à la création et la configuration du pipeline et sont limités au fichier de configuration CI où ils sont définis. Une fois l'exécution du pipeline lancée, ils ne peuvent plus être modifiés. Étant donné que chaque composant conserve ses propres intrants, il n'y a aucun risque d'interférence avec d'autres composants ou templates de votre pipeline. Cette approche prévient les conflits et les remplacements de variables qui sont fréquents avec le système traditionnel basé sur les variables globales.\n\n\n## Combiner variables et intrants\n\n\nDe nombreuses équipes utilisent de manière intensive des workflows basés sur les variables, et une migration complète vers les intrants CI/CD ne se fait pas du jour au lendemain. C'est pourquoi nous avons développé des mécanismes qui permettent d'utiliser à la fois des intrants et des variables pour favoriser la transition entre les deux systèmes et surmonter les principaux défis liés à l'expansion des variables.\n\n\nPrenons un exemple concret pour illustrer cette complémentarité.\n\n\n**Expansion des variables dans les conditions de règles**\n\n\nL'utilisation de variables qui contiennent d'autres références au sein des conditions `rules:if` peut s'avérer problématique. GitLab ne développe les variables que sur un niveau lors de l'évaluation de ces règles, ce qui peut entraîner des comportements inattendus :\n\n\n```yaml\n\n# This doesn't work as expected\n\n\nvariables:\n  TARGET_ENV:\n    value: \"${CI_COMMIT_REF_SLUG}\"\n\ndeploy-job:\n  rules:\n    - if: '$TARGET_ENV == \"production\"'  # Compares \"${CI_COMMIT_REF_SLUG}\" != \"production\"\n      variables:\n        DEPLOY_MODE: \"blue-green\"\n```\n\n\nLa fonction `expand_vars` résout ce problème en forçant une expansion appropriée des variables dans les intrants :\n\n\n```yaml\n\nspec:\n  inputs:\n    target_environment:\n      description: \"Target deployment environment\"\n      default: \"${CI_COMMIT_REF_SLUG}\"\n---\n\n\n\ndeploy-job:\n  rules:\n    - if: '\"$[[ inputs.target_environment | expand_vars ]]\" == \"production\"'\n      variables:\n        DEPLOY_MODE: \"blue-green\"\n        APPROVAL_REQUIRED: \"true\"\n    - when: always\n      variables:\n        DEPLOY_MODE: \"rolling\"\n        APPROVAL_REQUIRED: \"false\"\n  script:\n    - echo \"Target: $[[ inputs.target_environment | expand_vars ]]\"\n    - echo \"Deploy mode: ${DEPLOY_MODE}\"\n```\n\n\n### L'importance d'une telle opérabilité\n\n\nSans `expand_vars`, les conditions de règles sont évaluées à partir de la référence littérale d'une variable (comme `\"${CI_COMMIT_REF_SLUG}\"`) plutôt que sa variable développée (comme `\"production\"`). Il en résulte des règles qui ne se déclenchent pas comme prévu et brisent la logique conditionnelle du pipeline.\n\n\n**Remarques importantes concernant expand_vars :**\n\n\n* Seules les variables qui peuvent être utilisées avec le terme *include* sont prises en charge.  \n\n* Les variables doivent être rendues accessibles (non marquées comme protégées/masquées).  \n\n* L'expansion des variables imbriquées n'est pas prise en charge.  \n\n* Les conditions de règles avec `expand_vars` doivent être correctement citées : `'\"$[[ inputs.name | expand_vars ]]\" == \"value\"'`.\n\n\nCe mécanisme résout la limitation d'expansion de variables à un seul niveau et fonctionne pour toute logique conditionnelle qui nécessite de comparer des valeurs de variables entièrement résolues.\n\n\n### Chaînage de fonctions pour un traitement avancé\n\n\nEn plus de `expand_vars`, vous pouvez chaîner d'autres fonctions telles que `truncate` pour raccourcir les valeurs aux restrictions de nommage (par exemple, celles imposées par les noms de ressources [Kubernetes](https://about.gitlab.com/fr-fr/blog/2024/07/25/kubernetes-the-container-orchestration-solution/ \"Qu'est-ce que Kubernetes\")). Vous pouvez ainsi créer des pipelines plus sophistiqués, capables de traiter les paramètres tout en maintenant la sécurité et la prévisibilité qu'offrent les intrants CI/CD.\n\n\n```yaml\n\nspec:  \n  inputs:\n    service_identifier:\n      default: 'service-$CI_PROJECT_NAME-$CI_COMMIT_REF_SLUG'\n---\n\n\ncreate-resource:\n  script:\n    - resource_name=$[[ inputs.service_identifier | expand_vars | truncate(0,50) ]]\n```\n\n\nCette capacité d'intégration vous permet d'adopter progressivement les intrants CI/CD tout en tirant parti de votre infrastructure de variables existante, ce qui facilite la migration vers le nouveau système.\n\n\n### Des composants uniquement aux pipelines CI complets\n\n\nJusqu'à la version GitLab 17.11, les intrants n'étaient réservés qu'aux composants et templates inclus via la syntaxe `include:`, ce qui limitait leur utilisation aux configurations CI/CD réutilisables, mais ne répondait pas au besoin plus large de personnalisation dynamique des pipelines.\n\n\n### Prise en charge des intrants à l'échelle du pipeline\n\n\nÀ partir de GitLab 17.11, les intrants peuvent désormais être utilisés pour modifier en toute sécurité le comportement du pipeline dans tous les contextes d'exécution associés afin de remplacer le recours traditionnel aux variables de pipeline. Cette prise en charge étendue inclut notamment les pipelines suivants :\n\n\n* Pipelines planifiés : définissez des intrants avec des valeurs par défaut pour les exécutions automatisées et autorisez le remplacement manuel si nécessaire.  \n\n* Pipelines en aval : transmettez des intrants structurés aux pipelines enfants et multi-projets, avec une validation et une sécurité des types garanties.  \n\n* Pipelines manuels : proposez une interface claire et validée pour la saisie des intrants.\n\n\nCes premières améliorations, auxquelles s'ajouteront prochainement d'autres fonctionnalités, permettent aux équipes de moderniser leurs pipelines tout en assurant une rétrocompatibilité progressive. Une fois les intrants CI/CD pleinement adoptés, vous pouvez désactiver les variables de pipeline pour garantir un environnement CI/CD plus sécurisé et prévisible.\n\n\n## Résumé\n\n\nLa migration des variables vers les intrants CI/CD représente plus qu'une simple mise à niveau technique : cette évolution garantit des [pipelines CI/CD](https://about.gitlab.com/fr-fr/topics/ci-cd/cicd-pipeline/ \"Qu'est-ce qu'un pipeline CI/CD ?\") plus faciles à maintenir, plus prévisibles et plus sécurisés. Même si les variables continuent de servir des objectifs importants dans de nombreux scénarios de configuration, les intrants CI/CD fournissent les capacités de transmission de paramètres tant attendues par les équipes de développement.\n\n\nConscients que les variables sont profondément intégrées dans les workflows actuels, nous avons conçu des passerelles entre les deux systèmes. La fonction `expand_vars` et d'autres capacités d'intrant permettent de tirer parti de ce mécanisme, mais aussi de votre infrastructure de variables existante.\n\n\nEn commençant par de nouveaux composants et templates, puis en migrant progressivement les workflows critiques, vous constaterez rapidement les avantages de contrats explicites, d'une détection précoce des erreurs et d'une automatisation plus fiable qui s'étend à l'ensemble de votre entreprise. De plus, l'adoption des intrants CI/CD constitue un socle idéal pour tirer pleinement parti du [catalogue CI/CD de GitLab](https://gitlab.com/explore/catalog). Grâce à leurs interfaces typées, les composants réutilisables deviennent des fondamentaux puissants pour structurer vos workflows [DevOps](https://about.gitlab.com/fr-fr/topics/devops/ \"Qu'est-ce que l'approche DevOps ?\"). Nous reviendrons sur ce sujet en détail dans un prochain article.\n\n\nAdopter les intrants CI/CD aujourd'hui, c'est investir dans des pipelines plus robustes, plus lisibles, plus compréhensibles pour demain. Même si vous utilisez déjà un système basé sur des variables, les intrants peuvent être intégrés progressivement afin d'assurer une transition en douceur.\n\n\n## Prochaines étapes\n\n\nNous prévoyons d'étendre les capacités actuelles des intrants en vue de résoudre deux enjeux clés : améliorer le déclenchement des pipelines avec des options en cascade qui [s'ajustent dynamiquement au choix de l'utilisateur](https://gitlab.com/gitlab-org/gitlab/-/issues/520094) et introduire des intrants au niveau des jobs afin de pouvoir [relancer des jobs spécifiques avec des paramètres différents](https://gitlab.com/groups/gitlab-org/-/epics/17833). Nous vous encourageons à suivre ces discussions, à partager vos retours et à contribuer à façonner le développement de ces fonctionnalités via notre [ticket dédié aux retours d'expérience](https://gitlab.com/gitlab-org/gitlab/-/issues/407556).\n",[726],"Dov Hershkovitch","2025-08-07","2025-07-07",[9],{"featured":6,"template":691,"slug":731},"ci-cd-inputs-secure-and-preferred-method-to-pass-parameters-to-a-pipeline","content:fr-fr:blog:ci-cd-inputs-secure-and-preferred-method-to-pass-parameters-to-a-pipeline.yml","Ci Cd Inputs Secure And Preferred Method To Pass Parameters To A Pipeline","fr-fr/blog/ci-cd-inputs-secure-and-preferred-method-to-pass-parameters-to-a-pipeline.yml","fr-fr/blog/ci-cd-inputs-secure-and-preferred-method-to-pass-parameters-to-a-pipeline",{"_path":737,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":738,"content":744,"config":752,"_id":754,"_type":14,"title":755,"_source":16,"_file":756,"_stem":757,"_extension":19},"/fr-fr/blog/data-driven-devsecops-exploring-gitlab-insights-dashboards",{"title":739,"description":740,"ogTitle":739,"ogDescription":740,"noIndex":6,"ogImage":741,"ogUrl":742,"ogSiteName":673,"ogType":674,"canonicalUrls":742,"schema":743},"Créez des tableaux de bord personnalisés avec GitLab Insights","Tirez parti des tableaux de bord GitLab Insights. Visualisez vos indicateurs clés, suivez la progression de vos projets et augmentez la productivité de vos équipes. ","https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097210/Blog/Hero%20Images/Blog/Hero%20Images/blog-image-template-1800x945%20%2811%29_78Dav6FR9EGjhebHWuBVan_1750097210214.png","https://about.gitlab.com/blog/data-driven-devsecops-exploring-gitlab-insights-dashboards","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Créez des tableaux de bord personnalisés avec GitLab Insights\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Ricardo Amarilla Villalba\"}],\n        \"datePublished\": \"2024-11-20\",\n      }\n                  ",{"title":739,"description":740,"authors":745,"heroImage":741,"date":747,"body":748,"category":686,"tags":749,"updatedDate":751},[746],"Ricardo Amarilla Villalba","2024-11-20","Les indicateurs et outils d'analyse sont des éléments indispensables pour stimuler la productivité, garantir la qualité et assurer le succès des équipes de développement logiciel. En tant que plateforme DevSecOps la plus complète, GitLab propose avec ses tableaux de bord GitLab Insights des outils puissants pour suivre et visualiser ces indicateurs essentiels. Découvrez dans cet article comment intégrer les tableaux de bord GitLab Insights à votre environnement.\n\n## Qu'est-ce que GitLab Insights ? \n\nGitLab fournit un éventail d'indicateurs et d'outils d'analyse qui couvrent divers aspects du cycle de vie [DevSecOps](https://about.gitlab.com/fr-fr/topics/devsecops/ \"Qu'est-ce que l'approche DevSecOps ? \") :\n\n1. [Analyse de la productivité](https://docs.gitlab.com/ee/user/analytics/productivity_analytics.html) : suivez la vélocité, la durée de cycle et le délai d'exécution de votre équipe.  \n2. [Analyse des revues de code](https://docs.gitlab.com/ee/user/analytics/code_review_analytics.html) : évaluez la qualité du code, la couverture de test et l'efficacité des revues.  \n3. [Analyse des pipelines CI/CD](https://docs.gitlab.com/ee/user/analytics/ci_cd_analytics.html) : surveillez les performances des pipelines et la fréquence de déploiement.  \n4. [Analyse du flux de valeur](https://docs.gitlab.com/ee/user/group/value_stream_analytics/) : visualisez le workflow, de l'idée au déploiement en production.  \n5. [Informations stratégiques](https://docs.gitlab.com/ee/user/project/insights/) : explorez et visualisez les données relatives à vos projets et groupes.\n\nCes indicateurs fournissent des informations précieuses sur votre processus de développement, permettant aux équipes d'identifier les goulots d'étranglement, d'optimiser les workflows et de prendre des décisions éclairées basées sur des données fiables.\n\n### Tirer parti des labels pour des indicateurs spécifiques\n\nSouvent sous-estimés, les labels figurent pourtant parmi les fonctionnalités les plus puissantes de GitLab. Ils permettent de filtrer et de cibler exactement les indicateurs qui vous intéressent. En appliquant stratégiquement des labels aux tickets, aux merge requests et aux epics, vous pouvez créer des vues personnalisées qui fournissent des informations détaillées sur la performance et la progression de votre projet.\n\nEn ajoutant des labels dans GitLab, vous pouvez facilement regrouper et organiser vos tâches selon vos propres critères, pour un suivi plus clair et plus efficace. Que vous suiviez le développement de fonctionnalités, les corrections de bogues ou les tâches spécifiques à une équipe, les labels vous permettent de segmenter les données de votre projet pour faire émerger des tendances claires. Ce concept est semblable à l'utilisation de tags dans les déploiements cloud, où les ressources sont étiquetées pour faciliter la gestion, la répartition des coûts et les informations opérationnelles.\n\nEn attribuant judicieusement des labels à vos éléments de travail, vous mettez en place un système de catégorisation avancé, idéal pour créer des tableaux de bord et des rapports sur mesure. Grâce à cette approche, vous pouvez cibler les indicateurs essentiels pour votre équipe ou vos parties prenantes, avec à la clé une vue claire et précise de l'état et de la dynamique de votre projet.\n\n## Comment configurer GitLab Insights ?\n\nGitLab Insights vous permet d'explorer et de visualiser les données relatives à vos projets et à vos groupes. GitLab Insights fournit des analyses précieuses sur divers aspects : les tickets créés et fermés au cours d'une période donnée, le temps moyen nécessaire pour fusionner des merge requests et la qualité du classement par ordre de priorité. GitLab Insights peut être configuré à la fois pour les projets et les groupes.\n\nPour configurer GitLab Insights :\n\n1. Pour les informations stratégiques liées au projet :  \n   * Créez un fichier nommé `.gitlab/insights.yml` dans le répertoire racine de votre projet.  \n2. Pour les informations stratégiques liées au groupe :  \n   * Créez un fichier `.gitlab/insights.yml` dans un projet appartenant à votre groupe.  \n   * Accédez aux paramètres de votre groupe.  \n   * Développez la section **Analyse** et cliquez sur **Analyses**.  \n   * Sélectionnez le projet contenant le fichier de configuration et enregistrez les modifications.\n\nLe fichier `.gitlab/insights.yml` est un fichier YAML qui sert à organiser vos rapports : il permet de structurer l'ordre des graphiques et de définir leur apparence. Chaque graphique est défini avec des paramètres comme le titre, la description, le type et la requête pour déterminer la source des données et les conditions de filtrage.\n\nPour afficher les informations, accédez à **Analyse > Analyses** dans votre projet ou groupe.\n\n![Afficher le tableau de bord GitLab Insights par défaut](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097218/Blog/Content%20Images/Blog/Content%20Images/image3_aHR0cHM6_1750097217972.png)\n\nLa vue par défaut fournit des données utiles, mais en personnalisant le tableau de bord GitLab Insights, vous pouvez aller encore plus loin pour voir, par exemple, l'équipe à l'origine de chaque merge request ou la nature des problèmes traités.\n\n### Informations sur les merge requests pour chaque squad et type de besoin\n\nMesurer la productivité d'une squad dans GitLab n'est pas toujours évident, surtout lorsque l'organisation des groupes et sous-groupes ne reflète pas fidèlement la structure réelle de votre squad. Voici comment surmonter ces défis et suivre efficacement la productivité des squads :\n\n### Configuration des indicateurs en fonction des squads\n\n1. **Création de labels :** créez des labels à portée limitée spécifiques à chaque squad (par exemple, `squad::alpha`, `squad::beta`) et à chaque type d'exigence (par exemple, `type::bug`, `type::feature`, `type::maintenance`).\n\n\u003C!-- blank line -->\n\u003Cfigure class=\"video_container\">\n  \u003Ciframe src=\"https://www.youtube.com/embed/ZUOzORIUJeU?si=T8eHeGizS3blYFHB\" frameborder=\"0\" allowfullscreen=\"true\"> \u003C/iframe>\n\u003C/figure>\n\u003C!-- blank line -->\n\n2. **Application des labels :** appliquez systématiquement ces labels à tous les tickets et merge requests traités par chaque squad, quel que soit le projet ou le groupe auquel ils appartiennent.  \n\n\u003C!-- blank line -->\n\u003Cfigure class=\"video_container\">\n  \u003Ciframe src=\"https://www.youtube.com/embed/fJ9entEBZG8?si=MlM6mKirEdkmwDDJ\" frameborder=\"0\" allowfullscreen=\"true\"> \u003C/iframe>\n\u003C/figure>\n\u003C!-- blank line -->\n\n**Conseils :**  \n   * Utilisez l'API GitLab pour appliquer massivement des labels aux merge requests ouvertes, fusionnées et fermées existantes.  \n   * Ajoutez, supprimez ou mettez à jour des labels dans le cadre de votre pipeline GitLab CI.  \n   * Utilisez le bot de tri des tickets de GitLab pour automatiser l'ajout de labels.  \n\n3. **Configuration du tableau de bord :** créez un fichier `.gitlab/insights.yml` dans le dépôt de votre projet avec des graphiques personnalisés pour obtenir des informations sur les merge requests spécifiques à l'équipe et au type.\n\n```\n\n## Default Merge Requests insights.yml \nmergeRequests:\n  title: Merge requests dashboard\n  charts:\n    - title: Merge requests merged per week \n      type: bar\n      query:\n        data_source: issuables\n        params:\n          issuable_type: merge_request\n          issuable_state: merged\n          group_by: week\n          period_limit: 12\n    - title: Merge requests merged per month\n      type: bar\n      query:\n        data_source: issuables\n        params:\n          issuable_type: merge_request\n          issuable_state: merged\n          group_by: month\n          period_limit: 3\n\n## Per-teams Merge Requests insights.yml\nmergeRequestsTeams:\n  title: Merge requests dashboard per teams\n  charts:\n    - title: Merge requests merged per week \n      type: stacked-bar\n      query:\n        data_source: issuables\n        params:\n          issuable_type: merge_request\n          issuable_state: merged\n          group_by: week\n          period_limit: 12\n          collection_labels:\n            - squad::alpha\n            - squad::beta\n    - title: Merge requests merged per month\n      type: stacked-bar\n      query:\n        data_source: issuables\n        params:\n          issuable_type: merge_request\n          issuable_state: merged\n          group_by: month\n          period_limit: 3\n          collection_labels:\n            - squad::alpha\n            - squad::beta\n\n## Per-teams and Type Merge Requests insights.yml\nmergeRequestsTeamsAndType:\n  title: Per Teams and Type - Merge requests dashboard\n  charts:\n    - title: Merge requests merged per week - Squad Alpha\n      type: stacked-bar\n      query:\n        data_source: issuables\n        params:\n          issuable_type: merge_request\n          issuable_state: merged\n          filter_labels: squad::alpha\n          collection_labels:\n            - type::feature\n            - type::bug\n            - type::maintenance\n          group_by: week\n          period_limit: 12\n    - title: Merge requests merged per month - Squad Alpha\n      type: stacked-bar\n      query:\n        data_source: issuables\n        params:\n          issuable_type: merge_request\n          issuable_state: merged\n          filter_labels: squad::alpha\n          collection_labels:\n            - type::feature\n            - type::bug\n            - type::maintenance\n          group_by: month\n          period_limit: 3\n    - title: Merge requests merged per week - Squad Beta\n      type: stacked-bar\n      query:\n        data_source: issuables\n        params:\n          issuable_type: merge_request\n          issuable_state: merged\n          filter_labels: squad::beta\n          collection_labels:\n            - type::feature\n            - type::bug\n            - type::maintenance\n          group_by: week\n          period_limit: 12\n    - title: Merge requests merged per month - Squad Beta\n      type: stacked-bar\n      query:\n        data_source: issuables\n        params:\n          issuable_type: merge_request\n          issuable_state: merged\n          filter_labels: squad::beta\n          collection_labels:\n            - type::feature\n            - type::bug\n            - type::maintenance\n          group_by: month\n          period_limit: 3\n\n```\n\nEn personnalisant vos tableaux de bord, vous bénéficiez d'une vue d'ensemble claire de l'activité des merge requests, classée par équipe et par type. Vous pouvez ainsi suivre l'évolution dans le temps, comparer les performances entre les squads et visualiser comment le travail est réparti entre elles.\n\n![tableaux de bord permettant de visualiser l'activité des merge requests par équipe et par type de besoin](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097218/Blog/Content%20Images/Blog/Content%20Images/image2_aHR0cHM6_1750097217972.png)\n\n![tableau de bord comparant les performances entre les squads](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097218/Blog/Content%20Images/Blog/Content%20Images/image1_aHR0cHM6_1750097217974.png)\n\n## Lancez-vous dès aujourd'hui\n\nEn matière d'indicateurs et d'outils d'analyse, les tableaux de bord GitLab Insights ne sont que la partie émergée de l'iceberg. Pour explorer toute la gamme de fonctionnalités d'analyse de GitLab, notamment l'analyse du flux de valeur, l'analyse des [pipelines CI/CD](https://about.gitlab.com/fr-fr/topics/ci-cd/cicd-pipeline/ \"Qu'est-ce qu'un pipeline CI/CD ?\") et les indicateurs liés aux revues de code, cliquez sur l'image ci-dessous et découvrez comment optimiser le développement de logiciels avec la gestion de la chaîne de valeur. \n\n[![Visite guidée du produit de gestion de la chaîne de valeur](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097218/Blog/Content%20Images/Blog/Content%20Images/Screenshot_2024-11-20_at_12.28.08_PM_aHR0cHM6_1750097217976.png)](https://gitlab.navattic.com/vsm)\n\n> Et si vous commenciez à créer vos propres tableaux de bord ? [Essayez GitLab Ultimate gratuitement]( https://gitlab.com/-/trials/new?glm_content=default-saas-trial&glm_source=about.gitlab.com%2F) et exploitez pleinement le potentiel de l'approche DevSecOps fondée sur les données.\n",[9,685,686,750,684,687],"features","2025-06-02",{"slug":753,"featured":91,"template":691},"data-driven-devsecops-exploring-gitlab-insights-dashboards","content:fr-fr:blog:data-driven-devsecops-exploring-gitlab-insights-dashboards.yml","Data Driven Devsecops Exploring Gitlab Insights Dashboards","fr-fr/blog/data-driven-devsecops-exploring-gitlab-insights-dashboards.yml","fr-fr/blog/data-driven-devsecops-exploring-gitlab-insights-dashboards",{"_path":759,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":760,"content":766,"config":776,"_id":778,"_type":14,"title":779,"_source":16,"_file":780,"_stem":781,"_extension":19},"/fr-fr/blog/demystifying-ci-cd-variables",{"title":761,"description":762,"ogTitle":761,"ogDescription":762,"noIndex":6,"ogImage":763,"ogUrl":764,"ogSiteName":673,"ogType":674,"canonicalUrls":764,"schema":765},"Variables d’environnement : tout savoir sur les variables CI/CD de GitLab","Les variables CI/CD permettent de contrôler les jobs et les pipelines. Découvrez tout ce que vous devez savoir sur les variables d'environnement de GitLab.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749664679/Blog/Hero%20Images/blog-image-template-1800x945__24_.png","https://about.gitlab.com/blog/demystifying-ci-cd-variables","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Variables d’environnement : tout savoir sur les variables CI/CD de GitLab\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Veethika Mishra\"}],\n        \"datePublished\": \"2021-04-09\",\n      }",{"title":761,"description":762,"authors":767,"heroImage":763,"date":769,"body":770,"category":681,"tags":771,"updatedDate":775},[768],"Veethika Mishra","2021-04-09","Définir et utiliser des variables dans le cadre d'une approche [CI/CD](https://about.gitlab.com/fr-fr/topics/ci-cd/) s'avère une méthode très flexible. Ces variables sont d'une grande utilité pour contrôler les jobs et les pipelines, tout en vous permettant d'éviter de coder en dur des valeurs directement dans votre fichier de configuration `.gitlab-ci.yml`. \n\nDans [GitLab CI/CD](https://docs.gitlab.com/ee/ci/), les variables peuvent être utilisées pour personnaliser les jobs en définissant et en stockant des valeurs spécifiques. Pour définir vos variables CI/CD dans GitLab, accédez à **Paramètres >> CI/CD >> Variables** ou définissez-les simplement dans le fichier `.gitlab-ci.yml`. Sachez que les variables servent également d'alternative aux valeurs codées en dur.\n\nUtiliser des variables s’avère particulièrement utile pour configurer des services tiers dans différents environnements de déploiement, tels que l'environnement de test (`testing`), l'environnement de préproduction (`staging`), l'environnement de production (`production`), et plus encore. Pour modifier les services liés à ces environnements, il suffit de changer simplement la variable qui pointe vers le point de terminaison d'API associé aux services. Vous pouvez également utiliser des variables pour configurer les jobs et les rendre disponibles en tant que variables d'environnement dans les jobs lorsqu'ils s'exécutent.\n\nDécouvrez dans cet article tout ce que vous devez savoir sur les variables d’environnement afin de mieux comprendre leur fonctionnement et leur portée. \n\n![GitLab lit le fichier .gitlab-ci.yml pour analyser la variable référencée, puis envoie les informations à GitLab Runner. Les variables sont exposées et générées par le runner.](https://about.gitlab.com/images/blogimages/demystifying-ci-cd-variables/variables_processing.jpeg)\n\n## La relation entre les variables et les environnements\n\nLe processus de développement logiciel comprend plusieurs étapes destinées à tester un produit avant de le déployer et de le mettre à disposition des utilisateurs. Les [environnements](https://docs.gitlab.com/ee/ci/environments/) sont utilisés pour définir ces étapes, qui peuvent différer d'une équipe à l'autre, voire d'une entreprise à l'autre.\n\nLes variables, quant à elles, sont des valeurs de données susceptibles de changer à la suite d'une interaction entre un utilisateur et un produit. Par exemple, son âge, ses préférences ou toute autre information qui pourrait déterminer l'étape suivante qui lui sera présentée dans le flux de tâches du produit.\n\nLe terme [variable d'environnement](https://docs.gitlab.com/ee/administration/environment_variables.html) fait souvent référence à des variables définies dans un environnement donné, mais en dehors de l'application. Les variables dans GitLab CI/CD offrent aux équipes de développement la possibilité de configurer des valeurs dans le code. L'intérêt principal étant de garantir sa flexibilité. Ces variables permettent aux utilisateurs de modifier une application déployée dans un certain environnement sans toucher au code. Il est possible d'exécuter des tests en toute simplicité ou même d'intégrer des services tiers en modifiant une variable d'environnement de configuration en dehors de l'application.\n\n## La portée des variables dans l'approche CI/CD\n\n![Ordre de priorité des variables CI/CD : 1) Exécution manuelle du pipeline, variables de déclenchement et de planification du pipeline, 2) Variables protégées au niveau du projet, au niveau du groupe et au niveau de l'instance, 3) Variables CI/CD héritées, 4) Variables globales définies dans yml au niveau du job, 5) Variables de déploiement, 6) Variables CI/CD prédéfinies](https://about.gitlab.com/images/blogimages/demystifying-ci-cd-variables/variables_precedence.jpeg)\n\n### Variables définies dans `.gitlab-ci.yml`\n\nLes variables qui doivent être disponibles dans l'environnement du job peuvent être ajoutées à GitLab. Ces variables CI/CD stockent la configuration du projet ne contenant pas de données sensibles, comme l'URL de la base de données dans le fichier `.gitlab-ci.yml`. Réutilisez cette variable dans plusieurs jobs ou scripts, là où la valeur est nécessaire. Si la valeur change, vous n'avez besoin de mettre à jour la variable qu'une seule fois. Le changement se reflète ensuite partout où la variable est utilisée.\n\n### Variables CI/CD au niveau du projet\n\nUn cran au-dessus des exigences spécifiques au dépôt, vous pouvez définir des variables CI/CD dans les [paramètres du projet](https://docs.gitlab.com/ee/ci/variables/#for-a-project), afin qu'elles soient disponibles dans les [pipelines CI/CD](https://about.gitlab.com/fr-fr/topics/ci-cd/cicd-pipeline/ \"Qu'est-ce qu'un pipeline CI/CD ?\"). Celles-ci sont stockées en dehors du dépôt (c'est-à-dire qu'elles ne figurent pas dans le fichier `.gitlab-ci.yml`), mais peuvent néanmoins être utilisées dans les scripts et la configuration CI/CD. Le stockage des variables en dehors du fichier `.gitlab-ci.yml` limite ces valeurs à la portée du projet uniquement, sans les enregistrer en texte brut dans le projet.\n\n### Variables CI/CD au niveau du groupe et de l'instance\n\nCertaines variables sont pertinentes à l'échelle du groupe ou de l'instance et peuvent être utiles à tous les projets associés à un groupe ou à une instance spécifique. Définissez les variables dans les [paramètres du groupe ou de l'instance](https://docs.gitlab.com/ee/ci/variables/#for-a-group) afin que tous les projets de ces portées puissent utiliser les variables sans avoir besoin d'en connaître la valeur ou de les recréer pour chaque projet de portée inférieure. Par exemple, une valeur commune à plusieurs projets se gère facilement si elle ne doit être mise à jour qu'à un seul endroit. Alternativement, plusieurs projets peuvent utiliser un mot de passe spécifique sans avoir besoin de connaître la valeur du mot de passe lui-même.\n\n## Jobs et pipelines en tant qu'environnements\n\nEn plus d'être utilisées comme des variables d'environnement, les variables dans GitLab CI/CD fonctionnent également dans la portée du fichier de configuration `.gitlab-ci.yml` pour définir le comportement du pipeline, indépendamment de son environnement. Les variables peuvent être stockées dans les paramètres du projet/groupe/instance et mises à la disposition des jobs dans les pipelines.\n\nPar exemple :\n\n```  \njob:  \n  rules:  \n    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH  \n  script:  \n  - echo \"This job ran on the $CI_COMMIT_BRANCH branch.\"  \n```\n\nLa variable `($CI_COMMIT_BRANCH)` dans la section du script s'exécute dans la portée du job dans lequel elle a été définie. Cette portée est l'« environnement du job », ce qui signifie que lorsque le job se lance, le GitLab Runner démarre un conteneur Docker et exécute le job dans cet environnement. Le runner met cette variable (et toutes les autres variables prédéfinies ou personnalisées) à la disposition du job et peut également afficher leur valeur dans les données de sortie du log si nécessaire.\n\nToutefois, la variable est aussi utilisée dans la section `if:` pour déterminer quand le job doit s'exécuter. Il ne s'agit pas en soi d'un environnement, c'est pourquoi nous les appelons variables CI/CD. Elles peuvent être utilisées pour configurer dynamiquement vos jobs CI/CD, ainsi que comme variables d'environnement lorsque le job est en cours d'exécution.\n\n## Variables prédéfinies\n\nUn certain nombre de variables sont [prédéfinies](https://docs.gitlab.com/ee/ci/variables/predefined_variables.html) lorsqu'un pipeline GitLab CI/CD démarre. Un utilisateur peut immédiatement accéder aux valeurs pour des éléments tels que les validations, le projet ou les détails du pipeline sans avoir à définir les variables elles-mêmes.\n\n## Variables CI/CD personnalisées\n\n![Les runners peuvent créer deux types de variables CI/CD personnalisées : Type et Fichier.](https://about.gitlab.com/images/blogimages/demystifying-ci-cd-variables/variable_types.jpeg)\n\nLors de la création d'une variable CI/CD dans les paramètres, GitLab offre à l'utilisateur plus d'options pour configurer la variable. Utilisez ces options de configuration supplémentaires pour exercer un contrôle plus strict sur les variables plus sensibles :\n\n**Portée de l'environnement :** si une variable ne doit être utilisée que dans un environnement spécifique, définissez-la pour qu'elle soit disponible uniquement dans cet environnement. Par exemple, vous pouvez définir un jeton de déploiement pour qu'il ne soit disponible que dans l'environnement `production`.\n\n**Variables protégées :** comme pour la portée de l'environnement, vous pouvez définir une variable pour qu'elle ne soit disponible que lorsque le pipeline s'exécute sur une branche protégée, comme votre branche par défaut.\n\n**Type de variable :** certaines applications nécessitent que la configuration leur soit transmise sous la forme d'un fichier. Si une application nécessite cette configuration, définissez simplement le type de variable comme « Fichier ». Cette configuration de la variable CI/CD signifie que lorsque le runner rend la variable disponible dans l'environnement, il l'écrit dans un fichier temporaire et stocke le chemin d'accès au fichier en tant que valeur. Un utilisateur peut ensuite transmettre le chemin d'accès au fichier à toutes les applications qui en ont besoin.\n\nEn plus des éléments énumérés pour définir et utiliser les variables, GitLab a introduit une fonctionnalité qui génère des variables préremplies lorsqu'un pipeline doit être exécuté manuellement. Les variables préremplies réduisent les risques d'erreur et facilitent l'exécution du pipeline.\n\n**Variables masquées :** les [variables masquées](https://docs.gitlab.com/ee/ci/variables/#mask-a-cicd-variable) sont des variables CI qui ont été **cachées dans les job logs** pour empêcher l'affichage de leur valeur.\n\n**Variables masquées et cachées :** introduites dans [GitLab 17.4](https://about.gitlab.com/releases/2024/09/19/gitlab-17-4-released/#hide-cicd-variable-values-in-the-ui), les variables [masquées et cachées](https://docs.gitlab.com/ee/ci/variables/#hide-a-cicd-variable) offrent la même fonctionnalité de masquage des job logs et **gardent la valeur cachée** **dans l'interface utilisateur des paramètres**. Nous ne recommandons pas d'utiliser ces deux types de variables pour les informations sensibles (comme les secrets), car elles peuvent être exposées par inadvertance.\n\n## Secrets\n\nUn secret est un identifiant de connexion sensible qui doit rester confidentiel. Voici des exemples de secrets :\n\n* Mots de passe\n* Clés SSH\n* Jetons d'accès\n* Tout autre type d'identifiants de connexion dont la divulgation pourrait porter préjudice à l'entreprise\n\nGitLab permet actuellement à ses utilisateurs d'[utiliser des secrets externes](https://docs.gitlab.com/ee/ci/secrets/) dans l'[intégration continue (CI)](https://about.gitlab.com/fr-fr/topics/ci-cd/benefits-continuous-integration/ \"Qu'est-ce que l'intégration continue (CI) ?\"), en tirant parti de HashiCorp Vault, Google Cloud Secret Manager et Azure Key Vault pour gérer de manière sécurisée les clés, les tokens et d'autres secrets au niveau du projet. Les utilisateurs peuvent ainsi séparer ces secrets des autres variables CI/CD pour des raisons de sécurité.\n\n### Gestionnaire de secrets de GitLab\n\nEn plus de fournir une assistance pour les secrets externes dans la CI, GitLab prévoit également de proposer une [solution native de gestion des secrets](https://gitlab.com/groups/gitlab-org/-/epics/10108) permettant de stocker les secrets de manière pratique et sécurisée au sein de sa plateforme. Cette solution aidera également les clients à utiliser les secrets stockés dans les composants et les environnements spécifiques à GitLab, ainsi qu'à gérer facilement les accès au niveau des groupes d'espaces de nommage et des projets.\n\nPour en savoir plus sur le gestionnaire de secrets de GitLab, consultez notre article « [Le gestionnaire de secrets natif de GitLab renforce la sécurité de la chaîne d'approvisionnement logicielle](https://about.gitlab.com/blog/gitlab-native-secrets-manager-to-give-software-supply-chain-security-a-boost/) ». \n\n***Avertissement :** cet article de blog contient des informations relatives aux produits, fonctionnalités et caractéristiques à venir. Il est important de noter que les informations contenues dans cet article de blog ne sont fournies qu'à titre informatif. Veuillez ne pas vous fier à ces informations à des fins d'achat ou de planification. Comme pour tout projet, les éléments mentionnés dans cet article sont susceptibles de changer ou d’être retardés. Le développement, la sortie et le calendrier de tout produit ou fonctionnalité restent à la seule discrétion de GitLab.*\n",[772,750,773,774,9,684],"CD","inside GitLab","CI","2025-01-28",{"slug":777,"featured":6,"template":691},"demystifying-ci-cd-variables","content:fr-fr:blog:demystifying-ci-cd-variables.yml","Demystifying Ci Cd Variables","fr-fr/blog/demystifying-ci-cd-variables.yml","fr-fr/blog/demystifying-ci-cd-variables",{"_path":783,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":784,"content":790,"config":797,"_id":799,"_type":14,"title":800,"_source":16,"_file":801,"_stem":802,"_extension":19},"/fr-fr/blog/from-code-to-production-a-guide-to-continuous-deployment-with-gitlab",{"title":785,"description":786,"ogTitle":785,"ogDescription":786,"noIndex":6,"ogImage":787,"ogUrl":788,"ogSiteName":673,"ogType":674,"canonicalUrls":788,"schema":789},"Du code à la production : guide du déploiement continu avec GitLab","Découvrez comment créer un pipeline de déploiement continu robuste dans GitLab.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749659478/Blog/Hero%20Images/REFERENCE_-_Use_this_page_as_a_reference_for_thumbnail_sizes.png","https://about.gitlab.com/blog/from-code-to-production-a-guide-to-continuous-deployment-with-gitlab","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Du code à la production : guide du déploiement continu avec GitLab\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Benjamin Skierlak\"},{\"@type\":\"Person\",\"name\":\"James Wormwell\"}],\n        \"datePublished\": \"2025-01-28\",\n      }\n                  ",{"title":785,"description":786,"authors":791,"heroImage":787,"date":775,"body":794,"category":686,"tags":795,"updatedDate":796},[792,793],"Benjamin Skierlak","James Wormwell","Le déploiement continu est une pratique qui change la donne et qui permet aux équipes d'offrir de la valeur plus rapidement, avec une confiance accrue. Cependant, adopter des workflows de déploiement avancés, tels que [GitOps](https://about.gitlab.com/fr-fr/topics/gitops/ \"Qu'est-ce que GitOps ? \"), l'orchestration de conteneurs avec [Kubernetes](https://about.gitlab.com/fr-fr/blog/kubernetes-the-container-orchestration-solution/ \"Kubernetes, la solution d’orchestration des conteneurs\") ou les environnements dynamiques, peut être intimidant pour les équipes non expérimentées.\n\nChez GitLab, nous nous engageons à ce que la livraison de logiciels soit sans accroc et évolutive. En permettant aux équipes de se concentrer sur les fondamentaux, nous leur donnons les moyens d'établir une base solide qui soutient la croissance et de mettre en place des stratégies plus complexes au fil du temps. \n\nDans ce guide, découvrez les étapes clés pour mettre en œuvre le déploiement continu avec GitLab et poser les bases d'une réussite à long terme.\n\n## Commencez par planifier votre workflow\n\nAvant de passer à la mise en œuvre technique, prenez le temps de planifier votre workflow de déploiement. Une planification minutieuse et une approche méthodique sont les clés du succès.\n\n### Stratégie de gestion des artefacts\n\nDans le contexte du déploiement continu, les artefacts désignent les fichiers empaquetés suite au processus de compilation, destinés à être stockés, déployés et dont vous devez gérer les versions. \n\nEn voici quelques exemples :\n\n- images de conteneurs pour vos applications\n- paquets\n- exécutables ou fichiers binaires compilés\n- bibliothèques\n- fichiers de configuration\n- packages de documentation\n- autres artefacts\n\nChaque type d'artefact joue un rôle spécifique dans votre processus de déploiement. Par exemple, une application web typique peut générer les artefacts suivants :\n\n- une image de conteneur pour le service backend\n- une archive ZIP des ressources frontend compilées\n- des fichiers SQL pour les modifications de base de données\n- des fichiers de configuration propres à l'environnement\n\nLa gestion efficace de ces artefacts est cruciale pour la réussite des déploiements. Voici comment aborder la gestion des artefacts.\n\n#### Artefacts et stratégies de contrôle des versions\n\nUne bonne pratique permettant de démarrer avec une structure bien organisée consiste à établir une stratégie de gestion des versions claire pour vos artefacts. \n\nLors de la création de nouvelles versions :\n\n- Utilisez la gestion sémantique de version (major.minor.patch) pour les tags de version\n  - Exemple : `myapp:1.2.3` pour une version stable\n  - Modifications de la version majeure (2.0.0) pour les changements cassants\n  - Modifications de la version mineure (1.3.0) pour les nouvelles fonctionnalités\n  - Modifications de la version des correctifs (1.2.4) pour les corrections de bugs\n- Conservez un tag 'latest' pour la version stable la plus récente\n  - Exemple : `myapp:latest` pour les déploiements automatisés\n- Incluez un SHA de validation pour un suivi précis des versions\n  - Exemple : `myapp:1.2.3-abc123f` pour le débogage\n- Utilisez des tags basés sur les branches pour les environnements de développement\n  - Exemple : `myapp:feature-user-auth` pour les tests de fonctionnalités\n\n#### Rétention des artefacts de compilation\n\nMettez en œuvre des règles de durée de rétention définies :\n\n- Définissez des délais d'expiration explicites pour les artefacts temporaires\n- Définissez les artefacts nécessitant une durée de rétention permanente\n- Configurez des stratégies de nettoyage pour gérer le stockage\n\n#### Accès au registre et authentification\n\nSécurisez vos artefacts avec des contrôles d'accès appropriés :\n\n- Implémentez des jetons d'accès personnels (Personal Access Tokens) pour l'accès des développeurs\n- Configurez des variables CI/CD pour l'authentification du pipeline\n- Mettez en place des portées d'accès appropriées\n\n### Stratégie d’environnement de déploiement \n\nRéfléchissez dès le départ à la configuration de vos environnements, car ils façonnent l'ensemble de votre pipeline de déploiement :\n\n- Configurations de l'environnement de développement, de préproduction et de production\n- Variables et secrets propres à l'environnement\n- Contrôles d'accès et règles de protection\n- Approche de suivi et de surveillance du déploiement\n\n### Cibles de déploiement\n\nIl est important de réfléchir à la cible de déploiement et à l'approche choisie, tout en prenant en compte les avantages et les inconvénients de ces décisions :\n\n- Besoins en infrastructure (machines virtuelles, conteneurs, services cloud)\n- Configurations de la sécurité et de l'accès au réseau\n- Mécanismes d'authentification (clés SSH, jetons d'accès)\n- Éléments à prendre en compte pour l'allocation des ressources et la mise à l'échelle\n\nLorsque vous avez défini votre stratégie et pris les décisions fondamentales, vous pouvez transformer cette planification en un pipeline fonctionnel. Nous allons créer un exemple concret qui démontre ces concepts, en commençant par une application simple à laquelle nous ajouterons progressivement des fonctionnalités de déploiement.\n\n## Mettez en œuvre votre pipeline CD\n\n### Exemple pas à pas\n\nExaminons comment mettre en œuvre un pipeline de déploiement continu de base pour une application web. Nous utiliserons une application HTML simple à titre d'exemple, mais ces principes s'appliquent à tout type d'application. Nous allons également déployer notre application sous la forme d'une image Docker sur une simple machine virtuelle. Cela nous permettra de nous appuyer sur une image organisée avec un minimum de dépendances et de nous assurer qu'aucun prérequis propre à l'environnement n'est introduit involontairement. En travaillant sur une machine virtuelle, nous ne ferons pas appel aux intégrations natives de GitLab, ce qui nous permettra de travailler sur une configuration plus simple, quoique moins évolutive.\n\n#### Prérequis\n\nDans cet exemple, nous allons conteneuriser une application qui s'exécutera sur une machine virtuelle hébergée sur la plateforme d'un fournisseur de services cloud. Nous testerons également cette application localement sur notre machine. Cette liste de prérequis n'est nécessaire que pour notre scénario.\n\n##### Configuration de la machine virtuelle\n\n- Provisionnez une machine virtuelle sur la plateforme de votre fournisseur de services cloud préféré (par exemple, GCP, AWS, Azure).\n- Configurez les règles du réseau pour autoriser l'accès sur les ports 22, 80 et 443.\n- Enregistrez l'adresse IP publique de la machine pour le déploiement.\n\n##### Configuration de l'authentification SSH :\n\n- Générez une paire de clés publique/privée pour la machine.\n- Dans GitLab, accédez à **Paramètres > CI/CD > Variables**.\n- Créez une variable nommée `GITLAB_KEY`.\n- Définissez le type sur « Fichier » (requis pour l'authentification SSH).\n- Collez la clé privée dans le champ Valeur.\n- Définissez une variable USER (utilisateur qui se connecte et exécute les scripts sur votre machine virtuelle).\n\n##### Configuration des variables de déploiement\n\n- Créez des variables pour vos cibles de déploiement :\n  - `STAGING_TARGET` : l'adresse IP/le domaine de votre serveur de préproduction\n  - `PRODUCTION_TARGET` : l'adresse IP/le domaine de votre serveur de production\n\n##### Configuration du développement local\n\n- Installez Docker sur votre machine locale pour tester les déploiements.\n\n##### Accès au registre de conteneurs GitLab\n\n- Localisez votre chemin d'accès au registre :\n  - Accédez à **Déploiement > Registre de conteneurs**.\n- Copiez le chemin d'accès au registre (par exemple, registry.gitlab.com/group/project).\n- Configurez l'authentification :\n  - Accédez au menu **Paramètres > Jetons d'accès**.\n  - Créez un jeton avec un accès au registre.\n  - Expiration du jeton : maximum 1 an.\n  - Enregistrez le jeton de façon sécurisée.\n- Configurez l'accès au registre local :\n\n```\ndocker login registry.gitlab.com\n# The username if you are using a PAT is gitlab-ci-token\n# Password: your-access-token\n```\n\n#### 1. Création de votre application\n\nCommencez avec une application web de base. Dans notre exemple, nous utilisons une page HTML simple :\n\n```\n\u003C!|||UNTRANSLATED_CONTENT_START|||-- index.html -->\n\u003Chtml>\n  \u003Chead>\n    \u003Cstyle>\n      body {\n        background-color: #171321; /* GitLab dark */\n      }\n    \u003C/style>\n  \u003C/head>\n  \u003Cbody>\n    \u003C!|||UNTRANSLATED_CONTENT_END|||-- Your content here -->\n  \u003C/body>\n\u003C/html>\n```\n\n#### 2. Conteneurisation de votre application\n\nCréez un Dockerfile pour empaqueter votre application :\n\n```\nFROM nginx:1.26.2\nCOPY index.html /usr/share/nginx/html/index.html\n```\n\nCe Dockerfile :\n\n- Utilise nginx comme image de base pour diffuser du contenu web\n- Copie votre fichier HTML au bon endroit dans la structure du répertoire nginx\n\n#### 3. Configuration de votre pipeline CI/CD\n\nCréez un fichier `.gitlab-ci.yml` pour définir les étapes de votre [pipeline CI/CD](https://about.gitlab.com/fr-fr/topics/ci-cd/cicd-pipeline/ \"Qu'est-ce qu'un pipeline CI/CD ?\") :\n\n```\nvariables:\n  TAG_LATEST: $CI_REGISTRY_IMAGE/$CI_COMMIT_REF_NAME:latest\n  TAG_COMMIT: $CI_REGISTRY_IMAGE/$CI_COMMIT_REF_NAME:$CI_COMMIT_SHA\n\nstages:\n  - publish\n  - deploy\n```\n\nDécomposons ce code :\n\n`TAG_LATEST` est composé de trois parties :\n\n- `$CI_REGISTRY_IMAGE` est le chemin d'accès au registre des conteneurs de votre projet dans GitLab.\n\nPar exemple : `registry.gitlab.com/your-group/your-project`\n\n- `$CI_COMMIT_REF_NAME` est le nom de votre branche ou tag.\n\nPar exemple, si vous travaillez sur la branche principale : `/main`, et si vous travaillez sur une branche de fonctionnalité : `/feature-login`\n\n- `:latest` est un suffixe fixe.\n\nAinsi, si vous êtes sur la branche principale, `TAG_LATEST` devient `registry.gitlab.com/your-group/your-project/main:latest`.\n\n`TAG_COMMIT` est presque identique, mais au lieu de `:latest`, il utilise : `$CI_COMMIT_SHA`, qui est l'identifiant de commit, par exemple `:abc123def456`.\n\nAinsi, pour ce même commit sur la branche principale, `TAG_COMMIT` devient :` registry.gitlab.com/your-group/your-project/main:abc123def456`.\n\nLa présence de ces deux variables s'explique par le fait que `TAG_LATEST` vous permet facilement de toujours obtenir la version la plus récente. `TAG_COMMIT` vous fournit une version spécifique à laquelle vous pouvez revenir si nécessaire.\n\n#### 4. Publication dans le registre de conteneurs\n\nAjoutez le job de publication à votre pipeline :\n\n```\npublish:\n  stage: publish\n  image: docker:latest\n  services:\n    - docker:dind\n  script:\n    - docker build -t $TAG_LATEST -t $TAG_COMMIT .\n    - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY\n    - docker push $TAG_LATEST\n    - docker push $TAG_COMMIT\n```\n\nCe job :\n\n- Utilise Docker-in-Docker pour compiler des images\n- Crée deux versions avec tag de votre image\n- S'authentifie auprès du registre GitLab\n- Effectue un push des deux versions vers le registre \n\nMaintenant que vos images sont stockées de façon sécurisée dans le registre, vous pouvez vous concentrer sur leur déploiement dans vos environnements cibles. Commençons par des tests locaux pour valider notre configuration avant de passer aux déploiements dans l'environnement de production.\n\n#### 5. Déploiement dans votre environnement\n\nAvant le déploiement en production, vous pouvez effectuer un test localement. Nous venons de publier notre image dans le dépôt GitLab, pour lequel nous allons effectuer un pull localement. Si vous ne connaissez pas le chemin d'accès exact, accédez à **Déploiement > Registre de conteneurs**. Vous devriez voir une icône permettant de copier le chemin d'accès de votre image à la fin de la ligne pour l'image de conteneur que vous souhaitez tester.\n\n```\ndocker login registry.gitlab.com \ndocker run -p 80:80 registry.gitlab.com/your-project-path/main:latest\n```\n\nCe faisant, vous devriez être en mesure d'accéder à votre application localement sur votre adresse localhost via votre navigateur web.\n\nVous pouvez maintenant ajouter un job de déploiement à votre pipeline :\n\n```\ndeploy:\n  stage: deploy\n  image: alpine:latest\n  script:\n    - chmod 400 $GITLAB_KEY\n    - apk add openssh-client\n    - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY\n    - ssh -i $GITLAB_KEY -o StrictHostKeyChecking=no $USER@$TARGET_SERVER \n      docker pull $TAG_COMMIT &&\n      docker rm -f myapp || true &&\n      docker run -d -p 80:80 --name myapp $TAG_COMMIT\n```\n\nCe job :\n\n- Configure l'accès SSH à votre cible de déploiement\n- Effectue un pull de l'image la plus récente\n- Supprime tout conteneur existant\n- Déploie la nouvelle version\n\n#### 6. Suivi des déploiements\n\nActivez le suivi des déploiements en ajoutant la configuration de l'environnement :\n\n```\ndeploy:\n  environment:\n    name: production\n    url: https://your-application-url.com \n```\n\nCela crée un objet environnement dans la section **Exploitation > Environnements** de GitLab et fournit :\n\n- L'historique de déploiement\n- Le statut de déploiement actuel\n- Un accès rapide à votre application\n\nBien qu'un pipeline d'environnement unique soit un bon point de départ, la plupart des équipes doivent gérer plusieurs environnements, dont des environnements de test et de préproduction. Étoffons notre pipeline pour gérer ce scénario plus réaliste.\n\n#### 7. Configuration de plusieurs environnements\n\nPour obtenir un pipeline plus robuste, configurez les déploiements de préproduction et de production :\n\n```\nstages:\n  - publish\n  - staging\n  - release\n  - version\n  - production\n\nstaging:\n  stage: staging\n  rules:\n    - if: $CI_COMMIT_BRANCH == \"main\" && $CI_COMMIT_TAG == null\n  environment:\n    name: staging\n    url: https://staging.your-app.com\n  # deployment script here\n\nproduction:\n  stage: production\n  rules:\n    - if: $CI_COMMIT_TAG\n  environment:\n    name: production\n    url: https://your-app.com\n  # deployment script here\n```\n\nCette configuration :\n\n- Effectue un déploiement vers l'environnement de préproduction à partir de votre branche principale\n- Utilise les tags GitLab pour déclencher les déploiements de production\n- Fournit un suivi distinct pour chaque environnement\n\nQue ce soit à cette étape ou à l'étape suivante, nous tirons parti des tags, qui sont une fonctionnalité très utile de GitLab. En créant manuellement un tag dans la section **Code > Tags**, `$CI_COMMIT_TAG` est créé, ce qui nous permet de déclencher des jobs en conséquence.\n\n#### 8. Création de notes de version automatisées\n\nNous utiliserons les fonctionnalités de gestion des versions de GitLab depuis notre pipeline CI/CD. Commencez par mettre à jour les étapes de votre pipeline CI/CD dans `.gitlab-ci.yml` :\n\n```\nstages:\n\n- publish\n- staging\n- release # New stage for releases\n- version\n- production\n```\n\nEnsuite, ajoutez le job de release :\n\n```\nrelease_job:\n  stage: release\n  image: registry.gitlab.com/gitlab-org/release-cli:latest\n  rules:\n    - if: $CI_COMMIT_TAG                  # Only run when a tag is created\n  script:\n    - echo \"Creating release for $CI_COMMIT_TAG\"\n  release:                                # Release configuration\n    name: 'Release $CI_COMMIT_TAG'\n    description: 'Release created from $CI_COMMIT_TAG'\n    tag_name: '$CI_COMMIT_TAG'           # The tag to create\n    ref: '$CI_COMMIT_TAG'                # The tag to base release on\n```\n\nVous pouvez l'améliorer en ajoutant des liens vers vos images de conteneurs :\n\n```\nrelease:\n  name: 'Release $CI_COMMIT_TAG'\n  description: 'Release created from $CI_COMMIT_TAG'\n  tag_name: '$CI_COMMIT_TAG'\n  ref: '$CI_COMMIT_TAG'\n  assets:\n    links:\n      - name: 'Container Image'\n        url: '$CI_REGISTRY_IMAGE/main:$CI_COMMIT_TAG'\n        link_type: 'image'\n```\n\nPour générer des notes de version automatisées pertinentes :\n\n- Utilisez des commits conventionnels (feat:, fix:, et autres commandes.).\n- Incluez les numéros de ticket (#123).\n- Séparez le sujet du corps par un saut de ligne.\n\nSi vous souhaitez des notes de version personnalisées avec des informations de déploiement :\n\n```\nrelease_job:\n  script:\n    - |\n      DEPLOY_TIME=$(date '+%Y-%m-%d %H:%M:%S')\n      CHANGES=$(git log $(git describe --tags --abbrev=0 @^)..@ --pretty=format:\"- %s\")\n      cat > release_notes.md \u003C\u003C EOF\n      ## Deployment Info\n      - Deployed on: $DEPLOY_TIME\n      - Environment: Production\n      - Version: $CI_COMMIT_TAG\n\n      ## Changes\n      $CHANGES\n\n      ## Artifacts\n      - Container Image: \\`$CI_REGISTRY_IMAGE/main:$CI_COMMIT_TAG\\`\n      EOF\n  release:\n    description: './release_notes.md'\n```\n\nUne fois configurées, les versions sont créées automatiquement lorsque vous ajoutez un tag [Git](https://about.gitlab.com/fr-fr/blog/what-is-git/ \"Qu'est-ce que Git ? \"). Vous pouvez les afficher dans GitLab sous **Déploiement > Releases**.\n\n#### 9. Assemblage\n\nVoici à quoi ressemble notre fichier YAML final :\n\n```\nvariables:\n  TAG_LATEST: $CI_REGISTRY_IMAGE/$CI_COMMIT_REF_NAME:latest\n  TAG_COMMIT: $CI_REGISTRY_IMAGE/$CI_COMMIT_REF_NAME:$CI_COMMIT_SHA\n  STAGING_TARGET: $STAGING_TARGET    # Set in CI/CD Variables\n  PRODUCTION_TARGET: $PRODUCTION_TARGET  # Set in CI/CD Variables\n\nstages:\n  - publish\n  - staging\n  - release\n  - version\n  - production\n\n# Build and publish to registry\npublish:\n  stage: publish\n  image: docker:latest\n  services:\n    - docker:dind\n  rules:\n    - if: $CI_COMMIT_BRANCH == \"main\" && $CI_COMMIT_TAG == null\n  script:\n    - docker build -t $TAG_LATEST -t $TAG_COMMIT .\n    - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY\n    - docker push $TAG_LATEST\n    - docker push $TAG_COMMIT\n\n# Deploy to staging\nstaging:\n  stage: staging\n  image: alpine:latest\n  rules:\n    - if: $CI_COMMIT_BRANCH == \"main\" && $CI_COMMIT_TAG == null\n  script:\n    - chmod 400 $GITLAB_KEY\n    - apk add openssh-client\n    - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY\n    - ssh -i $GITLAB_KEY -o StrictHostKeyChecking=no $USER@$STAGING_TARGET \"\n        docker pull $TAG_COMMIT &&\n        docker rm -f myapp || true &&\n        docker run -d -p 80:80 --name myapp $TAG_COMMIT\"\n  environment:\n    name: staging\n    url: http://$STAGING_TARGET\n\n# Create release\nrelease_job:\n  stage: release\n  image: registry.gitlab.com/gitlab-org/release-cli:latest\n  rules:\n    - if: $CI_COMMIT_TAG\n  script:\n    - |\n      DEPLOY_TIME=$(date '+%Y-%m-%d %H:%M:%S')\n      CHANGES=$(git log $(git describe --tags --abbrev=0 @^)..@ --pretty=format:\"- %s\")\n      cat > release_notes.md \u003C\u003C EOF\n      ## Deployment Info\n      - Deployed on: $DEPLOY_TIME\n      - Environment: Production\n      - Version: $CI_COMMIT_TAG\n\n      ## Changes\n      $CHANGES\n\n      ## Artifacts\n      - Container Image: \\`$CI_REGISTRY_IMAGE/main:$CI_COMMIT_TAG\\`\n      EOF\n  release:\n    name: 'Release $CI_COMMIT_TAG'\n    description: './release_notes.md'\n    tag_name: '$CI_COMMIT_TAG'\n    ref: '$CI_COMMIT_TAG'\n    assets:\n      links:\n        - name: 'Container Image'\n          url: '$CI_REGISTRY_IMAGE/main:$CI_COMMIT_TAG'\n          link_type: 'image'\n\n# Version the image with release tag\nversion_job:\n  stage: version\n  image: docker:latest\n  services:\n    - docker:dind\n  rules:\n    - if: $CI_COMMIT_TAG\n  script:\n    - docker pull $TAG_COMMIT\n    - docker tag $TAG_COMMIT $CI_REGISTRY_IMAGE/main:$CI_COMMIT_TAG\n    - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY\n    - docker push $CI_REGISTRY_IMAGE/main:$CI_COMMIT_TAG\n\n# Deploy to production\nproduction:\n  stage: production\n  image: alpine:latest\n  rules:\n    - if: $CI_COMMIT_TAG\n  script:\n    - chmod 400 $GITLAB_KEY\n    - apk add openssh-client\n    - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY\n    - ssh -i $GITLAB_KEY -o StrictHostKeyChecking=no $USER@$PRODUCTION_TARGET \"\n        docker pull $CI_REGISTRY_IMAGE/main:$CI_COMMIT_TAG &&\n        docker rm -f myapp || true &&\n        docker run -d -p 80:80 --name myapp $CI_REGISTRY_IMAGE/main:$CI_COMMIT_TAG\"\n  environment:\n    name: production\n    url: http://$PRODUCTION_TARGET\n```\n\nCe pipeline complet :\n\n- Publie des images dans le registre (branche principale)\n- Déploie vers l'environnement de préproduction (branche principale)\n- Crée des versions (lorsqu'un tag est ajouté)\n- Crée des versions d'images avec des tags de version \n- Déploie dans l'environnement de production (lorsqu'un tag est créé)\n\nPrincipaux avantages :\n\n- Environnement de développement et de test local propre et reproductible\n- Chemin d'accès clair vers les environnements de production avec une structure qui renforce la confiance dans ce qui est déployé\n- Modèle pour se remettre de défaillances inattendues, entre autres\n- Possibilité de développement sur cette base et d'adoption de stratégies de déploiement plus complexes\n\n### Bonnes pratiques\n\nTout au long de la mise en œuvre, respectez les principes suivants :\n\n- Documentez tout, de l'utilisation des variables aux procédures de déploiement.\n- Utilisez les fonctionnalités intégrées de GitLab (environnements, releases, registre).\n- Mettez en œuvre des contrôles d'accès et des mesures de sécurité adaptés.\n- Pensez aux éventuelles défaillances en mettant en place des procédures de restauration robustes.\n- Évitez les redondances dans vos configurations de pipeline en suivant le principe DRY (Don't Repeat Yourself).\n\n## Mise à l'échelle de votre stratégie de déploiement\n\nPour terminer, voici quelques aspects à prendre en compte à mesure que votre stratégie de déploiement continu évolue.\n\n### Mesures de sécurité avancées\n\nAméliorez la sécurité grâce aux fonctionnalités suivantes :\n\n- Environnements protégés avec accès restreint\n- Approbations requises pour les déploiements en production\n- Scanning de sécurité intégré\n- Évaluations automatisées des vulnérabilités\n- Règles de protection des branches pour les modifications liées au déploiement\n\n### Stratégies de livraison progressive\n\nMettez en œuvre des stratégies de déploiement avancées :\n\n- Feature flags pour les déploiements contrôlés\n- Déploiements canari pour l'atténuation des risques\n- Stratégies de déploiement bleu-vert\n- Capacités de test A/B\n- Gestion dynamique de l'environnement\n\n### Surveillance et optimisation\n\nMettez en place des pratiques de surveillance robustes :\n\n- Suivi des mesures de déploiement\n- Mise en place d'un suivi des performances\n- Configuration d'alertes de déploiement\n- Établissement d'objectifs de niveau de service (SLO) en matière de déploiement\n- Optimisation régulière du pipeline\n\n## Pourquoi utiliser GitLab ?\n\nLa plateforme GitLab est idéale pour les workflows de déploiement modernes grâce à ses fonctionnalités de déploiement continu. Elle permet de simplifier les étapes menant du code à la production, en offrant un registre de conteneurs intégré, une gestion de l'environnement et le suivi des déploiements au sein d'une seule interface. Les variables propres à l'environnement, les portes d'approbation de déploiement et les fonctionnalités de restauration de GitLab fournissent la sécurité et le contrôle nécessaires aux déploiements en production, tandis que les fonctionnalités telles que les versions temporaires d'applications et les feature flags offrent des approches de livraison progressive. Ces fonctionnalités de déploiement continu font partie intégrante de la plateforme [DevSecOps](https://about.gitlab.com/fr-fr/topics/devsecops/ \"Qu'est-ce que DevSecOps ?\") complète de GitLab et s'intègrent parfaitement à l'ensemble du cycle de vie de vos logiciels.\n\n## Lancez-vous dès aujourd'hui\n\nOpter pour un déploiement continu est une évolution, pas une révolution. Commencez par les fondamentaux, établissez une base solide et intégrez progressivement des fonctionnalités avancées lorsque les besoins de votre équipe augmentent. GitLab fournit les outils et la flexibilité nécessaires pour vous accompagner à chaque étape de ce parcours, de votre premier déploiement automatisé aux pipelines de livraison complexes et multi-environnements.\n\n> [Essayez GitLab Ultimate gratuitement](https://about.gitlab.com/fr-fr/free-trial/devsecops/) et commencez votre déploiement continu dès aujourd'hui.",[772,9,750,686,684],"2025-03-24",{"slug":798,"featured":6,"template":691},"from-code-to-production-a-guide-to-continuous-deployment-with-gitlab","content:fr-fr:blog:from-code-to-production-a-guide-to-continuous-deployment-with-gitlab.yml","From Code To Production A Guide To Continuous Deployment With Gitlab","fr-fr/blog/from-code-to-production-a-guide-to-continuous-deployment-with-gitlab.yml","fr-fr/blog/from-code-to-production-a-guide-to-continuous-deployment-with-gitlab",{"_path":804,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":805,"content":811,"config":818,"_id":820,"_type":14,"title":821,"_source":16,"_file":822,"_stem":823,"_extension":19},"/fr-fr/blog/getting-started-with-gitlab-understanding-ci-cd",{"title":806,"description":807,"ogTitle":806,"ogDescription":807,"noIndex":6,"ogImage":808,"ogUrl":809,"ogSiteName":673,"ogType":674,"canonicalUrls":809,"schema":810},"Premiers pas avec GitLab : comprendre l'approche CI/CD ","Découvrez tout ce que vous devez savoir sur l’approche CI/CD grâce à ce guide dédié aux débutants.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749659525/Blog/Hero%20Images/blog-getting-started-with-gitlab-banner-0497-option4-fy25.png","https://about.gitlab.com/blog/getting-started-with-gitlab-understanding-ci-cd","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Premiers pas avec GitLab : comprendre l'approche CI/CD \",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"GitLab\"}],\n        \"datePublished\": \"2025-04-25\",\n      }\n                  ",{"title":806,"description":807,"authors":812,"heroImage":808,"date":814,"body":815,"category":686,"tags":816,"updatedDate":817},[813],"GitLab","2025-04-25","Imaginez un cycle de développement logiciel dans lequel chaque modification de code est automatiquement compilée, testée, puis déployée auprès de vos utilisateurs. C'est tout l'intérêt de l'[approche CI/CD](https://about.gitlab.com/fr-fr/topics/ci-cd/ \"Qu'est-ce que le CI/CD ? \") (intégration continue/livraison continue) qui vous aide à détecter les bogues à un stade précoce, garantit la qualité du code et vous permet de livrer des logiciels plus rapidement et plus fréquemment.\n\n## Qu'est-ce que l'approche CI/CD ?\n\n* **L'[intégration continue](https://about.gitlab.com/fr-fr/topics/ci-cd/benefits-continuous-integration/ \"Qu'est-ce que l'intégration continue ? \")** est une pratique de développement qui consiste à fusionner régulièrement les modifications apportées au code dans un dépôt partagé, de préférence plusieurs fois par jour, afin qu'elles soient vérifiées via un processus automatisé de compilation et de tests. Les équipes de développement peuvent ainsi détecter rapidement les problèmes et conflits éventuels.  \n* **La [livraison continue](https://about.gitlab.com/fr-fr/topics/continuous-delivery/ \"Qu'est-ce que la livraison continue ? \")** complète l'intégration continue en automatisant le pipeline pour la sortie de nouvelles versions. *À tout moment*, l'application reste déployable vers un environnement donné (par exemple, préproduction, production), en un seul clic ou par le biais d'un déclenchement automatique.  \n* **Le déploiement continu** pousse encore plus loin la logique d’automatisation. *Chaque compilation réussie* est directement mise en production, sans validation manuelle. Ce niveau d'automatisation requiert une confiance totale dans vos tests automatisés et vos processus de déploiement.\n\n## Pourquoi choisir GitLab CI/CD ?\n\nEntièrement intégré à la plateforme GitLab, GitLab CI/CD est un système puissant, qui permet d'automatiser facilement chaque étape de votre cycle de développement logiciel. Avec GitLab CI/CD, vous pouvez notamment :\n\n* **Automatiser l'intégralité de votre cycle de développement :** compilation, tests, déploiement, tout peut être orchestré via le [pipeline CI/CD](https://about.gitlab.com/fr-fr/topics/ci-cd/cicd-pipeline/ \"Qu'est-ce qu'un pipeline CI/CD ? \").  \n* **Détecter les bogues en amont :** les problèmes sont identifiés et corrigés bien avant d’atteindre l'environnement de production. \n* **Obtenir des retours immédiats :** les équipes de développement obtiennent un retour rapide sur leurs modifications de code.  \n* **Renforcer la collaboration :** les workflows automatisés fluidifient le travail en équipe.  \n* **Accélérer la livraison :** les livraisons de nouvelles versions sont plus rapides et plus fréquentes.  \n* **Réduire les risques :** les erreurs de déploiement et les retours en arrière sont considérablement réduits.\n\n## Quels sont les principaux composants de GitLab CI/CD ?\n\n- **`.gitlab-ci.yml` :** ce [fichier YAML](https://docs.gitlab.com/ee/ci/yaml/), situé dans le répertoire racine de votre projet, définit l'ensemble du pipeline CI/CD, y compris les étapes, les jobs et les runners.  \n- **[GitLab Runner](https://docs.gitlab.com/runner/):** cet agent exécute les jobs CI/CD sur l'infrastructure de votre choix (par exemple, machines physiques, machines virtuelles, conteneurs Docker ou clusters [Kubernetes](https://about.gitlab.com/fr-fr/blog/kubernetes-the-container-orchestration-solution/ \"Qu'est-ce que Kubernetes ? \")).  \n- **[Étapes](https://docs.gitlab.com/ee/ci/yaml/#stages):** elles définissent l'ordre d'exécution des jobs (par exemple, compilation, tests et déploiement).  \n- **[Jobs](https://docs.gitlab.com/ee/ci/yaml/#job-keywords):** chaque job représente une unité de travail spécifique exécutée lors de l'étape correspondante (par exemple, compiler du code, exécuter des tests ou déployer dans l'environnement de préproduction).\n\n## Comment configurer GitLab CI ?\n\nGitLab CI est très facile à prendre en main. Voici un exemple basique de fichier `.gitlab-ci.yml` :\n\n```yaml\n\nstages:\n  - build\n  - test\n  - deploy\n\nbuild_job:\n  stage: build\n  script:\n    - echo \"Building the application...\"\n\ntest_job:\n  stage: test\n  script:\n    - echo \"Running tests...\"\n\ndeploy_job:\n  stage: deploy\n  script:\n    - echo \"Deploying to production...\"\n  environment:\n    name: production\n\n```\n\nCette configuration définit trois étapes : « compilation », « test » et « déploiement ». Chaque étape contient un job qui exécute un script simple.\n\n### Exemples de configuration CI/CD\n\nExplorons quelques exemples plus concrets.\n\n**Création, compilation et déploiement d'une application Node.js**\n\nPrenons l'exemple du pipeline ci-dessous qui compile et teste une application Node.js à l'aide de npm, puis la déploie sur Heroku via [dpl](https://docs.gitlab.com/ci/examples/deployment/). L'étape de déploiement du pipeline utilise des [variables GitLab CI/CD](https://docs.gitlab.com/ci/variables/), qui permettent de stocker des informations sensibles (par exemple, des identifiants de connexion) et de les utiliser en toute sécurité dans les processus CI/CD. \n\nDans cet exemple, une clé API pour déployer l'application sur Heroku est stockée sous le nom de variable `$HEROKU_API_KEY`, cette clé étant utilisée par l'outil dpl.\n\n```yaml\n\nstages:\n  - build\n  - test\n  - deploy\n\nbuild:\n  stage: build\n  image: node:latest\n  script:\n    - npm install\n    - npm run build\n\ntest:\n  stage: test\n  image: node:latest\n  script:\n    - npm run test\n\ndeploy:\n  stage: deploy\n  image: ruby:latest\n  script:\n    - gem install dpl\n    - dpl --provider=heroku --app=$HEROKU_APP_NAME --api-key=$HEROKU_API_KEY\n\n```\n\n**Déploiement vers différents environnements (préproduction et production)**\n\nGitLab propose également la gestion des [environnements](https://docs.gitlab.com/ci/environments/) au sein du pipeline CI/CD pour suivre les déploiements vers des cibles d'infrastructure. Dans l'exemple ci-dessous, le pipeline ajoute des étapes avec une propriété « environnement » pour les environnements de préproduction et de production. Alors que l'étape deploy_staging exécute son script automatiquement, l'étape deploy_production nécessite une approbation manuelle afin d'éviter tout déploiement accidentel en production.  \n\n```yaml\n\nstages:\n  - build\n  - test\n  - deploy_staging\n  - deploy_production\n\nbuild:\n  # ...\n\ntest:\n  # ...\n\ndeploy_staging:\n  stage: deploy_staging\n  script:\n    - echo \"Deploying to staging...\"\n  environment:\n    name: staging\n\ndeploy_production:\n  stage: deploy_production\n  script:\n    - echo \"Deploying to production...\"\n  environment:\n    name: production\n  when: manual  # Requires manual approval\n\n```\n\n### GitLab Auto DevOps\n\n[GitLab Auto DevOps](https://docs.gitlab.com/ee/topics/autodevops/) simplifie encore plus l'approche CI/CD en fournissant une configuration prédéfinie pour compiler, tester et déployer automatiquement vos applications. Cette suite de fonctionnalités tire parti des bonnes pratiques et des normes du secteur pour rationaliser votre workflow.\n\nPour activer Auto DevOps :\n\n1. Accédez à **Paramètres > CI/CD > Pipelines généraux**.  \n2. Activez l'option **Auto DevOps**.\n\nAuto DevOps détecte automatiquement le langage et le framework de votre projet et configure les étapes de compilation, de tests et de déploiement nécessaires. Il est donc inutile de créer un fichier `.gitlab-ci.yml`.\n\n### Catalogue CI/CD\n\nLe catalogue CI/CD est une liste de projets contenant des [composants CI/CD](https://docs.gitlab.com/ee/ci/components/) publiés par la communauté, que vous pouvez utiliser pour optimiser votre workflow CI/CD. Vous pouvez y contribuer en ajoutant vos propres composants ou en enrichissant ceux déjà existants. Les composants publiés dans le [catalogue CI/CD](https://gitlab.com/explore/catalog) sont disponibles sur GitLab.com.\n\n> [Tutoriel : Comment configurer votre premier composant GitLab CI/CD](https://about.gitlab.com/blog/tutorial-how-to-set-up-your-first-gitlab-ci-cd-component/)\n\n### Templates CI\n\nVous pouvez également créer vos propres [templates CI](https://docs.gitlab.com/ee/ci/examples/) afin de standardiser et de réutiliser les configurations de vos pipelines CI/CD entre plusieurs projets. Cette pratique favorise la cohérence et réduit les doublons.\n\nPour créer un template CI :\n\n1. Créez un fichier `.gitlab-ci.yml` dans un projet ou un dépôt dédié.  \n2. Définissez la configuration CI/CD souhaitée dans ce template.  \n3. Dans le fichier `.gitlab-ci.yml`, utilisez le terme `include` pour inclure ce template.\n\n## Optimisez votre processus de développement\n\nGitLab CI/CD transforme en profondeur votre workflow de développement de logiciels. En maîtrisant ses concepts, en configurant efficacement vos pipelines CI/CD et en tirant parti de fonctionnalités tels qu'Auto DevOps, le catalogue CI/CD et les templates CI, vous pouvez automatiser l'ensemble de votre cycle de développement logiciel et livrer des logiciels de haute qualité plus rapidement et plus efficacement.\n\nVous souhaitez approfondir vos connaissances ? Inscrivez-vous aux [cours disponibles sur le portail GitLab University](https://university.gitlab.com/). \n\n> [Essayez GitLab Ultimate gratuitement](https://about.gitlab.com/fr-fr/free-trial/).\n\n## Articles de la série « Premiers pas avec GitLab »\n\nDécouvrez les autres articles de notre série « Premiers pas avec GitLab » :\n\n- [Comment gérer les utilisateurs](https://about.gitlab.com/fr-fr/blog/getting-started-with-gitlab-how-to-manage-users/)\n- [Comment importer vos projets dans GitLab](https://about.gitlab.com/fr-fr/blog/getting-started-with-gitlab-how-to-import-your-projects-to-gitlab/)  \n- [Comment maîtriser la gestion de projet](https://about.gitlab.com/fr-fr/blog/getting-started-with-gitlab-mastering-project-management/)\n- [La gemme gitlab-triage : votre alliée pour des workflows Agile automatisés](https://about.gitlab.com/fr-fr/blog/automating-agile-workflows-with-the-gitlab-triage-gem/)\n",[9,774,772,685,686,684],"2025-05-26",{"slug":819,"featured":91,"template":691},"getting-started-with-gitlab-understanding-ci-cd","content:fr-fr:blog:getting-started-with-gitlab-understanding-ci-cd.yml","Getting Started With Gitlab Understanding Ci Cd","fr-fr/blog/getting-started-with-gitlab-understanding-ci-cd.yml","fr-fr/blog/getting-started-with-gitlab-understanding-ci-cd",{"_path":825,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":826,"content":831,"config":837,"_id":839,"_type":14,"title":840,"_source":16,"_file":841,"_stem":842,"_extension":19},"/fr-fr/blog/getting-started-with-gitlab-working-with-ci-cd-variables",{"ogTitle":827,"schema":828,"ogImage":808,"ogDescription":829,"ogSiteName":673,"noIndex":6,"ogType":674,"ogUrl":830,"title":827,"canonicalUrls":830,"description":829},"Premiers pas avec GitLab : comment tirer parti des variables CI/CD","{\n  \"@context\": \"https://schema.org\",\n  \"@type\": \"Article\",\n  \"headline\": \"Premiers pas avec GitLab : comment tirer parti des variables CI/CD\",\n  \"author\": [{\"@type\": \"Person\", \"name\": \"GitLab Team\"}],\n  \"datePublished\": \"2025-05-27\"\n}\n","Découvrez les variables CI/CD, leur rôle clé dans l'approche DevSecOps ainsi que les bonnes pratiques relatives à leur utilisation.","https://about.gitlab.com/blog/getting-started-with-gitlab-working-with-ci-cd-variables",{"heroImage":808,"body":832,"authors":833,"date":710,"title":827,"tags":835,"description":829,"category":686,"updatedDate":836},"*Bienvenue dans notre série « Premiers pas avec GitLab », conçue pour guider les nouveaux utilisateurs dans la prise en main de la plateforme DevSecOps de GitLab.* \n\nAprès avoir exploré les bases de [l'approche CI/CD de GitLab](https://about.gitlab.com/fr-fr/blog/getting-started-with-gitlab-understanding-ci-cd/) dans notre précédent article, concentrons-nous à présent sur les **variables CI/CD** afin de tirer pleinement parti de leur potentiel.\n\n## Qu’est-ce qu’une variable CI/CD ?\n\nLes variables CI/CD sont des paires clé-valeur dynamiques que vous pouvez définir à différents niveaux (projet, groupe ou instance par exemple) au sein de votre environnement GitLab. Elles permettent de personnaliser les [pipelines CI/CD](https://about.gitlab.com/fr-fr/topics/ci-cd/cicd-pipeline/ \"Qu'est-ce qu'un pipeline CI/CD ?\"), de centraliser les configurations et de gérer en toute sécurité des données sensibles. Intégrées directement dans le fichier `.gitlab-ci.yml` comme des espaces réservés pour les valeurs correspondantes, elles facilitent la maintenance, renforcent la sécurité et améliorent la flexibilité des workflows CI/CD.\n\n## Quel est le rôle des variables CI/CD ?\n\nLes variables CI/CD offrent de nombreux avantages :\n\n* **Flexibilité** : adaptez facilement vos pipelines à différents environnements, configurations ou cibles de déploiement sans modifier votre script CI/CD principal.  \n* **Sécurité** : stockez en toute sécurité des informations sensibles telles que des clés API, des mots de passe et des tokens sans les exposer dans votre code.  \n* **Maintenabilité** : en centralisant les valeurs, elles simplifient la gestion et les mises à jour de votre configuration CI/CD pour qu'elle reste structurée correctement.  \n* **Réutilisation** : définies une seule fois, elles peuvent être réutilisées dans plusieurs projets, ce qui favorise la cohérence et réduit les doublons.\n\n## Portées des variables CI/CD : projet, groupe et instance\n\nGitLab permet de définir des variables CI/CD à différentes niveaux hiérarchiques du projet, avec un contrôle précis sur leur visibilité, leur portée et leur accessibilité :\n\n* **Variables au niveau du projet** : elles sont propres à un seul projet et idéales pour stocker des paramètres spécifiques, notamment :\n\n  * L'URL de déploiement : définissez des URL distinctes pour les environnements de préproduction et de production.  \n  * Les identifiants de connexion à la base de données : stockez les données de connexion à la base de données afin de pouvoir les utiliser lors d'un test ou d'un déploiement.  \n  * Les feature flags : activez ou désactivez les fonctionnalités à différentes étapes de votre pipeline.  \n  * Exemple : dans le cadre de votre projet `MyWebApp`, vous souhaitez stocker l'URL de déploiement de production. Vous pouvez définir une variable au niveau du projet, nommée `DPROD_DEPLOY_URL`, avec la valeur `https://mywebapp.com` d'URL de production.  \n* **Variables au niveau du groupe** : elles sont partagées par tous les projets d'un groupe GitLab. Elles sont utiles pour centraliser des paramètres communs à plusieurs projets, notamment :\n\n  * Les clés API de services partagés : stockez-les pour des services tels qu'AWS, Google Cloud ou Docker Hub qui sont utilisés par plusieurs projets au sein du groupe.  \n  * Les paramètres de configuration généraux : définissez des paramètres de configuration communs qui s'appliquent à tous les projets du groupe.  \n  * Exemple : dans votre groupe `Web Apps`, vous souhaitez stocker une clé API pour Docker Hub. Vous pouvez définir une variable au niveau du groupe, nommée `DOCKER_HUB_API_KEY`, avec la valeur de clé API correspondante.  \n* **Variables au niveau de l'instance** : elles sont disponibles pour tous les projets d'une instance GitLab et couramment utilisées pour les paramètres généraux qui s'appliquent à l'ensemble de l'entreprise, notamment :\n\n  * Le token d'enregistrement de runner par défaut : fournissez un token par défaut pour l'enregistrement de nouveaux [runners](https://docs.gitlab.com/runner/).  \n  * Les informations sur la licence : stockez les clés de licence des fonctionnalités GitLab ou des outils tiers.  \n  * Les paramètres d'environnement généraux : définissez des variables d'environnement qui doivent être disponibles pour tous les projets.  \n  * Exemple : vous souhaitez définir une image Docker par défaut pour tous les projets de votre instance GitLab. Vous pouvez définir une variable au niveau de l'instance, nommée `DEFAULT_DOCKER_IMAGE`, avec la valeur `ubuntu:latest`.\n\n## Comment définir des variables CI/CD ?\n\nPour définir une variable CI/CD, voici comment procéder :\n\n1. Cliquez sur les boutons **Paramètres > CI/CD** de votre projet, groupe ou instance.  \n2. Accédez à la section **Variables**.  \n3. Cliquez sur **Ajouter une variable**.  \n4. Saisissez la **clé** (par exemple, `API_KEY`) et la **valeur** correspondante.  \n5. Facultatif : cochez l'option **Protéger la variable** si elle contient des données sensibles afin de restreindre son utilisation aux pipelines qui s'exécutent sur des branches ou des tags protégés.  \n6. Facultatif : cochez la case **Masquer la variable** pour masquer sa valeur dans les job logs, afin d'éviter toute exposition accidentelle.  \n7. Cliquez sur **Enregistrer la variable**.\n\n## Comment utiliser des variables CI/CD ?\n\nPour utiliser une variable CI/CD dans votre fichier `.gitlab-ci.yml`, faites simplement précéder le nom de la variable du symbole `$` :\n\n```yaml\ndeploy_job:\n  script:\n    - echo \"Deploying to production...\"\n    - curl -H \"Authorization: Bearer $API_KEY\" https://api.example.com/deploy\n```\n\n## Comment utiliser les variables CI/CD prédéfinies dans GitLab ?\n\nGitLab met à disposition un ensemble de [variables CI/CD prédéfinies](https://docs.gitlab.com/ci/variables/predefined_variables/) que vous pouvez utiliser dans vos pipelines CI/CD. Celles-ci fournissent des informations contextuelles sur le pipeline, le job, le projet en cours, et bien plus encore.\n\nVoici les variables plus couramment utilisées :\n\n* `$CI_COMMIT_SHA` : SHA de validation qui déclenche le pipeline  \n* `$CI_PROJECT_DIR` : répertoire dans lequel le projet est cloné  \n* `$CI_PIPELINE_ID` : ID du pipeline en cours\n* `$CI_ENVIRONMENT_NAME` : nom de l'environnement de déploiement cible (le cas échéant)\n\n## Bonnes pratiques pour l'utilisation des variables CI/CD\n\n* Gérez en toute sécurité les variables sensibles : utilisez des variables protégées et masquées pour stocker les clés API, les mots de passe et tout autre secret.  \n* Évitez de coder en dur les valeurs : stockez les valeurs de configuration dans des variables afin de renforcer la flexibilité et la maintenance de vos pipelines.\n* Organisez vos variables : utilisez des noms explicites et regroupez les variables par usage pour faciliter leur gestion.  \n* Choisissez la portée appropriée : définissez vos variables au niveau du projet, groupe ou instance en fonction de leur utilisation prévue et de leur visibilité.\n\n## Tirez parti de la puissance des variables CI/CD\n\nLes variables CI/CD sont un outil puissant pour personnaliser et sécuriser vos pipelines GitLab. En maîtrisant leur fonctionnement et en comprenant leurs différentes portées, vous pouvez créer des workflows plus flexibles, plus faciles à maintenir et plus efficaces.\n\n> Prêt à passer à l’action ? Commencez à utiliser les variables CI/CD dès aujourd'hui et profitez d'un [essai gratuit de GitLab Ultimate avec Duo Enterprise](https://about.gitlab.com/fr-fr/free-trial/).\n\n## Articles de la série « Premiers pas avec GitLab »\n\nDécouvrez les autres articles de notre série « Premiers pas avec GitLab » :\n\n* [Comment gérer les utilisateurs](https://about.gitlab.com/fr-fr/blog/getting-started-with-gitlab-how-to-manage-users/)\n* [Comment importer vos projets dans GitLab](https://about.gitlab.com/fr-fr/blog/getting-started-with-gitlab-how-to-import-your-projects-to-gitlab/)  \n* [Comment maîtriser la gestion de projet](https://about.gitlab.com/fr-fr/blog/getting-started-with-gitlab-mastering-project-management/)\n* [La gemme gitlab-triage : votre alliée pour des workflows Agile automatisés](https://about.gitlab.com/fr-fr/blog/automating-agile-workflows-with-the-gitlab-triage-gem/)\n* [Comprendre l'approche CI/CD](https://about.gitlab.com/fr-fr/blog/getting-started-with-gitlab-understanding-ci-cd/)",[834],"GitLab Team",[686,684,774,772,9,750],"2025-06-10",{"slug":838,"featured":91,"template":691},"getting-started-with-gitlab-working-with-ci-cd-variables","content:fr-fr:blog:getting-started-with-gitlab-working-with-ci-cd-variables.yml","Getting Started With Gitlab Working With Ci Cd Variables","fr-fr/blog/getting-started-with-gitlab-working-with-ci-cd-variables.yml","fr-fr/blog/getting-started-with-gitlab-working-with-ci-cd-variables",{"_path":844,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":845,"content":851,"config":861,"_id":863,"_type":14,"title":864,"_source":16,"_file":865,"_stem":866,"_extension":19},"/fr-fr/blog/gitlab-flow-duo",{"title":846,"description":847,"ogTitle":846,"ogDescription":847,"noIndex":6,"ogImage":848,"ogUrl":849,"ogSiteName":673,"ogType":674,"canonicalUrls":849,"schema":850},"GitLab Flow et GitLab Duo : le combo gagnant pour un workflow puissant","Tirez parti de workflows DevSecOps plus productifs et puissants en combinant GitLab Flow et GitLab Duo au sein de votre cycle de développement logiciel.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749662840/Blog/Hero%20Images/ai-experiment-stars.png","https://about.gitlab.com/blog/gitlab-flow-duo","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"GitLab Flow et GitLab Duo : le combo gagnant pour un workflow puissant\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Cesar Saavedra\"}],\n        \"datePublished\": \"2023-07-27\",\n      }",{"title":846,"description":847,"authors":852,"heroImage":848,"date":854,"body":855,"category":856,"tags":857,"updatedDate":860},[853],"Cesar Saavedra","2023-07-27","Adopter une approche DevSecOps nécessite de bien réfléchir au workflow qui sera utilisé. Si cette étape peut parfois représenter un défi de taille, GitLab Flow et GitLab Duo sont là pour vous simplifier la tâche :\n\n__GitLab Flow__ est l'approche préconisée pour accompagner les entreprises dans la mise en œuvre réussie de leurs processus DevSecOps. __GitLab Duo__, quant à lui, offre un [ensemble de fonctionnalités alimentées par l'IA](https://about.gitlab.com/blog/supercharge-productivity-with-gitlab-duo/), intégré à la plateforme DevSecOps de GitLab. Il aide les équipes de développement à coder plus efficacement, optimise le cycle de développement logiciel et garantit une livraison de logiciels plus sécurisés. \n\nEn associant __GitLab Flow__ et __GitLab Duo__, les entreprises peuvent améliorer considérablement l'intégralité de leur workflow, augmenter davantage leur productivité, la fréquence de leurs déploiements, la qualité du code et la sécurité globale, ainsi que la résilience et la disponibilité de l'environnement de production.\n\nDans cet article, découvrez comment GitLab Flow et GitLab Duo peuvent être utilisés conjointement pour aider les entreprises à réussir leur approche [DevSecOps](https://about.gitlab.com/fr-fr/topics/devsecops/ \"Qu'est-ce que DevSecOps ?\").\n\n## Qu'est-ce que GitLab Flow ?\n\n[GitLab Flow](https://about.gitlab.com/fr-fr/topics/version-control/what-is-gitlab-flow/ \"Qu'est-ce que GitLab Flow ? \") est un workflow complet et précis destiné au développement d'applications avec GitLab, notre plateforme DevSecOps alimentée par l'IA offrant une interface utilisateur et un modèle de données uniques. \n\nGitLab Flow est basé sur les meilleures pratiques et leçons tirées des retours d'expérience de nos clients ainsi que de l'utilisation de nos propres fonctionnalités en interne. En outre, GitLab Flow couvre chacune des [étapes du cycle de vie DevSecOps](https://about.gitlab.com/fr-fr/stages-devops-lifecycle/) créant un workflow efficace comprenant deux boucles de rétroaction : \n\n- Une __boucle de rétroaction interne__ qui permet d'examiner et d'évaluer une mise à jour spécifique de l'application pour s'assurer qu'elle répond aux critères de qualité et de sécurité. \n- Une __boucle de rétroaction externe__ qui vise à améliorer l'application dans son ensemble, ainsi que le cycle de développement lui-même. \n\n![Boucles de rétroaction internes et externes de GitLab Flow](https://about.gitlab.com/images/blogimages/gitlab-flow-duo/The-GitLab-Flow-2023-feedback-loops.png)\n\u003Ccenter>Boucles de rétroaction internes et externes de GitLab Flow\u003C/center>\u003Cp>\u003C/p>\n\nGitLab Flow étant constitué de nombreuses étapes, le développement logiciel ne se limite pas à la simple écriture de code. Découvrez ci-dessous chaque étape du processus DevSecOps dans GitLab Flow ainsi que les avantages d'y ajouter l'utilisation de GitLab Duo. \n\n### L'étape de planification\n\nLa planification est la première étape de GitLab Flow et fait partie de la boucle de rétroaction externe. Elle inclut les tickets, les merge requests, les epics, les jalons, les itérations, les sorties de nouvelles versions, les preuves de déploiement et bien plus encore. Découvrez le rôle de ces composants dans GitLab Flow et les avantages de les utiliser en parallèle de GitLab Duo.\n\n![Planification : première étape de GitLab Flow](https://about.gitlab.com/images/blogimages/gitlab-flow-duo/The-GitLab-Flow-2023-planning-portion.png)\n\u003Ccenter>Planification : première étape de GitLab Flow\u003C/center>\u003Cp>\u003C/p>\n\n#### Les tickets \n\nLes tickets sont des espaces collaboratifs dans lesquels les problèmes relatifs au produit sont traités et les nouvelles fonctionnalités sont définies. Lorsque vous créez un ticket, vous commencez par renseigner son titre. Ensuite, vous pouvez utiliser la fonctionnalité de **génération de descriptions de tickets** de GitLab Duo pour automatiquement enrichir le champ de description. Cela vous permet ainsi de gagner un temps précieux et de réduire vos efforts. \n\nComme de nombreuses personnes peuvent être amenées à collaborer sur un même ticket, la fonctionnalité de **résumé des discussions** alimentée par l'IA de GitLab Duo peut résumer des centaines de commentaires laissés sur un ticket en un paragraphe concis. Ainsi, n'importe quelle partie prenante peut rapidement suivre la conversation, rejoindre la discussion et être immédiatement productive.\n\nLes tickets peuvent être organisés et visualisés dans des tableaux de tickets, qui sont des outils de gestion de projet pouvant être utilisés comme tableaux Kanban ou Scrum. Ces tableaux aident les équipes à planifier, à organiser et à visualiser un workflow relatif à un déploiement d'une fonctionnalité ou d'un produit. Différentes catégories de tableaux peuvent être créées et les tickets peuvent être déplacés d'un tableau à l'autre par simple glisser-déposer.\n\n#### Les merge requests\n\nC'est à l'aide des merge requests que les solutions logicielles sont développées. En tant que composants associés à la sortie de nouvelles versions, les tickets et les merge requests permettent d'auditer et de suivre les modifications apportées aux applications par les parties prenantes. Ils sont essentiels au travail des [ingénieurs DevOps](https://about.gitlab.com/fr-fr/topics/devops/what-is-a-devops-platform-engineer/ \"Qu’est-ce qu’un ingénieur de plateforme DevOps ?\") et des ingénieurs de plateforme, aux administrateurs système et aux administrateurs de base de données, tout comme aux ingénieurs sécurité et aux équipes de développement. En outre, les tickets et les merge requests sont des éléments clés du processus de planification pour la sortie des nouvelles versions.\n\nLes merge requests peuvent être créées individuellement ou à partir d'un ticket existant. La création d'une merge request à partir d'un ticket la relie automatiquement à ce dernier, de sorte que lorsqu'elle est fusionnée, le ticket associé est automatiquement fermé. Il est également possible de lier manuellement une merge request à un ticket.\n\n![Une merge request fusionnée ferme le ticket associé](https://about.gitlab.com/images/blogimages/gitlab-flow-duo/mr-with-its-issue.png)\n\u003Ccenter>Une merge request fusionnée ferme le ticket associé\u003C/center>\u003Cp>\u003C/p>\n\nTout comme les tickets, les merge requests peuvent regrouper une longue liste de mises à jour d'une branche de fonctionnalité réalisées par de nombreuses parties prenantes. Les collaborateurs souhaitant comprendre ou se familiariser avec les mises à jour d'une merge request peuvent utiliser la fonctionnalité de **résumé des merge requests** de GitLab Duo pour prendre rapidement connaissance des modifications qui ont été apportées. De plus, ils peuvent tirer parti de la fonctionnalité de **remplissage automatique d'un modèle de merge request** de GitLab Duo, qui s'appuie sur un template de merge request prédéfini, pour remplir automatiquement le contenu des différentes sections. Ces templates de description permettent de standardiser et d'optimiser la collaboration et la communication entre les parties prenantes tout au long du cycle de développement. Et ce processus est encore plus rapide avec GitLab Duo !\n\nLes tickets appartenant au même thème peuvent être regroupés dans des epics pour organiser les tâches à effectuer. Les epics peuvent inclure des tickets enfants et des sous-epics et/ou être liés aux autres epics de l'entreprise. Les itérations permettent de suivre les sprints de travail. Vous pouvez les planifier soit manuellement, soit automatiquement à l'aide des cadences d'itération de GitLab afin de rationaliser les workflows de planification. De plus, elles incluent des [graphiques d'avancement burndown et burnup](https://docs.gitlab.com/ee/user/project/milestones/burndown_and_burnup_charts.html). Les graphiques d'avancement burndown suivent la progression globale d'un projet, tandis que les graphiques d'avancement burnup suivent quotidiennement le nombre total et le poids des tickets ajoutés et terminés dans une timebox donnée.\n\n#### Les jalons\n\nLes jalons permettent aux équipes DevSecOps d'organiser les tickets et les merge requests dans un groupe cohérent, avec une date de début et une échéance facultatives. Ils sont généralement utilisés pour suivre les nouvelles versions et servent également à suivre les tickets et les merge requests au niveau d'un projet ou d'un groupe. Similaires aux itérations, les jalons fournissent des graphiques d'avancement burndown et burnup montrant l'avancement d'un projet.\n\nIls peuvent être associés à la sortie d'une nouvelle fonctionnalité, dont la création automatisée génère de nombreux artefacts, y compris des preuves de déploiement. La preuve de déploiement est un instantané automatisé des données liées à la sortie d'une nouvelle fonctionnalité. En complément des artefacts de test et des jalons associés, les artefacts de job peuvent éventuellement être inclus dans les preuves de déploiement. Cette démarche facilite la vérification par des audits externes des processus internes de développement et de déploiement des nouvelles versions.\n\nLes epics, jalons et itérations peuvent être visualisés depuis la page Roadmaps, qui permet de suivre la progression de la sortie d'une nouvelle fonctionnalité et de rationaliser ce processus. \n\nUne fois l'étape de planification terminée, le travail visant à résoudre un problème ou à développer une nouvelle fonctionnalité peut commencer. C'est là que les merge requests entrent en jeu. Examinons plus en détail ce processus dans GitLab Flow. \n\n### Les merge requests et le push du code\n\n![Merge requests et push du code : deuxième étape de GitLab Flow](https://about.gitlab.com/images/blogimages/gitlab-flow-duo/The-GitLab-Flow-2023-mr-pushing-code-portion.png)\n\u003Ccenter>Merge requests et push du code : deuxième étape de GitLab Flow\u003C/center>\u003Cp>\u003C/p>\n\nLa deuxième étape dans GitLab Flow concerne les merge requests et le push du code. Comme mentionné précédemment, c'est à l'aide des merge requests que les solutions sont développées de façon collaborative par les parties prenantes de l'entreprise. Cette collaboration peut se faire de manière distribuée et asynchrone.\n\nLes participants peuvent tirer parti des fonctionnalités de collaboration, telles que l'ajout de tags, l'intégration de suggestions et de commentaires à la ligne de code, l'ajout de commentaires au sein des merge requests, la revue des fils de discussion et des demandes. Toutes ces fonctionnalités permettent d'améliorer la qualité du code, sa disponibilité, sa fiabilité et ses performances. \n\nLa boucle de rétroaction interne de GitLab Flow intervient directement après la création de la merge request. Elle inclut le push du code et des corrections, l’exécution des scans et des tests, ainsi que la revue à des fins collaboratives et de mise à jour.\n\n#### Les pipelines\n\nLorsque des mises à jour sont appliquées à une branche de fonctionnalité via des merge requests, les pipelines (s'ils sont définis) sont automatiquement exécutés. Ils peuvent comporter plusieurs étapes et jobs servant à compiler, à tester puis à déployer l'application ou le [microservice](https://about.gitlab.com/fr-fr/blog/what-are-the-benefits-of-a-microservices-architecture/ \"Qu’est-ce qu’une architecture de microservices ? \") dans un environnement de revue. Cet environnement permet de vérifier les mises à jour dynamiquement avant qu'elles ne soient fusionnées dans la branche principale. Cette automatisation rationalise les processus de mise à jour et de revue lors du développement de l'application.\n\nPar ailleurs, lorsqu'elles apportent des mises à jour à l'application via des merge requests, les équipes DevSecOps ont accès à diverses fonctionnalités alimentées par l'IA. Lors de l'écriture ou de la mise à jour du code, la fonctionnalité de **[suggestions de code](https://about.gitlab.com/fr-fr/solutions/code-suggestions/ \"Suggestions de code\")** de GitLab Duo propose la prochaine portion de code à écrire en fonction du contexte. Le développeur est alors libre de l'accepter ou de l'ignorer. \n\nLes suggestions de code prennent en charge la génération de code via des prompts ainsi que la complétion de code en temps réel. Elles peuvent améliorer l'expérience de programmation en réduisant les erreurs et en aidant les équipes de développement à écrire du code plus rapidement, contribuant ainsi à améliorer la qualité du code de l'environnement de production. Elles peuvent également accroître la productivité des développeurs et développeuses, ainsi qu'accélérer les itérations et les déploiements.\n\nLorsque les différentes parties prenantes au sein du projet participent au développement ou à la revue d'applications, elles se heurtent parfois à un code peu documenté, complexe, difficile à interpréter ou écrit dans un langage de programmation qui ne leur est pas familier. Avec la fonctionnalité d'**explication du code** de GitLab Duo, le code est traduit en langage naturel permettant à quiconque au sein de l'équipe de le comprendre facilement et de devenir opérationnel rapidement.\n\nDe plus, lorsqu'un développeur ou une développeuse effectue une validation des modifications sur une branche de fonctionnalité, la fonctionnalité de **suggestion de relecteurs** de GitLab Duo utilise la merge request de ces modifications et le graphique de contributions pour suggérer une liste de relecteurs appropriés dans la liste déroulante des relecteurs située dans la barre latérale de la merge request. Cette liste inclut des utilisateurs qui connaissent un aspect spécifique de l'application et semblent les meilleurs candidats pour effectuer une revue des mises à jour. Ainsi, les développeurs n'ont plus besoin de rechercher ni d'identifier eux-mêmes les relecteurs appropriés, ce qui évite les retards et garantit la qualité des revues.\n\nLorsque les développeurs modifient le code, il arrive souvent qu'ils n'incluent pas dans la merge request un commentaire sur les modifications apportées. Fort de ce constat, la fonctionnalité de **résumé des merge requests** de GitLab Duo permet à l'auteur de la merge request d'utiliser l'IA pour générer un commentaire en langage naturel qui résume les modifications apportées au code. Les relecteurs peuvent ainsi mieux comprendre les changements apportés et rationaliser l'ensemble du processus de revue. \n\nLorsque les relecteurs vérifient les modifications apportées au code dans une merge request et qu'ils détectent des anomalies, ils peuvent créer un bloc de revue pouvant inclure de nombreux commentaires impliquant de nombreux fichiers source. Pour aider l'auteur de la merge request à comprendre l'afflux de commentaires fournis par le relecteur, la fonctionnalité de **résumé des revues de code** de GitLab Duo génère un résumé en langage naturel des retours du relecteur. Cela permet de meilleurs transferts entre les auteurs et les relecteurs, tout en simplifiant le processus de revue.\n\nEn outre, lorsque les développeurs ajoutent du nouveau code par le biais d'une merge request, ils peuvent tirer parti de la fonctionnalité de **génération de tests** de GitLab Duo qui utilise l'IA pour générer des tests unitaires afin de vérifier le nouveau code. Cela permet d'augmenter la productivité des équipes de développement, d'améliorer la couverture de test et de détecter les bogues en amont du cycle de développement. Elles peuvent également tirer parti de **[GitLab Duo Chat](https://about.gitlab.com/fr-fr/blog/developing-gitlab-duo-a-roundup-of-recent-chat-enhancements/ \"GitLab Duo Chat\")**, qui est toujours accessible, afin de refactoriser le code et de générer de la documentation intégrée à la ligne de code (par exemple des docstrings) pour leur code source.\n\nBien que les pipelines s'exécutent sur les mises à jour de branches, ils peuvent inclure des tests et des scans automatisés, ce qui permet d'intégrer la [sécurité en amont](https://about.gitlab.com/fr-fr/topics/ci-cd/shift-left-devops/ \"Shift Left\").\n\n### L'intégration de la sécurité en amont\n\n![L'intégration de la sécurité en amont : troisième étape de GitLab Flow](https://about.gitlab.com/images/blogimages/gitlab-flow-duo/The-GitLab-Flow-2023-shift-sec-left-portion.png)\n\u003Ccenter>L'intégration de la sécurité en amont : troisième étape de GitLab Flow\u003C/center>\u003Cp>\u003C/p>\n\nL'intégration de la sécurité en amont est la troisième étape de GitLab Flow. Elle fait également partie de la boucle de rétroaction interne.\n\nLes ingénieurs DevOps et ingénieurs de plateforme, les administrateurs système et administrateurs de base de données, les développeurs ainsi que d'autres parties prenantes collaborant à une merge request peuvent avoir des inquiétudes concernant la sécurité et la conformité. C'est là que les scans de sécurité et les tests automatisés entrent en jeu. \n\nIl est possible d'inclure les scans de sécurité dans un pipeline via des templates prêts à l'emploi et/ou de les exécuter automatiquement dans un pipeline de merge requests. GitLab fournit un large éventail de scanners et d'analyseurs de sécurité intégrés qui peuvent être utilisés par GitLab Flow. Mais ce n'est pas tout, notre plateforme DevSecOps peut également accueillir des scanners tiers et personnalisés.\n\nGitLab Flow intègre la sécurité en amont dans le pipeline afin de détecter et de résoudre les failles de sécurité le plus tôt possible dans le cycle de développement logiciel. Il est beaucoup plus simple (et moins coûteux) de corriger les vulnérabilités au début du cycle de développement. En effet, une fois qu'une application est en production, une panne imprévue peut avoir des conséquences sur vos utilisateurs, mais aussi vos revenus. Alors, pourquoi ne pas la résoudre avant qu'elle ne se produise ? \n\nVoici une liste des scanners et analyseurs de sécurité intégrés fournis par GitLab : \n- les tests unitaires, \n- l'analyse de l'Infrastructure as Code (IaC), \n- les scanners SAST (test statique de sécurité des applications), \n- l'analyse des dépendances, \n- la détection de secrets, \n- l'analyse des conteneurs, \n- la sécurité des API, \n- les tests d'API web par injection de données aléatoires,\n- les tests à données aléatoires guidés par la couverture de code. \n\nGitLab fournit par ailleurs un grand nombre de tableaux de bord et de rapports de sécurité permettant de gérer et de visualiser les vulnérabilités (liste des dépendances, tableau de bord de sécurité, rapport sur les vulnérabilités et pages de vulnérabilité).\n\nPour aider les développeurs et les ingénieurs sécurité à mieux comprendre les vulnérabilités et à les corriger plus efficacement, la fonctionnalité d'**explication des vulnérabilités** de GitLab Duo fournit des détails sur une vulnérabilité spécifique, en décrivant comment elle peut être exploitée et, surtout, en proposant des recommandations pour la corriger. Les développeurs peuvent également tirer parti de la fonctionnalité de **résolution des vulnérabilités** de GitLab Duo, qui crée automatiquement une merge request incluant les modifications de code permettant de corriger la vulnérabilité. Ces fonctionnalités alimentées par l'IA rationalisent et optimisent le processus de sécurisation et de renforcement de l'application concernée afin de prévenir les vulnérabilités susceptibles d'être exploitées lors de cyberattaques dans l'environnement de production.\n\nOutre les scanners SAST, GitLab met à disposition de ses utilisateurs des scanners DAST (test dynamique de sécurité des applications) qui nécessitent une application en cours d'exécution pour effectuer les tests. Grâce à ces scanners, GitLab peut provisionner automatiquement un environnement DAST en vue de réaliser des scans DAST, puis effectuer un nettoyage complet de toutes les ressources après les tests DAST. Par ailleurs, pour les conteneurs en cours d'exécution, GitLab fournit une fonctionnalité OCS (Operational Container Scanning) qui analyse les images de conteneurs de votre cluster afin de detecter des failles de sécurité.\n\nIl est possible d'exécuter automatiquement les scans mentionnés ci-dessus dans un pipeline de merge requests ou, dans certains cas, de planifier leur exécution via des stratégies d'exécution de scan et d'approbation des merge requests. Ces stratégies peuvent être définies via l'interface utilisateur de GitLab ou des fichiers YAML. Elles sont configurées dans un projet distinct, ce qui permet de séparer les tâches et ainsi de faciliter la réutilisation, la maintenance et la gestion. Les stratégies d'exécution des scans exigent que les scans de sécurité soient exécutés selon un calendrier précis ou avec le pipeline de projets. Ensuite, les stratégies d'approbation des merge requests prennent des mesures basées sur les résultats des scans. Les équipes ou les ingénieurs sécurité peuvent définir ces stratégies pour appliquer les processus de sécurité dans l'ensemble de l'entreprise, et GitLab Flow peut les détecter ou les exploiter lors de son exécution.\n\nPour renforcer la sécurité et la conformité des projets menés au sein de votre entreprise, vous pouvez utiliser des pipelines et des labels de conformité. Ceux-ci peuvent être rendus obligatoires avant l’exécution du pipeline d’un projet. Ainsi, vous avez la certitude que l'ensemble de vos équipes respectent vos normes de sécurité et de conformité. Cela vous permet par ailleurs de protéger vos applications contre les cyberattaques, tout en respectant les normes de conformité gouvernementales et de toujours être préparé pour un éventuel audit.\n\nL'objectif principal de toutes ces recommandations de sécurité de GitLab Flow est de corriger les vulnérabilités dès le début du cycle de développement, plutôt qu'en production, car les corrections peuvent s'avérer lourdes de conséquences en termes de réputation et de chiffre d'affaires.\n\nÀ mesure que les vulnérabilités sont atténuées dans la boucle de rétroaction interne de GitLab Flow et que des mises à jour sont apportées à l'application dans la branche de fonctionnalité, les parties prenantes doivent effectuer une nouvelle revue des mises à jour pour s'assurer de leur application effective et qu'aucune régression n'a été introduite par inadvertance.\n\n### La revue continue\n\n![La revue : quatrième étape de GitLab Flow](https://about.gitlab.com/images/blogimages/gitlab-flow-duo/The-GitLab-Flow-2023-reviewing-features-portion.png)\n\u003Ccenter>La revue de code : quatrième étape de GitLab Flow\u003C/center>\u003Cp>\u003C/p>\n\nLa revue des fonctionnalités, quatrième étape de GitLab Flow, repose sur une revue continue des applications. Cette étape nécessite de déployer l'application provisoire (branche de fonctionnalité) dans un environnement de revue prévu à cet effet afin que les parties prenantes puissent la vérifier en temps réel et fournir des retours constructifs. L'application provisoire peut ensuite être ajustée en continu jusqu'à ce qu'elle soit prête à être fusionnée dans la branche principale. GitLab Flow recommande également le nettoyage de toutes les ressources de l'environnement de revue provisionnées au moment où la merge request est fusionnée dans la branche principale.\n\nCe processus de revue automatisé et itératif fait partie de la boucle de rétroaction interne de GitLab Flow. Comme mentionné ci-dessus, dans la boucle de rétroaction interne, il est recommandé d'utiliser les fonctionnalités de GitLab Duo suivantes : explication du code, suggestions de code, suggestion de relecteurs, résumé des merge requests, remplissage automatique d'un template de merge request, résumé des revues de code, explication des vulnérabilités, résolution des vulnérabilités et analyse des causes profondes. En effet, celles-ci facilitent le transfert entre les auteurs et les relecteurs tout en simplifiant l'ensemble du processus de revue.\n\nLa boucle de rétroaction interne de GitLab Flow prend fin lorsque tous les éléments de revue sont traités et que la merge request est approuvée et fusionnée dans la branche principale, ce qui déclenche le déploiement de l'application en production.\n\n### Le déploiement des applications et de l'infrastructure\n\n![Le déploiement : cinquième étape de GitLab Flow](https://about.gitlab.com/images/blogimages/gitlab-flow-duo/The-GitLab-Flow-2023-deploy-apps-portion.png)\n\u003Ccenter>Le déploiement : cinquième étape de GitLab Flow\u003C/center>\u003Cp>\u003C/p>\n\nEn fonction des besoins de l'entreprise, GitLab Flow recommande la livraison continue ou le déploiement continu. \n- La __livraison continue__ consiste à publier fréquemment du code en déclenchant les déploiements manuellement (par exemple, en production). \n- Le __déploiement continu__ désigne la publication automatisée de code (par exemple, en production) sans intervention humaine. \n\nIntéressons-nous d'abord à la livraison continue.\n\nLorsque vous publiez votre logiciel en utilisant la livraison continue, vous disposez de plusieurs options de déploiement. Vous pouvez établir une fenêtre de gel, puis déployer le logiciel à l'aide de techniques de déploiement avancées, telles que les déploiements canari, bleu/vert, programmés et incrémentiels. Les déploiements incrémentiels réduisent le risque de panne dans l'environnement de production et améliorent l'expérience utilisateur ainsi que la satisfaction client. Les techniques de déploiement avancées améliorent également l'efficacité du processus de développement et de livraison en simplifiant le processus de sortie de nouvelles versions.\n\nLorsque vous publiez votre logiciel en utilisant le déploiement continu, l'intégralité des changements/mises à jour est directement déployée en production. Les approches de livraison progressive telles que les feature flags, qui vous permettent de séparer la livraison de fonctionnalités spécifiques d'un lancement, sont un bon moyen de réduire les risques et de gérer les fonctionnalités à mettre à la disposition des utilisateurs finaux. Les feature flags prennent en charge plusieurs langages de programmation. Ils permettent aux équipes de développement d'expérimenter et d'effectuer des tests contrôlés. Vous pouvez même utiliser des feature flags pour déployer des fonctionnalités auprès d'utilisateurs spécifiques.\n\nBien que GitLab prenne en charge toutes ces approches de déploiement, GitLab Flow permet d'adopter l'approche qui convient le mieux aux équipes et/ou aux besoins spécifiques du projet.\n\n### La surveillance des applications et des processus DevSecOps\n\nUne fois que votre application a été déployée en production, elle doit être surveillée en permanence pour assurer sa stabilité, ses performances et sa disponibilité. En outre, les processus DevSecOps qui s'exécutent sont mesurés en parallèle, ce qui permet d'améliorer leurs performances et leur efficacité. Les fonctionnalités de surveillance sont fournies par GitLab et, en tant que telles, peuvent être exploitées par GitLab Flow.\n\nPour les conteneurs en cours d'exécution, GitLab fournit une fonctionnalité OCS (Operational Container Scanning) qui analyse les images de conteneurs de votre cluster afin de détecter des failles de sécurité. Il est possible d'automatiser ces scans en planifiant leur exécution. Les vulnérabilités détectées sont automatiquement affichées dans un tableau de bord de sécurité. La fonctionnalité OCS peut vous aider à sécuriser vos applications de cluster et à anticiper toute cyberattaque pouvant entraîner des fuites de données privées et même provoquer des pannes inattendues.\n\nLe suivi des erreurs permet aux équipes de développement de détecter et de visualiser les erreurs générées par leur application. Celles-ci sont affichées dans la liste de suivi des erreurs dans GitLab. Le suivi des erreurs permet d'améliorer la disponibilité et les performances de vos applications en détectant et en résolvant rapidement les conditions d'application inattendues.\n\nGitLab peut recevoir des alertes de n'importe quelle source de surveillance, y compris Prometheus, via un récepteur webhook. Dès qu'une alerte arrive, elle est affichée dans la section Alertes de GitLab, où vous pouvez la gérer manuellement. Les alertes peuvent également déclencher automatiquement la création d'incidents, de ChatOps et d'e-mails à des personnes ou des groupes spécifiques. Toutes ces fonctionnalités rationalisent le processus de résolution et de gestion des alertes.\n\nDès qu'un incident est créé suite à la détection de problèmes dans l'environnement de production, il apparaît dans la liste des incidents de GitLab, où vous pouvez le gérer facilement. Vous pouvez gérer un ou plusieurs incidents, les trier, les rechercher, les assigner, définir leurs statuts et même voir leur compte à rebours calculant l'échéance de l'accord de niveau de service (SLA). De plus, vous pouvez créer des équipes d'astreinte et des rotations, des politiques d'escalade, ainsi que configurer la remontée d'alertes et les notifications pour gérer les incidents. Vous pouvez également associer un incident à une alerte afin que celle-ci soit automatiquement résolue une fois que l'incident est clos. Les chronologies d'incident permettent également aux cadres dirigeants et aux utilisateurs externes de voir ce qui s'est passé lors d'un incident et quelles mesures ont été prises pour le résoudre. Toutes ces fonctionnalités rationalisent et accélèrent le processus de gestion et de résolution des incidents.\n\nLes événements d'audit suivent les événements importants, en permettant notamment d'identifier l'intervenant qui a effectué l'action correspondante et le moment de son intervention dans GitLab. Ces événements sont affichés dans la liste des événements d'audit de GitLab et fournissent, entre autres, l'action qui a été effectuée sur un objet, son auteur, ainsi que sa date et son heure d'occurrence.\n\nL'ensemble des listes et tableaux de bord mentionnés ci-dessus permettent d'anticiper les scénarios de non-conformité afin d'éviter les pénalités et de rationaliser les processus d'audit. Pour vos applications en cours d'exécution, ils génèrent des données et des indicateurs qui peuvent être utilisés dans la boucle de rétroaction externe de GitLab Flow afin de vous aider à améliorer et à optimiser vos applications et à réduire le risque de pannes imprévues dans l'environnement de production.\n\n### L'amélioration continue\nGitLab Flow permet de tirer parti des tableaux de bord et indicateurs de performance des processus à chaque étape du développement logiciel. Ces tableaux offrent des informations précieuses pour améliorer en continu votre application et vos performances dans ce domaine. Ils sont générés automatiquement par GitLab et sont toujours accessibles.\n\n### Le tableau de bord d'analyse des flux de valeur\n\nVous pouvez suivre et surveiller le cycle de développement de vos applications via le tableau de bord d'analyse des flux de valeur, où vous pouvez consulter les statistiques d'un projet ou d'un groupe au fil du temps. Ce tableau de bord est personnalisable, mais vous pouvez commencer rapidement en créant une chaîne de valeur à l'aide d'un template par défaut fourni par GitLab. Celui-ci affiche des indicateurs pour chacune des étapes prédéfinies de l'analyse du flux de valeur (ticket, planification, codage, test, revue et préproduction), ainsi qu'un graphique montrant le délai moyen d'achèvement de chaque étape. Il affiche également les indicateurs clés de l'analyse du flux de valeur : délai d'exécution, durée de cycle, nouveaux tickets, validations et déploiements. Vous pouvez utiliser ces indicateurs pour identifier des axes d'amélioration dans les étapes de votre chaîne de valeur.\n\n### Le tableau de bord des métriques DORA\n\nPour visualiser les indicateurs de performance qui mesurent l'efficacité des pratiques de développement et de livraison de votre entreprise, GitLab met à disposition de ses utilisateurs un tableau de bord des métriques [DORA](https://about.gitlab.com/fr-fr/solutions/value-stream-management/dora/) (DevOps Research and Assessment), qui affiche quatre métriques clés : la fréquence de déploiement, le délai d'exécution des modifications, le délai de rétablissement du service et le taux d'échec des modifications. \n\n- La fréquence de déploiement mesure la fréquence à laquelle votre entreprise déploie du code en production ou le publie à destination des utilisateurs finaux. \n- Le délai d'exécution des modifications mesure le temps nécessaire pour passer du code validé au code exécuté avec succès en production. \n- Le délai de rétablissement du service mesure le temps nécessaire pour rétablir les services au niveau où ils étaient auparavant, en cas d'incident. \n- Le taux d'échec des modifications correspond au pourcentage de modifications apportées à l'environnement de production ou aux versions destinées aux utilisateurs, qui ont entraîné une dégradation du service (par exemple, une défaillance ou une panne) et ont ensuite nécessité des mesures correctives (solution corrective d'urgence, restauration d'une version antérieure, correctif). \n\nCes quatre métriques clés mesurent l'efficacité de vos processus actuels et vous donnent la possibilité d'améliorer les facteurs et fonctionnalités permettant de soutenir le travail de vos équipes.\n\n### La personnalisation de votre tableau de bord\n\nLe tableau de bord des flux de valeur est un autre tableau de bord personnalisable qui permet aux décideurs d'identifier les tendances et les opportunités d'amélioration du développement logiciel. Il affiche les métriques DORA suivies des indicateurs d'efficacité du processus d'analyse des flux de valeur et du nombre de vulnérabilités critiques et élevées pour le mois en cours, les deux mois précédents et les six derniers mois.\n\nGitLab Duo peut également vous aider dans vos efforts d'amélioration continue. Par exemple, la fonctionnalité de **prédiction de la chaîne de valeur** prend l'historique des données et utilise les tendances de l'ensemble de votre cycle de développement pour prédire le comportement futur de vos indicateurs de chaîne de valeur. Vous pouvez utiliser ces analyses prédictives dans vos efforts d'optimisation.\n\nL'ensemble de ces tableaux de bord et les indicateurs dont ils rendent compte font partie de la boucle de rétroaction externe de GitLab Flow. Ils vous aident à réduire le risque de pannes imprévues dans l'environnement de production, ainsi qu'à améliorer et à optimiser vos applications et vos workflows DevSecOps.\n\n### La fonctionnalité d'analyse d'impact de l'IA\n\nPour mieux comprendre l'impact de l'utilisation de GitLab Duo (ou de l'IA) tout au long du cycle de développement, vous pouvez consulter le tableau de bord d'[analyse d'impact de l'IA](https://about.gitlab.com/fr-fr/blog/developing-gitlab-duo-ai-impact-analytics-dashboard-measures-the-roi-of-ai/). Ce tableau vous indique comment l'adoption de la fonctionnalité de suggestions de code de GitLab Duo impacte d'autres indicateurs de performance, de qualité et de sécurité, sur les six derniers mois, tels que la durée de cycle, le délai d'exécution, la fréquence de déploiement, le taux d'échec des modifications et les vulnérabilités critiques au fil du temps.\n\nL'analyse d'impact de l'IA mesure l'adoption, l'optimisation et les avantages que l'IA apporte aux équipes et à l'entreprise dans son ensemble, et permet également d'identifier des axes d'amélioration.\n\n## Pourquoi utiliser GitLab Flow ?\n\nGitLab Flow est une approche préconisée, suivie par nos clients et utilisateurs du monde entier, qui offre les avantages suivants : \n- Une productivité accrue grâce aux fonctionnalités d'automatisation fournies par GitLab, son interface utilisateur unique et son modèle de données unique, le tout exploité par GitLab Flow.\n- Des informations précises sur le cycle de vie DevSecOps complet pour soutenir l'amélioration continue. \n- Des tableaux de bord et indicateurs intégrés qui peuvent vous aider à optimiser vos applications et vos processus DevSecOps.\n- Une qualité accrue du code et l'amélioration de la fiabilité et de la disponibilité de vos applications.\n- Une meilleure sécurité des applications grâce à des scanners et des fonctionnalités de sécurité intégrés.\n- La conformité et la préparation aux audits via des fonctionnalités de conformité intégrées.\n- Des durées de cycle plus courtes qui peuvent vous aider à augmenter la fréquence de déploiement.\n- La revue en continu activée par la boucle de rétroaction interne de GitLab Flow.\n- La boucle de rétroaction interne de GitLab Flow peut vous aider à optimiser les mises à jour afin d'améliorer la qualité du code, ainsi que la fiabilité et la disponibilité de vos applications.\n- La boucle de rétroaction externe de GitLab Flow peut vous aider à améliorer vos applications ainsi que le cycle de développement lui-même.\n- Des niveaux élevés de collaboration entre les parties prenantes de votre entreprise.\n- L'intégration de la sécurité en amont pour identifier les vulnérabilités dans les applications avant qu'elles ne passent en production, et ainsi éviter les pannes coûteuses et imprévues.\n- La réduction des risques lors du déploiement en production grâce aux techniques de déploiement avancées et aux approches de livraisons échelonnées prises en charge par GitLab.\n- Des fonctionnalités alimentées par l'IA qui couvrent l'ensemble du cycle de développement et peuvent optimiser la productivité, la qualité du code, l'amélioration continue, la sécurité, la conformité et bien plus encore.\n- La prise en charge des applications cloud-native et autres types d'application.\n- La prise en charge multi-cloud pour les applications hybrides/multi-cloud.\n\nPour commencer avec GitLab Flow, tirer parti de la fonctionnalité Auto DevOps de GitLab ou de certains de ses composants est un bon point de départ pour appliquer les principes de GitLab Flow à votre cycle de développement logiciel.\n\n## GitLab Flow et Auto DevOps\n\n![Auto DevOps : une instanciation de GitLab Flow](https://about.gitlab.com/images/blogimages/gitlab-flow-duo/ado-pipeline.png)\n\u003Ccenter>Auto DevOps : une instanciation de GitLab Flow\u003C/center>\u003Cp>\u003C/p>\n\n[Auto DevOps](https://docs.gitlab.com/ee/topics/autodevops/) applique GitLab Flow à l'ensemble des étapes et jobs associés. Vous pouvez le considérer comme un bon exemple pour l'instanciation de GitLab Flow.\n\nAuto DevOps est une collection de templates CI/CD prédéfinis et prêts à l'emploi qui détectent automatiquement le code source dont vous disposez. Basés sur les bonnes pratiques, ces templates détectent, compilent, testent, déploient et surveillent automatiquement vos applications.\n\nLe pipeline Auto DevOps intègre la sécurité en amont pour détecter et prévenir les défauts le plus tôt possible dans le processus de livraison de logiciels. Il déploie ensuite l'application en préproduction pour vérification, puis en production de manière incrémentielle/planifiée.\n\nAuto DevOps vous permet de démarrer rapidement, en augmentant la productivité des équipes de développement. Vous pouvez le personnaliser facilement en fonction de vos besoins, grâce à la prise en charge des frameworks et des langages de programmation les plus courants. Auto DevOps étant modulaire, personnalisable et extensible, vous pouvez utiliser certains de ses composants dans vos pipelines ou l'appliquer intégralement à votre application.\n\n## Conclusion\n[Combinez GitLab Flow et GitLab Duo dès aujourd'hui](https://gitlab.com/-/trials/new?glm_content=default-saas-trial&glm_source=about.gitlab.com%2Fblog%2F) pour améliorer considérablement l'efficacité de votre workflow, à chaque étape du cycle de développement logiciel. Ce duo améliore la productivité, la fréquence des déploiements, la qualité du code et la sécurité dans son ensemble, ainsi que la résilience et la disponibilité de l'environnement de production. \n\nPour voir un workflow en action qui combine GitLab Flow et GitLab Duo, et découvrir ses avantages, regardez la vidéo suivante :\n\n\u003C!-- blank line -->\n\u003Cfigure class=\"video_container\">\n  \u003Ciframe src=\"https://www.youtube.com/embed/CKrZ4_tKY4I?si=Kf6QsYFIzKkJZpJd\" frameborder=\"0\" allowfullscreen=\"true\"> \u003C/iframe>\n\u003C/figure>\n\u003C!-- blank line -->\n","ai-ml",[9,858,859],"AI/ML","DevSecOps","2025-04-03",{"slug":862,"featured":6,"template":691},"gitlab-flow-duo","content:fr-fr:blog:gitlab-flow-duo.yml","Gitlab Flow Duo","fr-fr/blog/gitlab-flow-duo.yml","fr-fr/blog/gitlab-flow-duo",{"_path":868,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":869,"content":872,"config":883,"_id":885,"_type":14,"title":886,"_source":16,"_file":887,"_stem":888,"_extension":19},"/fr-fr/blog/gitlab-ultimate-for-ibm-z-modern-devsecops-for-mainframes",{"noIndex":6,"description":870,"title":871},"Découvrez comment l'intégration d'IBM à GitLab allie développement sur mainframe et cloud-native. ","GitLab Ultimate pour IBM Z : DevSecOps moderne sur mainframe",{"heroImage":873,"body":874,"authors":875,"updatedDate":878,"date":879,"title":880,"tags":881,"description":882,"category":686},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1750440008/myqt5vcjlffh8sszw507.png","GitLab et IBM unissent leurs forces pour moderniser le développement logiciel sur mainframe. Ce partenariat permet aux équipes de développement mainframe de bénéficier des mêmes outils modernes, workflows et fonctionnalités collaboratives que ceux utilisés dans les environnements distribués. Baptisée GitLab Ultimate pour IBM Z, cette solution d'automatisation DevSecOps intégrée et certifiée par GitLab, adaptée à l'environnement mainframe, relève ce défi. Elle permet aux entreprises de moderniser leurs workflows de développement mainframe grâce à une migration sans accroc depuis les gestionnaires de bibliothèques hérités obsolètes. Avec des pipelines CI/CD exécutés de façon native sur IBM z/OS, ces entreprises sont en mesure d'innover plus rapidement et de réduire les coûts opérationnels.\n\n## Les défis actuels du développement sur mainframe\n\nLes entreprises qui utilisent les systèmes IBM Z pour leurs charges de travail critiques sont confrontées à des défis que les outils DevSecOps classiques ne sont pas en mesure de relever. Tandis que les équipes [cloud-native](https://about.gitlab.com/fr-fr/topics/cloud-native/ \"Qu'est-ce que cloud-native ?\") bénéficient de pipelines [CI/CD](https://about.gitlab.com/topics/ci-cd/) modernes, d'un développement collaboratif fluide et de tests automatisés, les équipes mainframe restent souvent confinées à des outils obsolètes, source d'inefficacités coûteuses et de silos opérationnels.\n\nElles ont souvent recours à des solutions de contournement, telles que les connexions SSH et les transferts manuels de fichiers, qui fragilisent la sécurité et complexifient les audits. Or, dans un contexte de conformité de plus en plus exigeant, ces pratiques improvisées s’exposent à des risques inacceptables. Par ailleurs, les entreprises maintiennent des chaînes d'outils parallèles coûteuses, reposant sur des outils de développement mainframe hérités aux coûts de licence élevés et aux fonctionnalités limitées par rapport aux alternatives modernes.\n\nCette fragmentation crée deux problèmes : des cycles de livraison de logiciels plus lents et une difficulté à attirer des développeurs, qui recherchent des environnements de travail modernes.\n\n> **« GitLab Ultimate pour IBM Z représente une avancée décisive pour résoudre une problématique à laquelle le secteur doit faire face depuis longtemps. D'après les recherches menées par IDC, les équipes de développement mainframe s'appuient encore largement sur des outils hérités qui contribuent à freiner les livraisons et compliquent l'acquisition de nouveaux talents. Avec cette offre conjointe, les fonctionnalités DevSecOps modernes et les workflows unifiés sont intégrés directement au mainframe. Résultat : une collaboration plus fluide et plus efficace pour les équipes de développement, et une accélération de l'innovation pour les entreprises, qui peuvent ainsi totalement intégrer le développement mainframe à leurs stratégies globales de transformation digitale. »** - Katie Norton, Research Manager, DevSecOps and Software Supply Chain Security chez IDC\n\n## Vers des environnements de développement unifiés\n\nUne véritable modernisation du développement mainframe nécessite de concevoir une plateforme unifiée où les équipes mainframe, cloud-native, web et mobile collaborent en harmonie. \n\nGitLab Ultimate pour IBM Z permet aux équipes de développement d'utiliser des workflows cohérents, qu'ils déploient sur z/OS, dans le cloud ou sur une infrastructure locale. Les connaissances sont ainsi transférées entre les équipes au lieu de rester cloisonnées. Les entreprises peuvent ainsi moderniser leurs pratiques progressivement, à leur propre rythme, sans interrompre leurs activités, car les systèmes hérités continuent de fonctionner.\n\nÀ l'heure où les architectures hybrides mêlant mainframe et développement cloud-native deviennent la norme, GitLab fournit une base robuste pour développer des applications entre ces différents environnements.\n\n## Qu'est-ce que GitLab Ultimate pour IBM Z ?\n\nGitLab Ultimate pour IBM Z offre une prise en charge native des runners sur z/OS et permet ainsi une exécution fluide et sécurisée de vos [pipelines CI/CD](https://about.gitlab.com/fr-fr/topics/ci-cd/cicd-pipeline/ \"Qu'est-ce qu'un pipeline CI/CD?\") directement sur votre infrastructure mainframe. Cette solution certifiée par GitLab supprime le besoin de solutions de contournement complexes tout en maintenant la sécurité et la fiabilité que vos applications exigent. \n\nEn combinant la plateforme DevSecOps complète de GitLab avec l'expertise approfondie d'IBM en matière de mainframe, cette offre unique et certifiée connecte les systèmes hérités aux pratiques d'innovation cloud-native.\n\n## Quelles fonctionnalités offre GitLab Ultimate pour IBM Z ?\n\nGitLab Ultimate pour IBM Z fournit aux équipes de développement les outils dont elles ont besoin pour moderniser le développement mainframe tout en préservant la continuité des systèmes métier critiques. \n\nVoici les principales fonctionnalités de cette solution intégrée :\n\n**La prise en charge native des runners sur z/OS** : les pipelines CI/CD s'exécutent directement sur votre mainframe. Cette approche réduit les risques de sécurité et les goulots d'étranglement d'évolutivité associés aux connexions distantes, tout en accélérant les déploiements et les livraisons.\n\n**La gestion unifiée du code source** : votre chaîne d'outils est modernisée en remplaçant les outils de gestion de bibliothèques hérités coûteux par le système de dépôt consultable et le [contrôle de version](https://about.gitlab.com/fr-fr/topics/version-control/ \"Qu'est-ce que le contrôle de version ?\") de GitLab. Ainsi, vos coûts de licence et frais de maintenance sont réduits.\n\n**L'intégration fluide** avec IBM Developer for z/OS Enterprise Edition (IDzEE) : les cycles de livraison sont accélérés grâce à des compilations basées sur les dépendances, à une analyse automatique du code et à des outils de débogage complets, directement accessibles dans les environnements de développement habituels. Le tout améliore à la fois la qualité du code et la sécurité des applications, sans perturber les habitudes des équipes. \n\n**La visibilité complète** sur les environnements mainframe et distribués : une gestion complète des projets, de la planification à la production, permet d'automatiser les workflows DevOps et améliore l'expérience développeur grâce à des outils de développement modernes de nouvelle génération.\n\n## Modernisez votre environnement de développement mainframe dès aujourd'hui\n\nGitLab Ultimate pour IBM Z est désormais disponible pour les entreprises prêtes à transformer leur expérience de développement mainframe. Pour en savoir plus, consultez la [page dédiée au partenariat entre GitLab et IBM](https://about.gitlab.com/fr-fr/partners/technology-partners/ibm/).",[876,877],"Mike Flouton","Andy Bradfield","2025-06-30","2025-06-20","GitLab Ultimate pour IBM Z : le DevSecOps moderne sur mainframe",[284,686,9,859],"Découvrez comment l'intégration d'IBM à GitLab allie développement sur mainframe et cloud-native, avec prise en charge des runners CI/CD, visibilité complète et coûts réduits.",{"featured":91,"template":691,"slug":884},"gitlab-ultimate-for-ibm-z-modern-devsecops-for-mainframes","content:fr-fr:blog:gitlab-ultimate-for-ibm-z-modern-devsecops-for-mainframes.yml","Gitlab Ultimate For Ibm Z Modern Devsecops For Mainframes","fr-fr/blog/gitlab-ultimate-for-ibm-z-modern-devsecops-for-mainframes.yml","fr-fr/blog/gitlab-ultimate-for-ibm-z-modern-devsecops-for-mainframes",{"_path":890,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":891,"content":897,"config":907,"_id":909,"_type":14,"title":910,"_source":16,"_file":911,"_stem":912,"_extension":19},"/fr-fr/blog/how-indeed-transformed-its-ci-platform-with-gitlab",{"title":892,"description":893,"ogTitle":892,"ogDescription":893,"noIndex":6,"ogImage":894,"ogUrl":895,"ogSiteName":673,"ogType":674,"canonicalUrls":895,"schema":896},"Comment Indeed a transformé sa plateforme CI avec GitLab","Indeed a migré des milliers de projets vers le système d'intégration continue (CI) de GitLab, ce qui lui a permis de booster sa productivité et de réduire ses coûts.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1750099351/Blog/Hero%20Images/Blog/Hero%20Images/Indeed-blog-cover-image-2_4AgA1DkWLtHwBlFGvMffbC_1750099350771.png","https://about.gitlab.com/blog/how-indeed-transformed-its-ci-platform-with-gitlab","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Comment Indeed a transformé sa plateforme CI avec GitLab\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Carl Myers\"}],\n        \"datePublished\": \"2024-08-27\",\n      }",{"title":892,"description":893,"authors":898,"heroImage":894,"date":900,"body":901,"category":902,"tags":903,"updatedDate":906},[899],"Carl Myers","2024-08-27","***Cet article a été traduit. Retrouvez la version originale sur [notre blog anglais](https://about.gitlab.com/blog/how-indeed-transformed-its-ci-platform-with-gitlab/ \"Blog anglais de GitLab\").***\n\n***Note de la rédaction : nous invitons parfois les membres de notre communauté de clients à contribuer au blog de GitLab. Nous remercions aujourd'hui Carl Myers, responsable des plateformes CI chez Indeed, de nous avoir fait part de son expérience avec GitLab.***\n\nChez Indeed, notre mission est d'aider chacun à trouver un emploi. Indeed est le [plus grand site d'offres d'emploi](https://www.indeed.com/about?isid=press_us&ikw=press_us_press%2Freleases%2Faward-winning-actress-viola-davis-to-keynote-indeed-futureworks-2023_textlink_https%3A%2F%2Fwww.indeed.com%2Fabout) au monde, accueillant plus de 350 millions de visiteurs uniques chaque mois.\n\nDu côté des équipes de plateforme d'ingénierie d'Indeed, la devise est légèrement différente : « Nous aidons ceux qui aident chacun à trouver un emploi ». Depuis près de vingt ans, les chercheurs d'emploi sont au cœur de notre culture d'ingénierie fondée sur les données. Dans ce contexte, notre responsabilité est de créer des outils qui non seulement facilitent cet objectif, mais qui permettent également aux ingénieurs d'offrir chaque jour des opportunités aux candidats.\n\nL'[intégration continue](https://about.gitlab.com/fr-fr/topics/ci-cd/benefits-continuous-integration/ \"Qu'est-ce que l'intégration continue (CI) ?\") de GitLab a permis à l'équipe de plateforme CI d'Indeed, composée de seulement 11 personnes, d'accompagner efficacement des milliers d'utilisateurs dans toute l'entreprise. Indeed a également constaté d'autres avantages, avec notamment :\n- une augmentation des pipelines quotidiens de 79 %\n- une réduction de 10 à 20 % des coûts de matériel de CI\n- une diminution des demandes d'assistance\n\n## L'évolution de notre plateforme CI : de Jenkins vers une solution évolutive\n\nComme de nombreuses grandes entreprises dans le domaine technologique, nous avons construit notre plateforme CI de manière organique, au fil de l'évolution de l'entreprise, en faisant appel aux solutions open source et standard qui étaient disponibles à l’époque. En 2007, lorsque Indeed comptait moins de 20 ingénieurs, nous utilisions Hudson, le prédécesseur direct de Jenkins.\n\nUne vingtaine d'années plus tard, nous employons aujourd'hui des milliers d'ingénieurs. Nous avons progressivement amélioré nos outils au fil de l'arrivée de nouvelles technologies, notamment en passant à Jenkins vers 2011. Une autre avancée nous a permis de déplacer la plupart de nos charges de travail vers des nœuds de travail cloud dynamiques grâce à [AWS EC2](https://aws.amazon.com/ec2/). Il est toutefois devenu évident que l'architecture de notre système avait atteint ses limites lorsque nous sommes entrés dans l'ère de [Kubernetes](https://about.gitlab.com/fr-fr/blog/kubernetes-the-container-orchestration-solution/ \"Qu'est-ce que Kubernetes ?\").\n\nL'architecture de Jenkins n'est en effet pas conçue pour le cloud. Le fonctionnement de Jenkins repose sur un nœud « contrôleur », un point de défaillance unique qui exécute les parties critiques d'un pipeline et décharge certaines étapes vers les nœuds de travail (qui peuvent évoluer horizontalement dans une certaine mesure). Les contrôleurs constituent également un axe de mise à l'échelle manuelle.\n\nSi vos tâches sont trop nombreuses pour un contrôleur donné, elles doivent être partitionnées manuellement entre plusieurs contrôleurs. CloudBees propose des solutions pour contourner ce problème, notamment avec le CloudBees Jenkins Operations Center qui vous permet de gérer votre constellation de contrôleurs depuis un seul endroit centralisé. Cependant, les contrôleurs restent difficiles à exécuter dans un environnement Kubernetes, car chaque contrôleur est un point de défaillance unique et fragile. Des activités telles que les déploiements de nœuds ou des défaillances matérielles peuvent ainsi entraîner des temps d'arrêt.\n\nAu-delà des limitations techniques inhérentes à Jenkins, notre plateforme CI a également rencontré des problèmes dont nous étions malheureusement à l'origine. Par exemple, nous avons utilisé le DSL Groovy de Jenkins pour générer des jobs à partir du code contenu dans chaque dépôt. Chaque projet s'est ainsi retrouvé avec un pipeline individuel de jobs copiés, ce qui a engendré des centaines de versions difficiles à maintenir et à mettre à jour. Bien que la culture d'ingénierie d'Indeed encourage la flexibilité et permette aux équipes de travailler dans des dépôts distincts, cette flexibilité était devenue un fardeau, car les équipes consacraient trop de temps à répondre aux demandes de maintenance régulières.\n\nAyant pris conscience de cette dette technique, nous nous sommes tournés vers le [modèle « Golden Path »](https://tag-app-delivery.cncf.io/whitepapers/platforms/), qui permet une certaine flexibilité tout en offrant une méthode par défaut pour simplifier les mises à jour et encourager des pratiques cohérentes dans tous les projets.\n\nL'équipe de plateforme CI d'Indeed est relativement petite. Nous comptons environ 11 ingénieurs qui gèrent des milliers d'utilisateurs, répondent aux demandes d'assistance, effectuent des mises à niveau et des opérations de maintenance, et offrent une assistance constante à notre entreprise mondiale.\n\nComme notre équipe prend en charge non seulement notre instance GitLab, mais également l'ensemble de la plateforme CI, y compris le serveur d'artefacts, notre code de compilation partagé et de multiples autres composants personnalisés de notre plateforme, nous avions énormément de travail. Nous avions besoin d'une solution qui nous aiderait à résoudre nos problèmes tout en exploitant au maximum nos ressources existantes.\n\n## Notre migration vers GitLab CI\n\nAprès un examen minutieux de sa conception avec les principales parties prenantes, nous avons décidé de migrer l'ensemble de l'entreprise de Jenkins vers le système d'intégration continue de GitLab. \n\nNos principales raisons étaient les suivantes :\n- Nous utilisions déjà GitLab pour la gestion du code source.\n- GitLab est une offre complète qui fournit tout ce dont nous avons besoin pour l'intégration continue.\n- GitLab CI est conçu pour l'évolutivité et le cloud.\n- GitLab CI nous permet de générer des modèles qui élargissent d'autres modèles, ce qui est compatible avec notre stratégie « Golden Path ».\n- GitLab est un logiciel open source et l'équipe de GitLab nous a toujours aidés à soumettre des correctifs, ce qui nous offre davantage de flexibilité et renforce notre confiance.\n\nAu moment de notre annonce officielle de la disponibilité de la plateforme CI de GitLab pour tous les utilisateurs, 23 % de l'ensemble des compilations étaient déjà effectuées dans le système d'intégration continue de GitLab.\n\nNotre plus grand défi lors de cette migration était que « le diable se niche dans les détails ». Du fait du nombre de compilations personnalisées présentes dans Jenkins, nous savions qu'un outil de migration automatisé ne fonctionnerait pas pour la majorité des équipes. Or, la plupart des avantages du nouveau système ne seraient concrétisés qu'une fois l'ancien système complètement abandonné. Ce n'est qu'alors que nous pourrions cesser d'utiliser le matériel et économiser les frais de licence CloudBees.\n\n## La parité des fonctionnalités et les avantages de repartir à zéro \n\nIndeed utilise de nombreuses technologies différentes, mais les trois langages les plus courants sont Java, Python et JavaScript. Ces piles technologiques de langages sont utilisées pour créer des bibliothèques, des déployables (services Web ou applications) et des tâches cron (un processus qui s'exécute à intervalles réguliers, par exemple pour créer un ensemble de données dans notre lac de données). Chacune de ces piles correspondait à un type de projet spécifique (par ex. Java Library, Python Cronjob, JavaScript Webapp, etc.) avec une configuration de base dans Jenkins. Par conséquent, nous avons dû générer un modèle « Golden Path » dans le système d'intégration continue de GitLab pour chacun de ces types de projets.\n\nLa plupart des utilisateurs pouvaient utiliser ces modèles recommandés tels quels. Pour ceux qui avaient besoin de les personnaliser, le « Golden Path » constituait un point de départ utile leur permettant de modifier uniquement les aspects nécessaires, tout en bénéficiant de mises à jour de modèles centralisées à l'avenir.\n\nNous avons rapidement constaté que la plupart des utilisateurs, même ceux qui avaient besoin de personnaliser certains aspects de leur projet, étaient tout à fait disposés à adopter ce modèle et à l'essayer. S'ils s'apercevaient que certaines de leurs personnalisations n'étaient pas incluses dans le modèle, ils savaient qu'ils pouvaient toujours les ajouter ultérieurement. C'était un résultat surprenant ! Nous pensions en effet que les équipes qui avaient investi dans des personnalisations importantes seraient réticentes à l'idée de les abandonner. Or, dans la majorité des cas, les équipes ne s'en souciaient tout simplement plus. Cela nous a permis de migrer de nombreux projets très rapidement : il suffisait en effet de déposer notre « Golden Path » (un petit fichier d'environ 6 lignes avec des inclusions) dans leur projet pour que chaque équipe puisse s'occuper du reste.\n\n## L'innersource à la rescousse\n\nL'équipe de plateforme CI a également adopté une politique de « priorité aux contributions externes » pour encourager la participation de tous les membres de l'entreprise. C'est ce qu'on appelle parfois l'[innersource](https://about.gitlab.com/fr-fr/topics/version-control/what-is-innersource/ \"Qu'est-ce que l'innersource ?\"). Nous avons créé des tests et une documentation pour encourager les contributions externes (c'est-à-dire externes à notre équipe immédiate). Les équipes qui souhaitaient créer des personnalisations pouvaient ainsi les ajouter au « Golden Path » tout en les activant ou désactivant à l'aide d'un feature flag. Cette approche a encouragé une meilleure collaboration et un plus grand respect des personnalisations (parce que celles-ci faisaient désormais partie du code base commun). \n\nAutre avantage : les équipes qui attendaient désespérément une fonctionnalité dont elles avaient besoin pouvaient désormais la créer elles-mêmes. Nous pouvons désormais leur donner le choix : « Oui, nous prévoyons de mettre en œuvre cette fonctionnalité dans quelques semaines, mais si vous en avez besoin plus tôt, nous serions ravis d'accepter une contribution ». Au final, de nombreuses fonctionnalités de base nécessaires à la parité ont été développées de cette manière, plus rapidement et mieux que nos ressources ne le permettaient. La migration n'aurait pas été un succès sans ce modèle.\n\n## En avance sur le calendrier et en dessous du budget\n\nNotre licence CloudBees arrivait à expiration le 1er avril 2024. Nous avons donc fixé cette date comme date d'achèvement de la migration. Cette échéance était particulièrement ambitieuse, car, à l'époque, 80 % de l'ensemble des compilations (soit 60 % de tous les projets) utilisaient encore Jenkins pour le processus d'intégration continue. Plus de 2 000 [fichiers Jenkins (Jenkinsfiles)](https://www.jenkins.io/doc/book/pipeline/jenkinsfile/) devaient donc encore être recréés ou remplacés par nos modèles « Golden Path ».\n\nPour atteindre cet objectif, nous avons mis à disposition des équipes une documentation et des exemples, ajouté des fonctionnalités dans la mesure du possible et aidé nos utilisateurs à offrir des contributions quand ils le pouvaient.\n\nNous avons mis en place des permanences régulières, durant lesquelles tous les utilisateurs pouvaient nous poser des questions ou demander notre aide pour migrer. Nous avons également donné la priorité aux questions d'assistance relatives à la migration. Certains membres de notre équipe sont devenus des experts du système d'intégration continue de GitLab et ont partagé leur expertise avec le reste de l'équipe et toute l'entreprise.\n\nLa migration automatique n'était pas adaptée à la plupart des projets, mais nous avons découvert qu'elle pouvait fonctionner pour un petit sous-ensemble de projets où les personnalisations étaient rares. Nous avons créé une campagne de changement par lots Sourcegraph afin de soumettre des merge requests pour migrer des centaines de projets et, avons convaincu les utilisateurs à accepter ces merge requests.\n\nNous avons également partagé des exemples de réussite notables avec toutes les équipes. Comme les utilisateurs ajoutaient de nouvelles fonctionnalités à nos modèles « Golden Path », nous avons annoncé que ces fonctionnalités seraient ajoutées « gratuitement » lors de la migration vers [GitLab CI](https://about.gitlab.com/fr-fr/blog/ci-deployment-and-environments/ \"Comment déployer du code dans des environnements multiples avec GitLab CI\"). Ces fonctionnalités comportaient entre autres un scan de sécurité et de conformité intégré, des notifications Slack pour les compilations CI et des intégrations avec d'autres systèmes internes.\n\nNous avons également mené une campagne de tests agressifs. Dans ce cadre, nous avons automatiquement désactivé les jobs Jenkins qui n'avaient pas été exécutés ou qui n'avaient pas abouti depuis un certain temps, en disant aux utilisateurs que s'ils en avaient besoin, ils pouvaient les réactiver. C'est un moyen simple d'identifier les jobs qui sont réellement nécessaires. Nous avons ainsi identifié des milliers de jobs qui n'avaient pas été exécutés une seule fois depuis notre dernière migration CI (de Jenkins vers Jenkins). Nous en avons déduit que nous pouvions ignorer la vaste majorité de ces jobs sans aucun risque.\n\nEn janvier 2024, nous avons annoncé que tous les contrôleurs Jenkins passeraient en lecture seule (sans compilation) à moins qu'une exception ne soit explicitement demandée par les utilisateurs. La propriété des contrôleurs était mieux connue et ils s'alignaient généralement sur la structure de notre entreprise. Il était donc logique de se concentrer sur les contrôleurs plutôt que sur les jobs. De plus, la liste des contrôleurs était beaucoup plus gérable que celle des jobs.\n\nPour obtenir une exception, les utilisateurs devaient identifier leurs contrôleurs dans une feuille de calcul, puis saisir leurs coordonnées à côté de chacun d'eux. Nous avons ainsi pu obtenir une liste à jour et fiable des parties prenantes avec lesquelles nous pouvions effectuer un suivi à mesure que la migration progressait, mais cela a également permis aux utilisateurs d'indiquer clairement les jobs dont ils avaient absolument besoin. Nous sommes passés d'environ 400 contrôleurs à 220 au mois de janvier, mais seuls 54 contrôleurs ont nécessité des exceptions (et parmi ces contrôleurs, plusieurs appartenaient à notre équipe pour exécuter nos tests et déploiements canari)).\n\n![Indeed - Graphique de recensement des contrôleurs Jenkins](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750099357/Blog/Content%20Images/Blog/Content%20Images/image2_aHR0cHM6_1750099357392.png)\n\nNous avions donc une liste gérable d'environ 50 équipes et chaque membre de notre équipe a été chargé d'en contacter un certain nombre pour évaluer leurs progrès dans le cadre de la migration. Nous avons consacré les mois de janvier et février à cette tâche et découvert que certaines équipes prévoyaient de terminer leur migration sans notre aide avant le 28 février. D'autres prévoyaient de mettre fin à leurs projets existants avant cette date, et seule une petite minorité pensait rencontrer des difficultés.\n\nNous avons pu travailler avec ce petit groupe d'équipes pour leur offrir un niveau d'accompagnement très personnalisé. Nous leur avons expliqué que nous ne disposions pas de l'expertise nécessaire pour effectuer la migration à leur place, mais que nous pouvions collaborer avec un expert métier de leur équipe. Dans certains cas, nous avons écrit le code et l'équipe s'est chargée de la revue de code, ou vice-versa. Au final, tout notre travail a porté ses fruits et nous avons pu désactiver Jenkins à la date que nous avions annoncée 8 mois plus tôt.\n\n## Résultats : une intégration continue plus efficace et des utilisateurs plus satisfaits\n\nÀ son apogée, notre plateforme CI Jenkins permettait d'exécuter plus de 14 000 pipelines par jour et de réaliser des milliers de projets. Aujourd'hui, notre plateforme CI GitLab exécute régulièrement plus de 25 000 pipelines par jour, mais peut en traiter plus de 40 000 en une seule journée. Le coût différentiel de chaque job dans chaque pipeline est similaire à celui de Jenkins, mais sans les coûts indirects du matériel nécessaire au fonctionnement des contrôleurs. De plus, ces contrôleurs agissaient comme des points de défaillance uniques et des limiteurs de mise à l'échelle, ce qui nous obligeait à diviser artificiellement notre plateforme en segments. Bien qu'une comparaison directe soit difficile, nous constatons que l'élimination de ces frais généraux permet de réduire nos coûts de matériel d'intégration continue de 10 à 20 %. En outre, la charge d'assistance de GitLab CI est bien moindre, car l'application évolue automatiquement dans le cloud et offre une résilience interzone, et le langage utilisé pour la génération de modèles s'accompagne d'une excellente documentation publique.\n\nUn avantage tout aussi important, sinon plus, est que nous sommes maintenant à plus de 70 % d'adoption de nos modèles « Golden Path ». Cela signifie que lorsque nous déployons une amélioration, plus de 5 000 projets en bénéficient immédiatement sans qu'aucune action ne soit requise de la part des équipes d'Indeed. Nous avons ainsi pu déplacer certains jobs vers des instances ARM64 plus rentables, mettre à jour plus facilement les images de compilation des utilisateurs et mieux gérer d'autres opportunités de réduction des coûts. Et le résultat dont nous sommes le plus fiers ? Nos utilisateurs sont plus satisfaits grâce à la nouvelle plateforme.\n\n__À propos de l'auteur :__\n*Carl Myers vit à Sacramento, en Californie, et est le responsable de l'équipe de plateforme CI d'Indeed. Depuis près de vingt ans, Carl crée des outils internes et des plateformes de développement pour le bonheur d'ingénieurs d'entreprises de toutes tailles.*\n\n**Remerciements :**\n*Cette migration n'aurait pas été possible sans le travail inlassable de Tron Nedelea, Eddie Huang, Vivek Nynaru, Carlos Gonzalez, Lane Van Elderen et de toute l'équipe de plateforme CI. L'équipe souhaite également remercier Deepak Bitragunta et Irina Tyree, dont le leadership a permis de garantir les ressources, l'adhésion et la cohérence à l'échelle de l'entreprise qui étaient nécessaires tout au long de ce long projet. Enfin, nous remercions tous les membres d'Indeed qui ont contribué au code, aux retours d'expérience, aux rapports de bogues et à la migration des projets.*\n\n**Ce texte est une version modifiée de l'article « [How Indeed Replaced Its CI Platform with Gitlab CI](https://engineering.indeedblog.com/blog/2024/08/indeed-gitlab-ci-migration/) », publié à l'origine sur le blog dédié à l'ingénierie d'Indeed.**","customer-stories",[904,9,905,685],"customers","user stories","2024-12-18",{"slug":908,"featured":91,"template":691},"how-indeed-transformed-its-ci-platform-with-gitlab","content:fr-fr:blog:how-indeed-transformed-its-ci-platform-with-gitlab.yml","How Indeed Transformed Its Ci Platform With Gitlab","fr-fr/blog/how-indeed-transformed-its-ci-platform-with-gitlab.yml","fr-fr/blog/how-indeed-transformed-its-ci-platform-with-gitlab",{"_path":914,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":915,"content":921,"config":929,"_id":931,"_type":14,"title":932,"_source":16,"_file":933,"_stem":934,"_extension":19},"/fr-fr/blog/how-to-deploy-react-to-amazon-s3",{"title":916,"description":917,"ogTitle":916,"ogDescription":917,"noIndex":6,"ogImage":918,"ogUrl":919,"ogSiteName":673,"ogType":674,"canonicalUrls":919,"schema":920},"Comment déployer une application React sur Amazon S3 avec GitLab CI/CD","Vous souhaitez déployer une application React sur Amazon S3 avec GitLab CI/CD ? Suivez notre guide étape par étape.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749663291/Blog/Hero%20Images/cover1.jpg","https://about.gitlab.com/blog/how-to-deploy-react-to-amazon-s3","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Comment déployer une application React sur Amazon S3 avec GitLab CI/CD\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Jeremy Wagner\"}],\n        \"datePublished\": \"2023-03-01\",\n      }",{"title":916,"description":917,"authors":922,"heroImage":918,"date":924,"body":925,"category":681,"tags":926,"updatedDate":928},[923],"Jeremy Wagner","2023-03-01","Amazon S3 dispose d'une fonctionnalité d'hébergement qui vous permet\nd'héberger un site Web statique directement à partir d'un bucket S3,\négalement appelé compartiment. Lorsque vous hébergez votre site Web sur\nAmazon S3, son contenu est stocké dans un bucket S3 et servi directement à\nvos utilisateurs, sans besoin de ressources supplémentaires. \n\n\nCombinez cela avec Amazon CloudFront et vous obtiendrez une solution\nrentable et évolutive pour l'hébergement de vos sites Web statiques. Une\nfonctionnalité particulièrement utile pour les applications à page unique.\n\n\nDans cet article, nous vous guidons dans la configuration de votre bucket\nAmazon S3, la configuration d'OpenID Connect\n([OIDC](https://openid.net/developers/how-connect-works/ \"OpenID Connect\"))\ndans AWS et le déploiement de votre application sur Amazon S3 à l'aide d'un\npipeline GitLab [CI/CD](https://about.gitlab.com/fr-fr/topics/ci-cd/\n\"Qu'est-ce que le CI/CD ?\").\n\n\nÀ la fin de cet article, vous disposerez d'un [pipeline\nCI/CD](https://about.gitlab.com/fr-fr/topics/ci-cd/cicd-pipeline/ \"Qu'est-ce\nqu'un pipeline CI/CD ?\") construit dans GitLab qui se déploie\nautomatiquement dans votre bucket Amazon S3. \n\n\n## Prérequis\n\n\nPour ce guide, vous aurez besoin des éléments suivants :\n\n\n- [Node.js](https://nodejs.org/fr) >= 14.0.0 et npm >= 5.6 installés sur\nvotre système\n\n- [Git](https://git-scm.com/) installé sur votre système\n\n- Un [compte GitLab](https://gitlab.com/-/trials/new)\n\n- Un [compte AWS](https://aws.amazon.com/fr/free/)\n\n\nDans un [précédent\ntutoriel](https://about.gitlab.com/blog/how-to-automate-testing-for-a-react-application-with-gitlab/)\nnous vous avons expliqué comment : \n\n- créer une nouvelle application React,\n\n- exécuter des tests unitaires dans le cadre du processus CI dans GitLab,\n\n- générer les résultats des tests ainsi que la couverture de code dans le\npipeline.\n\n\nCet article constitue la [suite de ce\nprojet](https://gitlab.com/guided-explorations/engineering-tutorials/react-unit-testing).\nLibre à vous de le parcourir et de le dupliquer (fork). \n\n\n## Configuration de votre bucket S3 \n\n\nPour commencer, vous devez configurer votre bucket Amazon S3. \n\n\n### Créez votre compartiment\n\n\nAprès vous être connecté à votre compte AWS, recherchez « S3 » à l'aide de\nla barre de recherche et sélectionnez le service S3. Cela ouvrira la page\nd'accueil du service.\n\n\nVous devriez immédiatement voir l'option permettant de créer un bucket\n(compartiment). Ce compartiment est l'endroit où vous allez stocker votre\napplication React une fois créée. Cliquez sur le bouton « Créer un\ncompartiment » pour continuer.\n\n\n![Création d'un bucket\nS3](https://about.gitlab.com/images/blogimages/2023-02-10-how-to-deploy-react-to-amazon-s3/create_bucket.png){:\n.shadow}\n\n\nDonnez un nom à votre compartiment, sélectionnez votre région, laissez le\nreste des paramètres par défaut (nous y reviendrons plus tard) et continuez\nen cliquant sur le bouton « Créer un compartiment ». \n\n\nLorsque vous nommez votre compartiment, il est important de se rappeler que\nle nom doit être unique et suivre les règles de nommage des compartiments.\nNous avons nommé le nôtre `jw-gl-react`.\n\n\nUne fois votre compartiment créé, vous devriez être redirigé vers une liste\nde vos compartiments, comme montré ci-dessous. \n\n\n![Liste bucket S3\nAWS](https://about.gitlab.com/images/blogimages/2023-02-10-how-to-deploy-react-to-amazon-s3/bucket_list.png){:\n.shadow}\n\n\n### Configurez l'hébergement de site web statique \n\n\nL'étape suivante consiste à configurer l'hébergement de site web statique.\nOuvrez votre compartiment en cliquant sur son nom. Sélectionnez l'onglet «\nPropriétés »  et faites défiler vers le bas pour trouver l'option\nd'hébergement de site web statique.\n\n\n![Configuration de l'hébergement de site web\nstatique](https://about.gitlab.com/images/blogimages/2023-02-10-how-to-deploy-react-to-amazon-s3/static_hosting_1.png){:\n.shadow}\n\n\nCliquez sur « Modifier », puis activez l'hébergement de site web statique.\nPour les documents d’index et d’erreur, saisissez `index.html`, puis cliquez\nsur « Enregistrer les modifications ».\n\n\n![Activation de l'hébergement de site web statique sur Amazon\nS3](https://about.gitlab.com/images/blogimages/2023-02-10-how-to-deploy-react-to-amazon-s3/static_hosting_2.png){:\n.shadow}\n\n\n### Configurez les autorisations de votre application React\n\n\nMaintenant que vous avez activé l'hébergement de site web statique, vous\ndevez mettre à jour vos autorisations afin que votre audience puisse accéder\nà votre site web. Revenez à votre compartiment et sélectionnez l'onglet «\nAutorisations ».\n\n\nSous « Bloquer l'accès public » (paramètres du compartiment), cliquez sur «\nModifier », décochez « Bloquer tous les accès publics » et continuez en\ncliquant sur « Enregistrer les modifications ».\n\n\n![Bloquer l'accès\npublic](https://about.gitlab.com/images/blogimages/2023-02-10-how-to-deploy-react-to-amazon-s3/block_access_1.png){:\n.shadow}\n\n\nVotre page devrait maintenant ressembler à ceci : \n\n\n![Configurer permission bucket S3\nAWS](https://about.gitlab.com/images/blogimages/2023-02-10-how-to-deploy-react-to-amazon-s3/block_access_2.png){:\n.shadow}\n\n\nMaintenant, vous devez modifier la stratégie de compartiment. Pour cela,\ncliquez sur le bouton « Modifier » dans la section « Stratégie de\ncompartiment » et collez le code suivant :\n\n\n```javascript\n\n{\n    \"Version\": \"2012-10-17\",\n    \"Statement\": [\n        {\n            \"Sid\": \"PublicReadGetObject\",\n            \"Effect\": \"Allow\",\n            \"Principal\": \"*\",\n            \"Action\": \"s3:GetObject\",\n            \"Resource\": \"arn:aws:s3:::jw-gl-react/*\"\n        }\n    ]\n}\n\n```\n\n\nÀ la ligne « Ressource », remplacez `jw-gl-react`  par le nom de votre\ncompartiment et enregistrez les modifications.\n\n\nVotre compartiment devrait ressembler à ceci : \n\n\n![Bucket S3 accès\npublic](https://about.gitlab.com/images/blogimages/2023-02-10-how-to-deploy-react-to-amazon-s3/block_access_3.png){:\n.shadow}\n\n\n## Chargement de votre application React\n\n\nMaintenant, créons votre application React et publions-la manuellement dans\nvotre bucket S3.\n\n\nPour créer l'application, assurez-vous que votre projet soit cloné sur votre\nmachine locale et exécutez la commande suivante dans votre terminal à\nl'intérieur du répertoire de votre dépôt :\n\n\n```\n\nnpm run build\n\n```\n\nCela créera un dossier `build` à l'intérieur du répertoire de votre dépôt. \n\n\nDans votre compartiment, cliquez sur le bouton « Charger »\n\n\n![Chargement de l'application\nReact](https://about.gitlab.com/images/blogimages/2023-02-10-how-to-deploy-react-to-amazon-s3/upload_1.png){:\n.shadow}\n\n\nFaites glisser le contenu de votre dossier nouvellement créé (et non le\ndossier lui-même) dans la zone de chargement. Cela chargera le contenu de\nvotre application React dans votre compartiment. Assurez-vous de cliquer sur\n« Charger » en bas de la page pour démarrer le chargement.\n\n\nRevenez maintenant à l'onglet « Propriétés » de votre compartiment et faites\ndéfiler vers le bas pour trouver l'URL de votre site web statique.\n\n\n![URL du site web\nstatique](https://about.gitlab.com/images/blogimages/2023-02-10-how-to-deploy-react-to-amazon-s3/upload_2.png){:\n.shadow}\n\n\nCliquez sur le lien et vous devriez voir votre application React\nnouvellement créée s'ouvrir dans votre navigateur.\n\n\n![Application React\ndéployée](https://about.gitlab.com/images/blogimages/2023-02-10-how-to-deploy-react-to-amazon-s3/manual_deploy.png){:\n.shadow}\n\n\n## Configuration d’OpenID Connect dans AWS\n\n\nPour déployer sur votre bucket S3 depuis GitLab, nous allons utiliser un job\nGitLab CI/CD pour  recevoir des informations d'identification temporaires\nd'AWS sans avoir besoin de stocker des secrets. Pour ce faire, nous allons\nconfigurer OpenID Connect pour la fédération d'identité entre GitLab et AWS.\nNous suivrons la [documentation de GitLab\nassociée](https://docs.gitlab.com/ee/ci/cloud_services/aws/).\n\n\n### Ajoutez un fournisseur d'identité \n\n\nLa première étape consiste à ajouter GitLab en tant que fournisseur\nd’identité OpenID Connect (OIDC) dans IAM. AWS fournit des\n[instructions](https://docs.aws.amazon.com/fr_fr/IAM/latest/UserGuide/id_roles_providers_create_oidc.html),\nmais nous allons les parcourir étape par étape dans ce guide.\n\n\nOuvrez tout d'abord la console IAM dans AWS.\n\n\n![Console IAM dans\nAWS](https://about.gitlab.com/images/blogimages/2023-02-10-how-to-deploy-react-to-amazon-s3/iam_1.png){:\n.shadow} \n\n\nDans le volet de navigation de gauche, sous « Gestion des accès »,\nchoisissez « Fournisseurs d'identité », puis « Ajouter un fournisseur ».\nPour le type de fournisseur, sélectionnez « OpenID Connect ».\n\n\nPour l'URL du fournisseur, saisissez l'adresse de votre instance GitLab,\ntelle que `https://gitlab.com` ou `https://gitlab.example.com`.\n\n\nPour « Audience », saisissez quelque chose de générique mais spécifique à\nvotre application React. Dans notre cas, nous allons utiliser `react_s3_gl`.\nVeillez à choisir quelque chose qui ne soit pas facile à deviner et prenez\nnote de cette valeur, car vous l'utiliserez pour définir l'`ID_TOKEN` dans\nvotre fichier `.gitLab-ci.yml`.\n\n\nAprès avoir saisi l'URL du fournisseur, cliquez sur « Obtenir une empreinte\nnumérique »  pour vérifier le certificat du serveur de votre fournisseur\nd'identité. Ensuite, continuez et cliquez sur « Ajouter un fournisseur »\npour terminer.\n\n\n### Créez une politique d’autorisations\n\n\nAprès avoir créé le fournisseur d'identité, vous devez créer une politique\nd’autorisations. \n\n\nDepuis le tableau de bord IAM, sous « Gestion des accès », sélectionnez «\nPolitiques » puis « Créer une politique ». Sélectionnez l'onglet JSON et\ncollez le code suivant en remplaçant `jw-gl-react` par le nom de votre\ncompartiment à la ligne « Ressource ».\n\n\n```javascript\n\n{\n  \"Version\": \"2012-10-17\",\n  \"Statement\": [\n    {\n      \"Effect\": \"Allow\",\n      \"Action\": [\"s3:ListBucket\"],\n      \"Resource\": [\"arn:aws:s3:::jw-gl-react\"]\n    },\n    {\n      \"Effect\": \"Allow\",\n      \"Action\": [\n        \"s3:PutObject\",\n        \"s3:GetObject\",\n        \"s3:DeleteObject\"\n      ],\n      \"Resource\": [\"arn:aws:s3:::jw-gl-react/*\"]\n    }\n  ]\n}\n\n```\n\n\nSélectionnez le bouton « Suivant : Balises » , ajoutez les balises\nsouhaitées, puis sélectionnez le bouton « Suivant : Confirmer ». Entrez un\nnom pour votre politique avant de terminer sa création.\n\n\n### Configurez le rôle\n\n\nIl est maintenant temps d'ajouter le rôle. Depuis le tableau de bord IAM,\nsous « Gestion des accès  », sélectionnez « Rôles », puis cliquez sur «\nCréer un rôle » et choisissez « Identité Web ».\n\n\nDans la section « Identité Web », sélectionnez le fournisseur d'identité que\nvous avez créé précédemment. Pour l'audience, sélectionnez également\nl'audience que vous avez créée précédemment. Cliquez sur le bouton « Suivant\n» pour continuer.\n\n\nSi vous souhaitez limiter l'autorisation à un groupe, un projet, une branche\nou une balise spécifique, vous pouvez créer une « Politique d’approbation\npersonnalisée » (Custom Trust Policy) au lieu d'une « Identité Web ».\n\n\nPour une liste complète des types de filtres qu'il est possible d'appliquer,\n[consultez notre\ndocumentation](https://docs.gitlab.com/ee/ci/cloud_services/index.html#configure-a-conditional-role-with-oidc-claims). \n\n\n![Configuration du rôle dans\nl'IAM](https://about.gitlab.com/images/blogimages/2023-02-10-how-to-deploy-react-to-amazon-s3/iam_2.png){:\n.shadow}\n\n\nAu cours de l'étape « Ajout des autorisations », sélectionnez la politique\nque vous avez créée, puis cliquez sur « Suivant » pour continuer. Donnez un\nnom à votre rôle et cliquez sur « Créer un rôle ».\n\n\nOuvrez le rôle que vous venez de créer. Dans la section « Récapitulatif »,\nrecherchez le nom de ressource Amazon (ARN) et enregistrez-le dans un\nendroit sécurisé. Vous l'utiliserez dans votre pipeline.\n\n\n![Déployer le rôle dans\nl'IAM](https://about.gitlab.com/images/blogimages/2023-02-10-how-to-deploy-react-to-amazon-s3/iam_3.png){:\n.shadow}\n\n\n## Déploiement sur votre compartiment Amazon S3 à l'aide d'un pipeline\nGitLab CI/CD\n\n\nDans votre projet, créez deux [variables\nCI/CD](https://docs.gitlab.com/ci/variables/#define-a-cicd-variable-in-the-ui)\n:\n\n\n- La première variable doit être nommée `ROLE_ARN`. Pour la valeur, collez\nl'ARN du rôle que vous venez de créer.\n\n- La deuxième variable doit être nommée `S3_BUCKET`. Pour la valeur, collez\nle nom du compartiment que vous avez créé plus tôt.\n\n\nPour des raisons de sécurité, dans cet article nous avons choisi de masquer\nnos variables.\n\n\n### Récupérez vos identifiants temporaires\n\n\nDans votre fichier `.gitlab-ci.yml`, collez le code suivant :\n\n\n```\n\n.assume_role: &assume_role\n    - >\n      STS=($(aws sts assume-role-with-web-identity\n      --role-arn ${ROLE_ARN}\n      --role-session-name \"GitLabRunner-${CI_PROJECT_ID}-${CI_PIPELINE_ID}\"\n      --web-identity-token $ID_TOKEN\n      --duration-seconds 3600\n      --query 'Credentials.[AccessKeyId,SecretAccessKey,SessionToken]'\n      --output text))\n    - export AWS_ACCESS_KEY_ID=\"${STS[0]}\"\n    - export AWS_SECRET_ACCESS_KEY=\"${STS[1]}\"\n    - export AWS_SESSION_TOKEN=\"${STS[2]}\"\n```\n\n\nCela va utiliser le service de jeton de sécurité AWS (AWS Security Token\nService) pour générer des identifiants temporaires (3 600 secondes) en\nutilisant le rôle OpenID Connect que vous avez créé précédemment.\n\n\n### Créez le job de déploiement pour votre application React\n\n\nMaintenant, ajoutons un job de compilation et de déploiement pour créer\nvotre application et la déployer sur votre bucket S3.\n\n\nTout d'abord, mettez à jour les étapes dans votre fichier `.gitlab-ci.yml`\npour inclure une étape `build` et `deploy`, comme indiqué ci-dessous :\n\n\n```\n\nstages:\n  - build\n  - test\n  - deploy\n```\n\n\nEnsuite, ajoutons un job pour créer votre application. Collez le code\nsuivant dans votre fichier `.gitLab-ci.yml` :\n\n\n```\n\nbuild artifact:\n  stage: build\n  image: node:latest\n  before_script:\n    - npm install\n  script:\n    - npm run build\n  artifacts:\n    paths:\n      - build/\n    when: always\n  rules:\n    - if: '$CI_COMMIT_REF_NAME == \"main\"'\n      when: always\n```\n\n\nCela va exécuter `npm run build` si le changement se produit sur la branche\n`main` et télécharger le répertoire de compilation (build directory) en tant\nqu'artefact à utiliser lors de l'étape suivante.\n\n\nEnsuite, ajoutons un job qui sera réellement déployé sur votre bucket S3.\nCollez le code suivant dans votre fichier `.gitLab-ci.yml` :\n\n\n```\n\ndeploy s3:\n  stage: deploy\n  image:\n    name: amazon/aws-cli:latest\n    entrypoint: \n      - '/usr/bin/env'\n  id_tokens:\n      ID_TOKEN:\n        aud: react_s3_gl\n  script:\n    - *assume_role\n    - aws s3 sync build/ s3://$S3_BUCKET\n  rules:\n    - if: '$CI_COMMIT_REF_NAME == \"main\"'\n      when: always\n```\n\n\nCela utilise les [ancres\nYAML](https://docs.gitlab.com/ee/ci/yaml/yaml_optimization.html#yaml-anchors-for-scripts)\npour exécuter le script `assume_role`, puis utilise `aws cli` pour\ntélécharger votre artefact de compilation dans le compartiment que vous avez\ndéfini en tant que variable. Ce job ne s'exécute que si le changement se\nproduit sur la branche `main`.\n\n\nAssurez-vous que la valeur `aud` correspond à celle que vous avez saisie\npour votre audience au moment de la configuration du fournisseur d'identité.\nDans notre cas, nous avons saisi `react-s3_gl`.\n\n\nVotre fichier `.gitLab-ci.yml` complet devrait ressembler à ceci :\n\n\n```\n\nstages:\n  - build\n  - test\n  - deploy\n\n.assume_role: &assume_role\n    - >\n      STS=($(aws sts assume-role-with-web-identity\n      --role-arn ${ROLE_ARN}\n      --role-session-name \"GitLabRunner-${CI_PROJECT_ID}-${CI_PIPELINE_ID}\"\n      --web-identity-token $ID_TOKEN\n      --duration-seconds 3600\n      --query 'Credentials.[AccessKeyId,SecretAccessKey,SessionToken]'\n      --output text))\n    - export AWS_ACCESS_KEY_ID=\"${STS[0]}\"\n    - export AWS_SECRET_ACCESS_KEY=\"${STS[1]}\"\n    - export AWS_SESSION_TOKEN=\"${STS[2]}\"\n\nunit test:\n  image: node:latest\n  stage: test\n  before_script:\n    - npm install\n  script:\n    - npm run test:ci\n  coverage: /All files[^|]*\\|[^|]*\\s+([\\d\\.]+)/\n  artifacts:\n    paths:\n      - coverage/\n    when: always\n    reports:\n      junit:\n        - junit.xml\n\nbuild artifact:\n  stage: build\n  image: node:latest\n  before_script:\n    - npm install\n  script:\n    - npm run build\n  artifacts:\n    paths:\n      - build/\n    when: always\n  rules:\n    - if: '$CI_COMMIT_REF_NAME == \"main\"'\n      when: always\n\ndeploy s3:\n  stage: deploy\n  image:\n    name: amazon/aws-cli:latest\n    entrypoint: \n      - '/usr/bin/env'\n  id_tokens:\n      ID_TOKEN:\n        aud: react_s3_gl\n  script:\n    - *assume_role\n    - aws s3 sync build/ s3://$S3_BUCKET\n  rules:\n    - if: '$CI_COMMIT_REF_NAME == \"main\"'\n      when: always\n```\n\n\n### Testez votre pipeline\n\n\nPour tester votre pipeline, dans `App.js`, modifiez cette ligne `Edit\n\u003Ccode>src/App.js\u003C/code> and save to reload.` par ceci :  `This was deployed\nfrom GitLab`. Maintenant, validez vos modifications dans la branche `main`.\nLe pipeline devrait se lancer et une fois terminé avec succès, vous devriez\nvoir votre application mise à jour avec l'URL de votre site web statique.\n\n\n![Application React mise à\njour](https://about.gitlab.com/images/blogimages/2023-02-10-how-to-deploy-react-to-amazon-s3/auto_deploy.png){:\n.shadow}\n\n\nVous disposez désormais d'un pipeline CI/CD construit dans GitLab qui reçoit\ndes informations d'identification temporaires d'AWS à l'aide d'OpenID\nConnect et qui se déploie automatiquement dans votre compartiment Amazon S3.\nPour aller plus loin, vous pouvez [sécuriser votre\napplication](https://docs.gitlab.com/ee/user/application_security/secure_your_application.html)\navec les outils de sécurité intégrés de GitLab.\n\n\nDécouvrez [tout le\ncode](https://gitlab.com/guided-explorations/engineering-tutorials/react-s3)\nde ce projet.\n",[927,9],"DevOps","2025-03-27",{"slug":930,"featured":6,"template":691},"how-to-deploy-react-to-amazon-s3","content:fr-fr:blog:how-to-deploy-react-to-amazon-s3.yml","How To Deploy React To Amazon S3","fr-fr/blog/how-to-deploy-react-to-amazon-s3.yml","fr-fr/blog/how-to-deploy-react-to-amazon-s3",{"_path":936,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":937,"content":943,"config":954,"_id":956,"_type":14,"title":957,"_source":16,"_file":958,"_stem":959,"_extension":19},"/fr-fr/blog/how-to-use-oci-images-as-the-source-of-truth-for-continuous-delivery",{"title":938,"description":939,"ogTitle":938,"ogDescription":939,"noIndex":6,"ogImage":940,"ogUrl":941,"ogSiteName":673,"ogType":674,"canonicalUrls":941,"schema":942},"Comment utiliser les images OCI comme source unique de vérité pour vos déploiements continus","Découvrez les avantages d'intégrer les images OCI (Open Container Initiative) dans vos workflows GitOps.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097601/Blog/Hero%20Images/Blog/Hero%20Images/REFERENCE%20-%20Use%20this%20page%20as%20a%20reference%20for%20thumbnail%20sizes_76Tn5jFmEHY5LFj8RdDjNY_1750097600692.png","https://about.gitlab.com/blog/how-to-use-oci-images-as-the-source-of-truth-for-continuous-delivery","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Comment utiliser les images OCI comme source unique de vérité pour vos déploiements continus\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Daniel Helfand\"}],\n        \"datePublished\": \"2025-02-19\",\n      }",{"title":938,"description":939,"authors":944,"heroImage":940,"date":946,"body":947,"category":948,"tags":949,"updatedDate":953},[945],"Daniel Helfand","2025-02-19","Est-il encore approprié d'employer le terme [GitOps](https://about.gitlab.com/fr-fr/topics/gitops/) si vous ne déployez plus directement depuis un dépôt Git ? Git reste au cœur des workflows GitOps, c'est indéniable. Pourtant, de plus en plus d'équipes de développement choisissent de stocker leurs configurations d'infrastructure sous forme d'artefacts OCI (Open Container Initiative) dans des registres de conteneurs. Cette pratique gagne du terrain en tant que nouvelle source unique de vérité pour les déploiements GitOps. Découvrez dans cet article les raisons qui motivent cette tendance et comment les fonctionnalités de GitLab soutiennent cette amélioration des workflows GitOps. \n\n## Qu'est-ce que la pratique GitOps ?\n\nLe projet [OpenGitOps](https://opengitops.dev/) définit [quatre principes](https://opengitops.dev/#principles) qui encadrent la pratique GitOps :\n- Un [système géré par GitOps](https://github.com/open-gitops/documents/blob/v1.0.0/GLOSSARY.md#software-system) doit [exprimer son état désiré de manière déclarative](https://github.com/open-gitops/documents/blob/v1.0.0/GLOSSARY.md#declarative-description).\n- Cet état désiré doit être stocké dans un système garantissant l'immuabilité et la gestion des versions, et conserver un historique complet des versions.\n- Des agents logiciels doivent pouvoir effectuer automatiquement un pull des déclarations de l'état désiré depuis la source.\n- Ils doivent surveiller [en continu](https://github.com/open-gitops/documents/blob/v1.0.0/GLOSSARY.md#continuous) l'état réel du système et [tenter de le faire converger vers l'état désiré](https://github.com/open-gitops/documents/blob/v1.0.0/GLOSSARY.md#reconciliation).\n\nUn exemple concret de pratique GitOps consiste à stocker les manifestes [Kubernetes](https://about.gitlab.com/fr-fr/blog/kubernetes-the-container-orchestration-solution/ \"Qu'est-ce que Kubernetes ? \") d'un microservice dans un projet GitLab. Ces ressources Kubernetes sont ensuite continuellement synchronisées par un [contrôleur](https://kubernetes.io/docs/concepts/architecture/controller/) s'exécutant sur le cluster Kubernetes hébergeant le microservice. Ainsi, les équipes de développement sont en mesure de gérer l'infrastructure avec les mêmes workflows que pour du code applicatif : ouverture de merge requests afin d'examiner et de valider les modifications et gestion des versions. La pratique GitOps présente également de nombreux avantages opérationnels. Par exemple, elle permet de [prévenir la dérive de configuration](https://about.gitlab.com/fr-fr/topics/gitops/#cicd) et facilite l'audit des modifications ayant conduit à un certain état du système ou à un incident lors des déploiements. \n\n## Avantages et limites de Git dans les workflows GitOps\n\nGit est sans conteste un composant essentiel des workflows GitOps. Cependant, les dépôts Git n'ont pas été conçus pour être utilisés directement par des contrôleurs GitOps lors des déploiements. Git offre aux équipes de développement la possibilité de collaborer sur les modifications d'infrastructure et d'auditer ces dernières ultérieurement, mais les contrôleurs GitOps n'ont pas besoin de récupérer l'intégralité d'un dépôt Git pour réussir un déploiement. Il leur suffit d'accéder aux définitions d'infrastructure spécifiques à un environnement donné. \n\nDe plus, un autre aspect important du processus de déploiement consiste à [signer et vérifier les déploiements](https://docs.sigstore.dev/about/overview/#why-cryptographic-signing) pour garantir que les modifications en lien avec un déploiement, apportées à un environnement, proviennent d'une source de confiance. Bien que les commit Git puissent effectivement être signés et vérifiés par les contrôleurs GitOps, ils peuvent également inclure des éléments sans lien direct avec le déploiement (par exemple, des modifications de documentation, des mises à jour pour d'autres environnements, ou une restructuration du dépôt Git) ou offrir une image de déploiement incomplète, car un déploiement peut être constitué de plusieurs commits. Là encore, il semble que cette fonctionnalité Git ne soit pas en adéquation avec les exigences spécifiques du déploiement continu.  \n\nLes workflows GitOps basés sur Git peuvent parfois conduire à un excès d'automatisation, ce qui peut être problématique. Par exemple, dès qu'une modification est fusionnée dans une branche surveillée, elle est déployée immédiatement. Il n'y a aucun mécanisme de contrôle dans le processus en dehors de Git. Comment avoir la certitude d'empêcher le déclenchement d'un déploiement un vendredi en fin d'après-midi ? Que se passe-t-il si les équipes responsables du déploiement ne disposent pas des autorisations nécessaires pour fusionner les modifications dans certains projets GitLab ? L'utilisation d'images OCI ajoute une étape intermédiaire au processus : un pipeline intégré au workflow. Celui-ci inclut toutes les fonctionnalités nécessaires au contrôle de la livraison, telles que des [approbations ou le gel des déploiements](https://docs.gitlab.com/ee/ci/environments/protected_environments.html).\n\n## Les images OCI\n\nL'[Open Container Initiative](https://opencontainers.org/) a contribué à définir des normes relatives aux formats de conteneurs. Bien que la plupart des équipes de développement aient l'habitude de créer des images de conteneurs à partir d'un fichier Dockerfiles, beaucoup ne sont peut-être pas aussi familiers avec le stockage des manifestes Kubernetes dans un registre de conteneurs. Étant donné que le [registre de conteneurs de GitLab](https://docs.gitlab.com/ee/user/packages/container_registry/) est conforme à la norme OCI, il permet aux utilisateurs d'effectuer le push des manifestes Kubernetes liés à un environnement particulier directement dans le registre de conteneurs. Au lieu de cloner un dépôt Git complet, les contrôleurs GitOps, tels que [Flux CD](https://about.gitlab.com/blog/why-did-we-choose-to-integrate-fluxcd-with-gitlab/), peuvent désormais récupérer uniquement l'artefact OCI contenant les manifestes nécessaires au déploiement. \n\nDans de nombreux workflows GitOps, un même dépôt Git regroupe les configurations d'infrastructure pour tous les environnements cibles dans lesquels un [microservice](https://about.gitlab.com/fr-fr/topics/microservices/ \"Qu'est-ce qu'un microservice ? \") sera déployé. En empaquetant uniquement les manifestes Kubernetes liés à un environnement spécifique dans une image OCI, Flux CD télécharge les fichiers strictement nécessaires au déploiement dans cet environnement spécifique. \n\n### Les atouts sécurité des artefacts OCI\n\nComme mentionné précédemment, signer et vérifier les artefacts à déployer dans un environnement ajoutent une couche de sécurité supplémentaire aux projets de développement logiciel. Une fois que les manifestes Kubernetes font l'objet d'un push dans un registre de conteneurs, un outil comme [Sigstore Cosign](https://docs.sigstore.dev/quickstart/quickstart-cosign/) peut être utilisé pour signer l'image OCI avec une clé privée, stockée en toute sécurité dans un projet GitLab en tant que [variable CI/CD](https://about.gitlab.com/fr-fr/blog/demystifying-ci-cd-variables/ \"Variables CI/CD\"). Flux CD peut ensuite utiliser une clé publique stockée sur un cluster Kubernetes pour vérifier et garantir que le déploiement provient d'une source fiable. \n\n## Push et signature des images OCI avec GitLab \n\nGitLab offre de nombreuses fonctionnalités qui simplifient le processus d'empaquetage, de signature et de déploiement d'images OCI dans des workflows GitOps. Une pratique courante consiste à structurer les projets GitLab en séparant le code des microservices d’un côté, et le dépôt de l’infrastructure de déploiement de l’autre. Ainsi, pour une application composée de `n` microservices, il est fréquent d'avoir `n +1` projets GitLab.\n\nLe projet de code produit généralement un artefact sous forme d'image de conteneur qui sera utilisée pour empaqueter l'application. Le projet d'infrastructure (aussi appelé projet de livraison) contient, quant à lui, les manifestes Kubernetes définissant toutes les ressources nécessaires pour que chaque microservice puisse monter en charge, recevoir et traiter le trafic des utilisateurs. L'artefact découlant de ce projet est généralement une image OCI servant à déployer l'application et d'autres manifestes sur Kubernetes. \n\nDans cette configuration, la séparation des environnements est gérée en définissant des manifestes Kubernetes dans des dossiers distincts représentant les environnements (par exemple, de développement, de préproduction et de production) qui hébergeront l'application. Lorsque des modifications sont apportées au code d'un microservice et qu'une nouvelle image de conteneur fait l'objet d'un push, il suffit alors de mettre à jour la référence de cette image dans le manifeste situé dans le dossier correspondant à l'environnement cible, puis de créer une merge request pour déployer ces modifications via l'intégration de GitLab avec Flux CD. Une fois cette merge request examinée, approuvée et fusionnée, le job CI/CD du projet de livraison déclenche le push d'une nouvelle image OCI que Flux CD récupérera et déploiera dans le nouvel environnement.\n\n![Images OCI - schéma du workflow](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097611/Blog/Content%20Images/Blog/Content%20Images/image1_aHR0cHM6_1750097611046.png)\n\nPour signer une image OCI, il vous suffit d'intégrer Cosign dans le job CI/CD de votre projet et de générer une nouvelle paire de clés publique/privée avec Cosign en exécutant localement les commandes ci-dessous. Veillez simplement à vous connecter à votre instance GitLab via l'[interface de ligne de commande glab](https://gitlab.com/gitlab-org/cli/#installation) et remplacez la variable [`PROJECT_ID`] dans la commande Cosign par l'[ID de votre projet de livraison](https://docs.gitlab.com/ee/user/project/working_with_projects.html#access-a-project-by-using-the-project-id).   \n\n```\nglab auth login\ncosign generate-key-pair gitlab://[PROJECT_ID]\n```\n\nUne fois la commande Cosign exécutée avec succès, les clés Cosign seront ajoutées à votre projet dans la section des variables CI/CD, sous les noms de clés `COSIGN_PUBLIC_KEY` et `COSIGN_PRIVATE_KEY`.\n\n### Exemple de job CI/CD\n\nVoici à quoi ressemblera un job GitLab CI/CD permettant d'effectuer un push d'une image OCI :\n\n```yaml\nfrontend-deploy:\n  rules:\n  - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH\n    changes:\n      paths: \n      - manifests/dev/frontend-dev.yaml\n  trigger:\n    include:\n      - component: gitlab.com/components/fluxcd/oci-artifact@0.3.1\n        inputs:\n          version: 0.3.1\n          kubernetes_agent_reference: gitlab-da/projects/tanuki-bank/flux-config:dev\n          registry_image_url: \"oci://$CI_REGISTRY_IMAGE/frontend\"\n          image_tag: dev\n          manifest_path: ./manifests/dev/frontend-dev.yaml\n          flux_oci_repo_name: frontend\n          flux_oci_namespace_name: frontend-dev\n          signing_private_key: \"$COSIGN_PRIVATE_KEY\" \n```\n\nLe [catalogue GitLab CI/CD](https://about.gitlab.com/blog/ci-cd-catalog-goes-ga-no-more-building-pipelines-from-scratch/) comprend un [composant CI/CD maintenu par GitLab pour travailler avec les artefacts OCI et Flux CD](https://gitlab.com/explore/catalog/components/fluxcd). Ce composant permet aux équipes de développement d'effectuer un push des manifestes Kubernetes sous forme d'images OCI vers le registre de conteneurs de GitLab ou dans un registre de conteneurs externe, de signer ces image OCI à l'aide de Cosign et d'en déclencher immédiatement la synchronisation via Flux CD. \n\nDans l'exemple ci-dessus, le `component` Flux CD est inclus dans un fichier `.gitlab-ci.yml` d'un projet GitLab. À l'aide aux paramètres `inputs` du composant, les utilisateurs peuvent définir le registre de destination pour l'image (`registry_image_url` et `image tag`), le chemin d'accès aux manifestes Kubernetes qui feront l'objet d'un push (`manifest_path`), la clé privée Cosign utilisée pour signer l'image (`signing_private_key`), ainsi que l'espace de nommage Kubernetes et le nom de l'[OCIRepository](https://fluxcd.io/flux/components/source/ocirepositories/) de Flux CD nécessaires pour synchroniser les mises à jour vers l'environnement de déploiement (`flux_oci_namespace_name` et `flux_oci_repo_name`).\n\nLa variable `kubernetes_agent_reference` permet aux jobs GitLab CI/CD d'hériter automatiquement de la variable `kubeconfig` nécessaire pour accéder à un cluster Kubernetes, sans avoir à stocker manuellement une variable CI/CD `kubeconfig` dans chaque projet GitLab. En configurant [GitLab Agent for Kubernetes](https://docs.gitlab.com/ee/user/clusters/agent/), vous pouvez configurer les jobs CI/CD de tous les projets GitLab dans un [groupe GitLab](https://docs.gitlab.com/ee/user/group/) et faire en sorte qu'ils héritent des autorisations nécessaires pour déployer sur le cluster Kubernetes. \n\nVous pouvez configurer le contexte de GitLab Agent for Kubernetes au même endroit que la configuration de GitLab Agent for Kubernetes dans votre groupe GitLab. Il est toutefois recommandé d'effectuer ces modifications dans le projet qui gère Flux CD. Pour en savoir plus sur la configuration de GitLab Agent pour l'accès CI/CD, consultez notre [documentation dédiée au workflow CI/CD](https://docs.gitlab.com/ee/user/clusters/agent/ci_cd_workflow.html).\n\nPar ailleurs, les variables `$COSIGN_PRIVATE_KEY`, `$FLUX_OCI_REPO_NAME`, et `$FRONTEND_DEV_NAMESPACE` sont des variables CI/CD qui contiennent des données sensibles. Elles sont stockées tout en masquant leur contenu dans les logs CI/CD. Enfin, la variable `$CI_REGISTRY_IMAGE` est disponible par défaut dans tous les jobs GitLab et spécifie le registre de conteneurs associé au projet GitLab. \n\n### Déploiement des images OCI\n\nEn intégrant [Flux CD à vos projets GitLab](https://docs.gitlab.com/ee/user/clusters/agent/gitops/flux_tutorial.html), vous pouvez automatiser les déploiements ainsi que la vérification des signatures pour les environnements de vos microservices. Une fois que Flux CD est configuré pour se synchroniser avec un projet GitLab, vous pouvez simplement ajouter les [définitions de ressources personnalisées](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources/) Kubernetes suivantes à votre projet pour synchroniser votre image OCI dont le push a été effectué. \n\n```yaml\napiVersion: v1\nkind: Namespace\nmetadata:\n  name: frontend-dev\n  labels:\n    name: frontend-dev\n---\napiVersion: bitnami.com/v1alpha1\nkind: SealedSecret\nmetadata:\n  name: cosign-public-key\n  namespace: frontend-dev\nspec:\n  encryptedData:\n    cosign.pub: AgAKgLf4VbVzJOmr6++k81LlFayx88AELaUQFNOaXmBF4G+fBfBYeABl0skNvMAa1UrPVNSfMIHgFoYHoO96g576a+epk6V6glOI+++XvYbfsygof3GGxe0nL5Qh2b3ge0fNpyd0kTPSjTj0YUhRhKtMGMRSRw1jrwhNcGxCHK+Byibs52v8Np49KsIkeZKbzLdgYABkrv+k0j7hQM+jR180NpG+2UiRvaXpPuogxkbj61FEqWGrJHk8IVyfl3eh+YhoXxOHGDqko6SUC+bUZPDBlU6yKegO0/8Zq3hwulrSEsEjzRZNK+RFVMOLWWuC6h+WGpYhAMcsZPwjjJ/y29KLNa/YeqkN/cdk488QyEFc6ehCxzhH67HxIn2PDa+KkEOTv2TuycGF+Q00jKIizXF+IwLx/oRb3pTCF0AoAY8D8N3Ey+KfkOjsBON7gGID8GbQiJqX2IgIZxFMk0JRzxbRKOEqn+guLd5Shj7CD1a1Mkk0DxBdbqrGv2XNYUaFPI7xd3rZXUJZlnv+fsmwswsiGWRuXwim45HScWzQnfgLAe7tv3spVEGeaO5apl6d89uN21PBQnfE/zyugB//7ZW9tSp6+CSMyc5HynxI8diafqiwKPgvzLmVWRnkvxJijoXicRr3sCo5RudZPSlnjfd7CKdhwEVvLl7dRR4e/XBMdxCzk1p52Pl+3/kJR+LJii5+iwOpYrpVltSZdzc/3qRd19yMpc9PWpXYi7HxTb24EOQ25i21eDJY1ceplDN6bRtop2quzkjlwVeE2i4cEsX/YG8QBtQbop/3fjiAjKaED3QH3Ul0PECS9ARTScSkcOL3I00Xpp8DyD+xH0/i9wCBRDmH3yKX18C8VrMq02ALSnlP7WCVVjCPzubqKx2LPZRxK9EG0fylwv/vWQzTUUwfbPQZsd4c75bSTsTvxqp/UcFaXA==\n  template:\n    metadata:\n      name: cosign-public-key\n      namespace: frontend-dev\n---\napiVersion: source.toolkit.fluxcd.io/v1beta2\nkind: OCIRepository\nmetadata:\n    name: frontend\n    namespace: frontend-dev\nspec:\n    interval: 1m\n    url: oci://registry.gitlab.com/gitlab-da/projects/tanuki-bank/tanuki-bank-delivery/frontend\n    ref:\n        tag: dev\n    verify:\n      provider: cosign\n      secretRef:\n        name: cosign-public-key\n---\napiVersion: kustomize.toolkit.fluxcd.io/v1\nkind: Kustomization\nmetadata:\n    name: frontend\n    namespace: frontend-dev\nspec:\n    interval: 1m\n    targetNamespace: frontend-dev\n    path: \".\"\n    sourceRef:\n        kind: OCIRepository\n        name: frontend\n    prune: true\n```   \n\nLa ressource [`Kustomization`](https://fluxcd.io/flux/components/kustomize/kustomizations/) permet de personnaliser davantage les manifestes Kubernetes, tout en spécifiant l'espace de nommage dans lequel déployer les ressources. La ressource `OCIRepository` de Flux CD, quant à elle, permet de spécifier la référence et le tag du dépôt d'images OCI à synchroniser régulièrement. Vous remarquerez également les champs `verify.provider` et `verify.secretRef` : ils permettent de vérifier que l'image OCI déployée sur le cluster a bien été signée avec la clé privée Cosign correspondante, utilisée précédemment dans le job CI/CD. \n\nLa clé publique correspondante doit être stockée dans un [secret Kubernetes](https://kubernetes.io/fr/docs/concepts/configuration/secret/) qui doit être présent dans le même espace de nommage que la ressource `OCIRepository`. Pour que ce secret soit géré par Flux CD et non stocké en texte brut, vous pouvez utiliser [SealedSecrets](https://fluxcd.io/flux/guides/sealed-secrets/) pour chiffrer sa valeur et la faire déchiffrer côté cluster par un contrôleur. \n\nSi vous souhaitez opter pour une approche plus simple sans SealedSecrets, vous pouvez [déployer le secret via un job GitLab CI/CD](https://docs.gitlab.com/ee/user/clusters/agent/getting_started_deployments.html) à l'aide de l'[interface de ligne de commande `kubectl CLI`](https://kubernetes.io/docs/reference/kubectl/). Il vous suffit alors de supprimer le SealedSecret inclus dans la configuration ci-dessus et d'exécuter un job CI/CD pour déployer le secret de clé publique avant de lancer le job qui effectuera un push de la nouvelle image OCI. Cette opération permet de stocker le secret en toute sécurité dans GitLab et d'y accéder sur le cluster par le biais de la ressource OCIRepository. Cependant, bien qu'elle soit moins complexe, cette approche ne permet pas de gérer les secrets en environnement de production. \n\n## Les avantages combinés des artefacts OCI, de GitLab et de GitOps\n\nLes artefacts OCI permettent aux équipes GitOps d'affiner leurs déploiements avec un niveau de sécurité renforcé et une approche plus minimaliste, sans priver les utilisateurs des atouts de Git, notamment une source unique de vérité et une collaboration efficace. Les images OCI introduisent une méthode d'empaquetage optimisée qui améliore le déploiement au sein des workflows GitOps.\n\nGitLab continue de s'améliorer grâce aux retours de ses clients et de la communauté cloud-native dans le but de simplifier les workflows GitOps. Pour tester les fonctionnalités présentées dans cet article, vous pouvez commencer par un [essai gratuit de GitLab Ultimate](https://about.gitlab.com/fr-fr/free-trial/). Nous serions ravis de connaître votre avis suite à l'utilisation de ces outils. Alors, n'hésitez pas à nous faire part de vos retours d'expérience sur le [forum de la communauté GitLab](https://forum.gitlab.com/t/oci-images-as-source-of-truth-for-gitops-with-gitlab/120965).\n","open-source",[9,950,951,536,952,684],"open source","kubernetes","git","2025-05-09",{"slug":955,"featured":6,"template":691},"how-to-use-oci-images-as-the-source-of-truth-for-continuous-delivery","content:fr-fr:blog:how-to-use-oci-images-as-the-source-of-truth-for-continuous-delivery.yml","How To Use Oci Images As The Source Of Truth For Continuous Delivery","fr-fr/blog/how-to-use-oci-images-as-the-source-of-truth-for-continuous-delivery.yml","fr-fr/blog/how-to-use-oci-images-as-the-source-of-truth-for-continuous-delivery",{"_path":961,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":962,"content":968,"config":976,"_id":978,"_type":14,"title":979,"_source":16,"_file":980,"_stem":981,"_extension":19},"/fr-fr/blog/jenkins-to-gitlab-migration-made-easy",{"title":963,"description":964,"ogTitle":963,"ogDescription":964,"noIndex":6,"ogImage":965,"ogUrl":966,"ogSiteName":673,"ogType":674,"canonicalUrls":966,"schema":967},"Migrer de Jenkins vers GitLab : le guide complet","Découvrez pourquoi et comment migrer facilement de Jenkins vers GitLab en suivant ce guide étape par étape.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749663019/Blog/Hero%20Images/AdobeStock_519147119.jpg","https://about.gitlab.com/blog/jenkins-to-gitlab-migration-made-easy","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Migrer de Jenkins vers GitLab : le guide complet\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Fernando Diaz\"}],\n        \"datePublished\": \"2024-02-01\",\n      }",{"title":963,"description":964,"authors":969,"heroImage":965,"date":971,"body":972,"category":973,"tags":974,"updatedDate":975},[970],"Fernando Diaz","2024-02-01","GitLab est la plateforme DevSecOps alimentée par l'IA la plus complète. En effet, GitLab fournit toutes les fonctionnalités dont vous avez besoin pour planifier, développer et livrer des logiciels sécurisés plus rapidement, le tout au sein d'une seule et même plateforme. \n\nLes plateformes comme GitLab éliminent les difficultés et les défis liés à l'intégration de multiples outils (approche DevOps DIY) pour gérer au mieux le cycle de vie du développement logiciel (SDLC). À l'inverse, Jenkins n'étant pas une plateforme, des outils supplémentaires sont nécessaires pour compléter le SDLC. Cette approche DevOps DIY introduit une complexité supplémentaire liée à la chaîne d'outils, et génère un certain nombre d'inconvénients comme : \n\n- La nécessité d'une assistance personnalisée pour l'intégration et l'orchestration des outils\n- La difficulté à tenir à jour/mettre à niveau/sécuriser des outils disparates\n- L'impossibilité de mesurer correctement la transformation organisationnelle\n- Une mauvaise expérience des équipes de développement \n- Des coûts supplémentaires en lien avec la gestion, les délais et le budget\n- Une perte de productivité\n- Un changement de contexte et une inefficacité en terme de collaboration\n\n\u003Ccenter>\n\u003Cfigure>\n   \u003Cimg src=\"https://res.cloudinary.com/about-gitlab-com/image/upload/v1752175993/Blog/ikr97sr9jclddeqdg7ew.png\" alt=\"Import project selection\">\n   \u003Cfigcaption>DevOps DIY versus plateforme DevSecOps\u003C/figcaption>\n\u003C/figure>\n\u003C/center>\n\u003Cp>\u003C/p>\n\nPour ces raisons, de nombreuses équipes de développement utilisant Jenkins envisagent de migrer vers une plateforme [DevSecOps](https://about.gitlab.com/fr-fr/topics/devsecops/ \"Qu'est-ce que l'approche DevSecOps ?\") complète. Si vous recherchez une plateforme puissante, fiable et sécurisée, GitLab est votre meilleure option ! GitLab propose une version gratuite ainsi que différents niveaux d'abonnement en fonction des besoins de votre entreprise. Pour en savoir plus sur nos offres et fonctionnalités, consultez notre [page tarifaire](https://about.gitlab.com/fr-fr/pricing/).\n\nDécouvrez dans cet article de blog :\n- Comment planifier une migration\n- Comment migrer des dépôts depuis d'autres outils de gestion du code source (SCM) vers GitLab\n- Comment migrer des pipelines CI/CD de Jenkins vers GitLab\n\n## Comment planifier une migration de Jenkins vers GitLab ? \n\nAvant d'initier la migration de vos dépôts hébergés sur un autre outil vers GitLab CI/CD, vous devez élaborer un plan de migration. Cette étape technique est importante et vous permet de définir clairement vos attentes. Les outils CI/CD diffèrent par leur approche, leur structure et leurs spécificités techniques. Par conséquent, les migrations ne sont pas de simples transferts directs des données. \n\nUn plan de migration offre les avantages suivants :\n- Il définit et communique une vision claire de vos objectifs de migration, ce qui aide les personnes impliquées à comprendre le but de cette opération. \n- Il vous permet de vous assurer d’obtenir l'aval des équipes de direction concernées pour faciliter cette démarche.\n- Il permet d'expliquer aux utilisateurs les changements à venir.\n- Il permet de trouver des moyens de séquencer ou de retarder certaines étapes de la migration pour éviter l'échec de la migration ou une migration partielle.\n- Il documente les avantages des améliorations apportées par GitLab CI/CD et met à jour votre mise en œuvre à chaque étape de la migration.\n\nUn plan de migration vous aide à mettre en place un processus fluide permettant de migrer progressivement vers GitLab, avec un minimum de perturbations. Il peut s'agir d’exécuter simultanément Jenkins et GitLab, tandis que certains projets sont transférés de Jenkins vers GitLab.\n\n### Définissez un processus de gestion du changement\n\nIl se peut que les développeurs, opérateurs informatiques, administrateurs cloud, équipes en charge de la sécurité, ainsi que les ingénieurs qualité n'aient pas d'expérience avec GitLab et ne sachent pas pourquoi vous ou votre équipe de direction avez choisi de réaliser cette migration. C'est pourquoi votre plan de migration doit inclure un processus efficace de gestion du changement. \n\nLes personnes impactées par cette migration doivent savoir :\n- __Pourquoi__ ce changement est nécessaire\n- __À quoi__ ressemblera le futur système\n- __Comment__ l'entreprise prévoit d'atteindre cet objectif\n- __Vers qui__ se tourner pour obtenir plus d'informations ou de l'aide \n\nÀ cette fin, vous devez réaliser les étapes suivantes afin de gérer efficacement le changement au sein des différentes équipes fonctionnelles : \n- __Analysez l'état actuel__ : documentez les processus existants. Collectez des indicateurs qui serviront de base de référence. Identifiez ce qui fonctionne ou non avec l'[approche CI/CD](https://about.gitlab.com/fr-fr/topics/ci-cd/ \"Qu'est-ce que le CI/CD ?\") en interrogeant certains membres de votre équipe. Documentez les défis que vous devez relever, et ce d'un point de vue quantitatif et qualitatif. Comme vous allez devoir expliquer les raisons de ce changement et votre vision, plus vous définirez clairement les problématiques que vous espérez résoudre, plus il vous sera facile d'obtenir l'adhésion de tous. \n- __Établissez une vision__ : maintenant que vous avez décrit les points de friction actuels quantitativement avec des indicateurs de référence et qualitativement (en vous basant sur les retours des membres de votre équipe), communiquez une vision de l'état futur. Expliquez pourquoi c'est important (en vous référant aux indicateurs de réussite de votre entreprise) et partagez l’état actuel de la situation et les résultats attendus. Renforcez ce message par le biais de différents canaux de communication : groupes de discussion, réunions rassemblant l'ensemble des acteurs de l'entreprise, ou encore notifications par e-mail.\n- __Formez les collaborateurs__ : investissez dans une [formation sur GitLab CI/CD](https://about.gitlab.com/services/education/gitlab-ci/) dispensée par un expert GitLab. Mesurez l'acquisition et la mémorisation des connaissances à l'aide des [certifications GitLab](https://levelup.gitlab.com/pages/certifications). \n- __Communiquez la roadmap et les ressources__ : partagez avec les membres de votre équipe le calendrier prévu de la migration et les ressources mises à leur disposition pour faciliter la transition. Mentionnez également les ressources communautaires (groupes de discussion, forums), afin que votre équipe puisse poser des questions et obtenir de l'aide. Créez un système qui récompense les équipes qui effectuent rapidement cette transition, et encouragez-les à partager leur expérience avec d'autres équipes similaires au sein de l'entreprise.\n\nSi vous mettez en place ces éléments dès le début de cette transition, cela sera de bon augure pour la réussite de votre migration. \n\n### Définissez des objectifs de migration\n\nAvant d'effectuer votre migration, vous devez avoir une bonne compréhension de vos objectifs et de la façon de les atteindre. Voici par exemple certaines des questions auxquelles vous devez pouvoir répondre :\n\n- Quel est votre calendrier de migration ?\n- Quelle est la configuration actuelle de votre serveur Jenkins ?\n- Combien de projets sont concernés par la migration ?\n- Quel est le degré de complexité de votre pipeline ?\n- Nécessite-t-il des dépendances externes, plusieurs déclencheurs pour s'exécuter, exécute-t-il plusieurs processus en parallèle pour compiler le code, etc. ?\n- Comment/où déployez-vous votre code ?\n- Quel est le processus de revue/sortie des nouvelles versions et de déploiement du code ?\n- Est-il intégré dans Jenkins ou dans un workflow distinct déclenché par Jenkins ?\n- Quels artefacts de compilation ou binaires sont nécessaires au succès du pipeline ?\n- Quels plug-ins sont utilisés par les jobs dans Jenkins aujourd'hui ?\n- Quel logiciel est installé sur les agents Jenkins ?\n- Quelle solution de gestion du code source (SCM) utilisez-vous actuellement ?\n- Utilisez-vous des bibliothèques partagées dans vos jobs Jenkins ?\n- Quelle méthode d'authentification est utilisée pour Jenkins (Basic Authentication, LDAP/AD, SSO) ?\n- Y a-t-il d'autres projets auxquels vous devez accéder depuis votre pipeline ?\n- Des identifiants de connexion dans Jenkins sont-ils utilisés pour accéder à des services externes ?\n\nEn répondant à ces questions, vous saurez comment procéder à la migration, combien de temps durera cette opération et par où commencer. Une fois que vous avez élaboré un plan et que vous êtes conscient des attentes et des écueils possibles, vous pouvez commencer votre processus de migration.\n\n## Prérequis à la migration\n\nUne fois que vous avez créé votre plan de migration et répondu à toutes les attentes associées, vous pouvez commencer à configurer GitLab. \n\nVoici certains des prérequis suggérés pour la migration :\n- Familiarisez-vous avec GitLab et découvrez les [fonctionnalités clés de GitLab CI/CD](https://docs.gitlab.com/ee/ci/index.html).\n- Suivez des tutoriels pour créer votre premier [pipeline GitLab](https://docs.gitlab.com/ee/ci/quick_start/index.html) et des [pipelines plus complexes](https://docs.gitlab.com/ee/ci/quick_start/tutorial.html) qui créent, testent et déploient un site statique.\n- Passez en revue la [liste des mots-clés de configuration .gitlab-ci.yml](https://docs.gitlab.com/ee/ci/yaml/index.html).\n- Configurez GitLab.\n- Testez votre instance GitLab.\n\nUne fois que vous avez compris le fonctionnement de GitLab et qu'une instance a été configurée, vous pouvez suivre votre plan de migration et commencer à déplacer des projets de Jenkins vers GitLab. Vérifiez que votre instance GitLab a été correctement configurée à l'aide des bonnes pratiques et des [architectures de référence](https://docs.gitlab.com/ee/administration/reference_architectures/) de GitLab.\n\n### Migrez vos dépôts vers GitLab\nL'un des principaux inconvénients de Jenkins est qu'il ne fournit pas de solution SCM. Si vous utilisez Jenkins, votre code doit être stocké dans une solution SCM distincte à laquelle Jenkins doit avoir accès. Comme GitLab dispose d'un SCM intégré, la migration depuis Jenkins vous permet également de migrer depuis la solution SCM que vous utilisiez, ce qui entraîne une réduction supplémentaire des coûts.\n\nGitLab fournit des outils pour vous permettre de déplacer facilement votre dépôt et ses métadonnées dans GitLab. Les outils d'importation suivants sont inclus et vous aideront à migrer vos projets vers GitLab :\n\n- [GitHub](https://docs.gitlab.com/ee/user/project/import/github.html)\n- [Autre instance GitLab](https://docs.gitlab.com/ee/user/project/settings/import_export.html)\n- [Bitbucket Cloud](https://docs.gitlab.com/ee/user/project/import/bitbucket.html)\n- [Bitbucket Server](https://docs.gitlab.com/ee/user/project/import/bitbucket_server.html)\n- [FogBugz](https://docs.gitlab.com/ee/user/project/import/fogbugz.html)\n- [Gitea](https://docs.gitlab.com/ee/user/project/import/gitea.html)\n- [Jira (Tickets uniquement)](https://docs.gitlab.com/ee/user/project/import/jira.html)\n- [Dépôt par fichier manifeste](https://docs.gitlab.com/ee/user/project/import/manifest.html)\n- [Dépôt par URL](https://docs.gitlab.com/ee/user/project/import/repo_by_url.html)\n\n\u003Ccenter>\n\u003Cfigure>\n   \u003Cimg src=\"https://res.cloudinary.com/about-gitlab-com/image/upload/v1752176002/Blog/ie2xrexhbcoq6m8rnhit.png\" alt=\"GitHub to GitLab Repo Exporter\">\n   \u003Cfigcaption>Outil d'exportation de dépôt de GitHub vers GitLab\u003C/figcaption>\n\u003C/figure>\n\u003C/center>\n\u003Cp>\u003C/p>\n\nChaque outil d'importation importe différentes données d'un projet. Lisez notre [documentation sur l'importation et la migration de projets](https://docs.gitlab.com/ee/user/project/import/) pour en savoir plus sur les outils d'importation fournis et comprendre quelles données sont migrées vers GitLab. De plus, vous pouvez [automatiser l'importation de groupes et de projets](https://docs.gitlab.com/ee/user/project/import/#automate-group-and-project-import) et créer une solution personnalisée pour mieux répondre aux besoins de votre entreprise :\n\n- [Services professionnels](https://about.gitlab.com/services/)\n- [Services de migration](https://gitlab.com/gitlab-org/professional-services-automation/tools/migration/congregate/-/blob/master/docs/using-congregate.md#quick-start)\n- [Foire aux questions sur la migration](https://gitlab.com/gitlab-org/professional-services-automation/tools/migration/congregate/-/blob/master/customer/famq.md)\n\n#### Comment migrer un dépôt ? \n\nLa migration d'un dépôt vers GitLab est facile grâce à nos outils d'importation intégrés. Dans cet exemple, nous allons vous expliquer comment copier un dépôt de GitHub vers GitLab ainsi que [ses ressources](https://docs.gitlab.com/ee/user/project/import/github.html#imported-data) (tickets, pull requests, jalons et plus encore). \n\nAfin de migrer un dépôt depuis GitHub vers GitLab, vous pouvez suivre les étapes ci-dessous :\n\n1. Dans la barre latérale de gauche, en haut, sélectionnez **Créer un nouveau (+)**.\n2. Sélectionnez **Nouveau projet/dépôt**.\n3. Sélectionnez **Importer un projet**.\n\n\u003Ccenter>\n\u003Cfigure>\n   \u003Cimg src=\"https://res.cloudinary.com/about-gitlab-com/image/upload/v1752176017/Blog/boowmmaqhbredxa3g92s.png\" alt=\"Import project selection\">\n\u003C/figure>\n\u003C/center>\n\u003Cp>\u003C/p>\n\n4. Cliquez sur le bouton **GitHub**.\n    - Si vous utilisez GitLab Self-Managed, vous devez [activer l'outil d'importation GitHub](https://docs.gitlab.com/ee/administration/settings/import_and_export_settings.html#configure-allowed-import-sources).\n    - Notez que d'autres outils d'importation peuvent être lancés de la même manière.\n5. Vous pouvez ensuite utiliser l'une des deux options ci-dessous :\n    - Autoriser OAuth de GitHub en sélectionnant **Autoriser avec GitHub**.\n    - Utiliser un jeton d'accès personnel GitHub :\n       - Accédez à la page [https://github.com/settings/tokens/new](https://github.com/settings/tokens/new).\n       - Dans le champ **Note**, saisissez une description du token.\n       - Sélectionnez la portée du dépôt.\n       - En option, pour importer des collaborateurs, sélectionnez la portée **read:org**.\n       - Cliquez sur le bouton **Générer un token**.\n       - Sur la page d'importation de GitLab, dans le champ **Jeton d'accès personnel**, collez le jeton d'accès personnel GitHub.\n6. Cliquez sur le bouton **Authentification**.\n7. Sélectionnez les éléments que vous souhaitez migrer.\n8. Sélectionnez les projets que vous souhaitez migrer et leur destination.\n9. Cliquez sur le bouton **Importer**.\n\nLe projet importé devrait maintenant être disponible dans votre espace de travail. Pour en savoir plus sur la migration de GitHub vers GitLab, regardez cette vidéo :\n\n\u003Cfigure class=\"video_container\">\n  \u003Ciframe src=\"https://www.youtube.com/embed/0Id5oMl1Kqs?si=TQ5HI9aMwtzJMiMi\" frameborder=\"0\" allowfullscreen=\"true\"> \u003C/iframe>\n\u003C/figure>\n\u003C!-- blank line -->\n\nUne fois que vous avez terminé la migration de votre dépôt, vous pouvez configurer votre pipeline Jenkins pour exploiter le fichier Jenkinsfile dans GitLab. Pour ce faire, définissez l'URL du dépôt sur le projet que vous venez tout juste d'importer via le menu de configuration du pipeline Jenkins :\n\n\u003Ccenter>\n\u003Cfigure>\n   \u003Cimg src=\"https://res.cloudinary.com/about-gitlab-com/image/upload/v1752176020/Blog/mu475liw66abcxbu2g6g.png\" alt=\"Jenkins Pipeline SCM settings\">\n\u003C/figure>\n\u003C/center>\n\u003Cp>\u003C/p>\n\nCette opération est utile pendant la phase de migration initiale du dépôt et vous permet d'utiliser Jenkins et GitLab en parallèle. Vous évitez ainsi toute interruption de service pendant que vous travaillez sur votre migration.\n\nDe plus, vous pouvez utiliser le [plug-in Jenkins GitLab](https://plugins.jenkins.io/gitlab-plugin/) pour faciliter la migration. Ce plug-in permet à GitLab de déclencher et d'obtenir le statut des compilations Jenkins.\n\n### Migrez vos pipelines CI/CD\nUne fois que vous avez migré vos dépôts vers GitLab, vous pouvez procéder à la migration de vos pipelines Jenkins. Bien qu'assez simple, ce processus nécessite une bonne compréhension des concepts et de la syntaxe Jenkins et GitLab.\n\nJenkins fournit deux types de syntaxe pour la définition des pipelines : une syntaxe déclarative et une syntaxe scriptée. Dans ce guide, nous décrirons la migration à partir des pipelines déclaratifs, car ils sont les plus couramment utilisés.\n\n#### Migrez votre pipeline étape par étape\n\nDans ce tutoriel, nous analyserons un fichier Jenkinsfile (Groovy) ainsi qu'un fichier de configuration GitLab CI/CD (YAML) qui compile, teste et déploie un microservice écrit en Golang. Nous activerons ensuite le pipeline dans GitLab et observerons le résultat. \n\nLe pipeline :\n- Utilisera l'image de conteneur Golang avec le tag **alpine**\n- Exécutera un job pour compiler le code Golang en un fichier binaire exécutable\n   - Stockera le fichier exécutable compilé en tant qu'artefact\n- Exécutera un job pour lancer les tests unitaires\n- Exécutera un job pour effectuer le déploiement sur l'environnement de préproduction\n   - Ne s'exécutera que si la validation cible la branche de **préproduction**\n   - S'exécutera uniquement après la réussite de l'étape de **test**\n   - Utilisera l'artefact exécutable compilé du job précédent\n\nVous trouverez ci-dessous les définitions de pipeline Jenkins et GitLab accompagnées de commentaires descriptifs. Vous pouvez observer le pipeline en action dans le [projet de migration Meow](https://gitlab.com/gitlab-da/projects/blogs/meow-migration).\n\nVoici un fichier Jenkinsfile écrit en Groovy :\n\n```  \n// The top-level of the declarative\n// pipeline.\npipeline {\n\n  // Defines the default agent to use\n  // when it is not explicitly defined\n  // in a job.\n    agent any\n\n  // Defines the stages that will run\n  // in numerical order. Each stage\n  // only runs one job.\n    stages {\n\n    // Defines the name of the stage\n        stage('build') {\n      // Defines the container image to\n      // use for this job, overwriting\n      // the default 'agent any'.\n      // The Jenkins Docker plugin\n      // must be configured for this\n      // to run.\n            agent { docker 'golang:alpine' }\n\n      // Defines the sequence of steps\n      // to execute when the stage is\n      // run.\n            steps {\n                sh 'go build -o bin/meow-micro'\n                sh 'chmod +x bin/meow-micro'\n            }\n\n      // The steps to run after the\n      // stage completes.\n            post {\n              always {\n\n        // Stores the stage artifacts\n        // generated for use in another\n        // job.\n                archiveArtifacts artifacts: 'bin/meow-micro'\n                onlyIfSuccessful: true\n              }\n            }\n        }\n\n    stage('test') {\n            agent { docker 'golang:alpine' }\n            steps {\n                sh 'go test .'\n            }\n        }\n\n        stage('deploy') {\n      // Defines conditions which must\n      // be met in order for the job to\n      // execute. In this case the\n      // deploy job will only run on the \n      // staging branch.\n            when {\n              branch 'staging'\n            }\n            steps {\n                echo 'Deploying meow-micro to staging'\n        // Uses the artifact stored in\n        // the build stage.\n                sh './bin/meow-micro'\n            }\n        }\n    }\n}\n```\n\nVoyons maintenant comment créer la même fonctionnalité dans GitLab :\n\n```\n# Defines the default image to use\n# when it is not explicitly defined in\n# a job.\ndefault:\n  image: alpine:latest\n\n# Defines the order to run the stages.\n# Each stage can have multiple jobs.\nstages:\n  - build\n  - test\n  - deploy\n\n# Defines the name of the job\ncreate-binary:\n # Defines the stage the job will run in\n  stage: build\n # Defines the container image to use\n # for this job, overwriting default.\n  image: golang:alpine\n # Defines the sequence of steps to\n # execute when the job is run.\n  script:\n    - go build -o bin/meow-micro\n    - chmod +x bin/meow-micro\n # Stores the job artifacts generated\n # for use in another job.\n  artifacts:\n    paths:\n      - bin/meow-micro\n    expire_in: 1 week\n\nunit-tests:\n  stage: test\n  image: golang:alpine\n  script:\n    - go test .\n # Defines commands to run after the\n # job.\n after_script:\n  - echo \"Tests Complete\"\n\nstaging-deploy:\n  stage: deploy\n # Defines commands to run before the\n # actual job.\n  before_script:\n    - apk update\n  script:\n    - echo \"Deploying meow-micro to staging environment\"\n    - ./bin/meow-micro\n # Defines conditions which must be met\n # in order for this job to execute. In\n # this case the staging-deploy job will \n # only run on the staging branch.\n  rules:\n    - if: $CI_COMMIT_BRANCH == 'staging'\n # Allows the artifact stored in the\n # build job to be used in this job.\n  artifacts:\n    paths:\n      - bin/meow-micro\n```\n\nComme vous l'avez peut-être remarqué, il existe de nombreuses similitudes entre Jenkins et GitLab en termes de syntaxe, ce qui simplifie la migration du pipeline. Bien que l'exemple ci-dessus fournisse une vue d'ensemble basique, assurez-vous de consulter la liste complète des [comparaisons de fonctionnalités et de concepts](https://docs.gitlab.com/ee/ci/migration/jenkins.html#comparison-of-features-and-concepts) entre les deux outils.\n\nMaintenant que nous comprenons comment transposer Jenkins à GitLab, nous pouvons commencer à créer un pipeline avec les mêmes fonctionnalités dans GitLab. Pour effectuer la migration de votre [pipeline CI/CD](https://about.gitlab.com/fr-fr/topics/ci-cd/cicd-pipeline/ \"Qu'est-ce qu'un pipeline CI/CD ?\"), suivez les étapes suivantes :\n\n##### 1. Ouvrez le dépôt que vous avez migré vers GitLab dans la section ci-dessus.\n- Dans la barre latérale de gauche, en haut, sélectionnez **Rechercher ou accéder à...**\n- Localisez votre projet.\n\n##### 2. Ouvrez l'[éditeur de pipeline](https://docs.gitlab.com/ee/ci/pipeline_editor/).\n- Dans la barre latérale de gauche, sélectionnez **Compilation > Éditeur de pipeline**.\n\u003Ccenter>\n\u003Cfigure>\n   \u003Cimg src=\"https://res.cloudinary.com/about-gitlab-com/image/upload/v1752176026/Blog/ecp4jh7epho2oxuegaor.png\" alt=\"Pipeline editor menu\">\n\u003C/figure>\n\u003C/center>\n\u003Cp>\u003C/p>\n\n- Cliquez sur le bouton **Configurer le pipeline**.\n\n\u003Ccenter>\n\u003Cfigure>\n   \u003Cimg src=\"https://res.cloudinary.com/about-gitlab-com/image/upload/v1752176029/Blog/nypfh01zhwgvzqc0xz3v.png\" alt=\"Configure pipeline selection\">\n\u003C/figure>\n\u003C/center>\n\u003Cp>\u003C/p>\n\n##### 3. Complétez le fichier [.gitlab-ci.yml](https://docs.gitlab.com/ee/ci/yaml/).\n- Ajoutez le code du pipeline GitLab CI. \n\u003Ccenter>\n\u003Cfigure>\n   \u003Cimg src=\"https://res.cloudinary.com/about-gitlab-com/image/upload/v1752176031/Blog/nxi6uxxispyyoiiyvxyg.png\" alt=\"Pipeline editor input\">\n\u003C/figure>\n\u003C/center>\n\u003Cp>\u003C/p>\n\n- Vérifiez que la syntaxe est correcte.\n\n\u003Ccenter>\n\u003Cfigure>\n   \u003Cimg src=\"https://res.cloudinary.com/about-gitlab-com/image/upload/v1752176037/Blog/x3d4utfsnymye0lvphtf.png\" alt=\"Pipeline syntax validation\">\n\u003C/figure>\n\u003C/center>\n\u003Cp>\u003C/p>\n\n- Visualisez le pipeline.\n\n\u003Ccenter>\n\u003Cfigure>\n   \u003Cimg src=\"https://res.cloudinary.com/about-gitlab-com/image/upload/v1752176043/Blog/hipzofpyywjxf62edzfv.png\" alt=\"Pipeline visualization\">\n\u003C/figure>\n\u003C/center>\n\u003Cp>\u003C/p>\n\n##### 4. Validez le fichier dans la branche principale.\n- Ajoutez un message de validation.\n- Assurez-vous que la branche est définie sur la branche principale.\n- Cliquez sur le bouton __Valider les modifications__.\n\n\u003Ccenter>\n\u003Cfigure>\n   \u003Cimg src=\"https://res.cloudinary.com/about-gitlab-com/image/upload/v1752176048/Blog/nn8bl7rdysabccoycfrk.png\" alt=\"Commit changes dialog\">\n\u003C/figure>\n\u003C/center>\n\u003Cp>\u003C/p>\n\nUne fois le fichier fusionné, le pipeline défini s'exécute. Vous pouvez revenir à votre projet et [observer le pipeline](https://docs.gitlab.com/ee/ci/pipelines/#view-pipelines) en action en le sélectionnant sur la page **Compilation > Pipelines** de votre projet. Comme il a été exécuté sur la branche **principale**, vous ne verrez que les jobs **create-binary** et **unit-tests**. Le job **staging-deploy** s'exécute uniquement sur la branche de préproduction.\n\n\u003Ccenter>\n\u003Cfigure>\n   \u003Cimg src=\"https://res.cloudinary.com/about-gitlab-com/image/upload/v1752176051/Blog/wfb4k8nkzpg28kpf2pzz.png\" alt=\"Pipeline running on main branch\">\n\u003C/figure>\n\u003C/center>\n\u003Cp>\u003C/p>\n\nSi nous créons une branche de préproduction, le pipeline suivant s'exécute.\n\n\u003Ccenter>\n\u003Cfigure>\n   \u003Cimg src=\"https://res.cloudinary.com/about-gitlab-com/image/upload/v1752176053/Blog/e2jxedpolaniotgixpby.png\" alt=\"Pipeline running on staging branch\">\n\u003C/figure>\n\u003C/center>\n\u003Cp>\u003C/p>\n\nEn cliquant sur un job, nous pouvons voir la sortie associée :   \n\n\u003Ccenter>\n\u003Cfigure>\n   \u003Cimg src=\"https://res.cloudinary.com/about-gitlab-com/image/upload/v1752176056/Blog/fywzwbzkwcvc9zzakilh.png\" alt=\"create-binary job output\">\n   \u003Cfigcaption>Sortie du job create-binary\u003C/figcaption>\n\u003C/figure>\n\u003C/center>\n\u003Cp>\u003C/p>\n\n\u003Ccenter>\n\u003Cfigure>\n   \u003Cimg src=\"https://res.cloudinary.com/about-gitlab-com/image/upload/v1752176061/Blog/ekmpd8ecanwwiena9xi9.png\" alt=\"unit-tests job output input\">\n   \u003Cfigcaption>Entrée/sortie du job unit-tests\u003C/figcaption>\n\u003C/figure>\n\u003C/center>\n\u003Cp>\u003C/p>\n\n\u003Ccenter>\n\u003Cfigure>\n   \u003Cimg src=\"https://res.cloudinary.com/about-gitlab-com/image/upload/v1752176065/Blog/h7nqxszy50xdmnvhalfq.png\" alt=\"staging-deploy job output\">\n   \u003Cfigcaption>Sortie du job staging-deploy\u003C/figcaption>\n\u003C/figure>\n\u003C/center>\n\u003Cp>\u003C/p>\n\nL'artefact est stocké dans le job __create-binary__ et utilisé dans le job __staging-deploy__. Et voilà, la migration d'un pipeline de Jenkins vers GitLab est aussi simple que cela !\n\n### Autres conseils à suivre lors de la migration\nVoici quelques conseils pratiques pour simplifier le processus de déploiement :\n\n- N'essayez pas de répliquer les tâches dans des jobs GitLab une à une. Prenez le temps de comprendre le fonctionnement du pipeline actuel et quel problème il résout.\n\n- Certains jobs Jenkins peuvent être trop complexes pour être migrés immédiatement vers GitLab. Il peut donc s'avérer pratique d'utiliser le [plug-in Jenkins GitLab](https://plugins.jenkins.io/gitlab-plugin/) pour lancer les pipelines Jenkins et afficher leurs résultats directement depuis GitLab. Cela vous permet de migrer lentement certaines actions vers GitLab jusqu'à ce que l'ensemble du pipeline puisse être déplacé.\n\n- Mettez en œuvre des [scanners de sécurité et une vérification de la qualité du code](https://docs.gitlab.com/ee/user/application_security/) à l'aide de templates intégrés fournis par GitLab. Cela vous permettra d'intégrer la sécurité en amont et ainsi de réduire le risque potentiel de failles. Simplifiez votre configuration CI/CD et essayez d'utiliser les avantages de chaque fonctionnalité sans tarder. Modularisez le code et implémentez-le en petites itérations.\n\n- Mettez en place le suivi et la gouvernance dès le départ.\n\n- Sachez que GitLab Runner (Go) peut se comporter différemment de l'agent Jenkins (Java). L'utilisation du processeur et la consommation de mémoire peuvent différer. Pensez à effectuer des comparaisons au fil du temps.\n\n- Envisagez d'investir dans des mécanismes de mise à l'échelle automatique et arrêtez les ressources inutiles le week-end ou en dehors des heures de travail.\n\n- Modernisez le développement d'applications en conteneurisant vos jobs. Les jobs Jenkins ne sont pas actuellement exécutés sur un conteneur, mais sur un agent Jenkins s'exécutant en tant que machine virtuelle.\n\nBien que cette liste ne soit pas exhaustive, elle constitue un bon point de départ. Si vous avez besoin d'une aide supplémentaire, GitLab fournit des [services professionnels](https://about.gitlab.com/fr-fr/get-help/) pour vous aider dans votre parcours de migration.\n\n### Conclusion\n\nMerci de votre intérêt pour cet article ! Nous espérons que ce guide vous a aidé à comprendre les avantages d'une migration de Jenkins vers GitLab, et comment procéder. \n\nVous hésitez encore ? [Essayez GitLab gratuitement](https://about.gitlab.com/fr-fr/free-trial/) et découvrez les avantages de notre plateforme DevSecOps.\n\nRessources complémentaires : \n\n- [Migration depuis Jenkins](https://docs.gitlab.com/ee/ci/migration/jenkins.html)\n- [Planification d'une migration](https://docs.gitlab.com/ee/ci/migration/plan_a_migration.html)\n- [Outils d'importation de projets GitLab](https://docs.gitlab.com/ee/user/project/import/)\n- [Migrer de GitHub Advanced Security vers GitLab Ultimate : notre guide complet](https://about.gitlab.com/fr-fr/blog/migration-guide-github-advanced-security-to-gitlab-ultimate/)\n- [Vidéo : Migration facile de GitHub vers GitLab](https://youtu.be/0Id5oMl1Kqs?feature=shared)\n- [De Jenkins vers GitLab : le guide ultime pour moderniser votre environnement CI/CD](https://about.gitlab.com/blog/jenkins-gitlab-ultimate-guide-to-modernizing-cicd-environment/)\n","devsecops",[9,859],"2025-03-18",{"slug":977,"featured":91,"template":691},"jenkins-to-gitlab-migration-made-easy","content:fr-fr:blog:jenkins-to-gitlab-migration-made-easy.yml","Jenkins To Gitlab Migration Made Easy","fr-fr/blog/jenkins-to-gitlab-migration-made-easy.yml","fr-fr/blog/jenkins-to-gitlab-migration-made-easy",{"_path":983,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":984,"content":990,"config":997,"_id":999,"_type":14,"title":1000,"_source":16,"_file":1001,"_stem":1002,"_extension":19},"/fr-fr/blog/prepare-now-docker-hub-rate-limits-will-impact-gitlab-ci-cd",{"title":985,"description":986,"ogTitle":985,"ogDescription":986,"noIndex":6,"ogImage":987,"ogUrl":988,"ogSiteName":673,"ogType":674,"canonicalUrls":988,"schema":989},"Nouvelles limites de Docker Hub : vos pipelines GitLab CI/CD sont impactés","Les nouvelles limites de Docker Hub relatives aux pulls d'images vont affecter les pipelines GitLab. Voici ce qu'il faut savoir.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749662488/Blog/Hero%20Images/blog-image-template-1800x945__3_.png","https://about.gitlab.com/blog/prepare-now-docker-hub-rate-limits-will-impact-gitlab-ci-cd","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Nouvelles limites de Docker Hub : vos pipelines GitLab CI/CD sont impactés\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Tim Rizzi\"}],\n        \"datePublished\": \"2025-03-24\",\n      }\n                  ",{"title":985,"description":986,"authors":991,"heroImage":987,"date":796,"body":992,"category":993,"tags":994,"updatedDate":996},[678],"Le 1er avril 2025, Docker va mettre en place de nouvelles [limites de débit relatives aux pulls d'images](https://docs.docker.com/docker-hub/usage/) sur Docker Hub, susceptibles d'impacter de manière significative les pipelines CI/CD de développement logiciel, y compris ceux qui s'exécutent sur GitLab. Le changement le plus notable : un plafond fixé à 10 pulls d'images par heure pour les utilisateurs non authentifiés.\n\n## Quels sont les changements attendus ?\n\nÀ compter du 1er avril, Docker va appliquer les limites strictes suivantes aux pulls d'images (téléchargements d'images) :\n\n| Type d'utilisateur | Limite de pulls d'images par heure | Nombre de dépôts publics | Nombre de dépôts privés |\n|-----------|--------------------------|-------------------------------|--------------------------------|\n| Business, Team, Pro (authentifié) | Illimité (utilisation raisonnable) | Illimité | Illimité |\n| Personal (authentifié) | 100 | Illimité | Jusqu'à 1 |\n| Utilisateurs non authentifiés | 10 par adresse IPv4 ou sous-réseau IPv6/64 | Non applicable | Non applicable |\n\nCes nouveaux quotas sont particulièrement importants pour les raisons suivantes :\n- Le proxy de dépendances de GitLab effectue actuellement des pulls à partir de Docker Hub en tant qu'utilisateur non authentifié.\n- La plupart des pipelines CI/CD qui n'utilisent pas le proxy de dépendances effectuent des pulls directement à partir de Docker Hub en tant qu'utilisateurs non authentifiés.\n- Pour les runners hébergés sur GitLab.com, le partage d'une même adresse IP ou sous-réseau par plusieurs utilisateurs les soumet collectivement à cette limite.\n\n## Quel impact sur les utilisateurs de GitLab ?\n\n**Impact sur les pulls directs depuis Docker Hub**\n\nSi vos pipelines CI/CD effectuent des pulls directement depuis Docker Hub sans authentification, ils seront limités à 10 pulls d'images par heure et par adresse IP. Dans le cas de pipelines exécutés fréquemment ou sur plusieurs projets partageant la même infrastructure de runner, cette limite sera rapidement atteinte, ce qui entraînera des échecs de pipeline.\n\n**Impact sur le proxy de dépendances de GitLab**\n\nLa fonctionnalité de proxy de dépendances de GitLab permet de mettre en cache des images Docker dans GitLab pour accélérer les pipelines et réduire la dépendance aux registres externes. Cependant, dans sa version actuelle, ce proxy effectue des pulls d'images depuis Docker Hub en tant qu'utilisateur non authentifié, ce qui signifie qu'il est lui aussi soumis à la limite des 10 pulls d'images par heure.\n\n**Impact sur les runners hébergés**\n\nSur GitLab.com, les runners hébergés s'appuient sur le [cache pull-through de Google Cloud](https://cloud.google.com/artifact-registry/docs/pull-cached-dockerhub-images?hl=fr), qui met en miroir les images fréquemment téléchargées. Cela permet d'éviter les limites de débit, comme pour les images de job définies comme `image:` ou `services:` dans votre fichier `.gitlab-ci.yml`.\n\nTout se complique légèrement lorsque les images sont téléchargées dans l'environnement du runner. Le cas le plus courant de pull d'images pendant l'exécution du runner concerne la création d'une image à l'aide de Docker-in-Docker ou de Kaniko. Dans ce scénario, l'image Docker Hub définie dans votre `Dockerfile` fait l'objet d'un pull directement depuis Docker Hub. Elle est donc susceptible d'être affectée par les limites de débit. \n\n## Comment GitLab répond à ces nouveaux quotas ?\n\nNous travaillons activement à la recherche de solutions pour atténuer les impacts liés à ces nouvelles limites :\n\n* **Authentification du proxy de dépendances :** nous avons ajouté la prise en charge de l'authentification Docker Hub dans la [fonctionnalité de proxy de dépendances de GitLab](https://gitlab.com/gitlab-org/gitlab/-/issues/331741). Cela permettra à ce dernier de télécharger des images depuis Docker Hub en tant qu'utilisateur authentifié, et ainsi d'augmenter considérablement les limites de débit.  \n* **Mise à jour de la documentation :** nous avons actualisé notre [documentation](https://docs.gitlab.com/user/packages/dependency_proxy/#configure-credentials) afin de fournir des instructions claires sur la configuration de l'authentification des pipelines pour Docker Hub.\n* **Préparation de l'infrastructure interne :** nous préparons notre infrastructure GitLab.com afin de réduire au maximum l'impact de ces limites sur les runners hébergés.\n\n## Comment s'y préparer ? \n\n**Option 1 : configurez l'authentification Docker Hub dans vos pipelines**\n\nSi vos pipelines effectuent des pulls directement depuis Docker Hub, vous pouvez configurer l'authentification afin d'augmenter votre limite de taux à 100 pulls d'images par heure (ou illimitée avec un abonnement payant à Docker Hub).\n\nPour cela, ajoutez vos identifiants de connexion Docker Hub aux variables CI/CD de votre projet ou groupe (ne les insérez pas directement dans le fichier `.gitlab-ci.yml`). Consultez les instructions détaillées de notre [documentation sur l'utilisation d'images Docker](https://docs.gitlab.com/ci/docker/using_docker_images/#use-statically-defined-credentials) pour configurer correctement la variable CI/CD `DOCKER_AUTH_CONFIG`.\n\n**Option 2 : utilisez le registre de conteneurs GitLab**\n\nEffectuez un push des images Docker que vous utilisez le plus souvent dans votre [registre de conteneurs GitLab](https://docs.gitlab.com/user/packages/container_registry/) afin d'éviter de devoir effectuer un pull d'images depuis Docker Hub pendant l'exécution des pipelines CI/CD. Procédez comme suit :\n\n1. Effectuez un pull de l'image depuis Docker Hub.\n2. Attribuez-lui un tag adapté à votre registre de conteneurs GitLab.\n3. Effectuez un push de l'image dans votre registre de conteneurs GitLab.\n4. Mettez à jour vos pipelines pour qu'ils effectuent un pull de l'image depuis le registre de conteneurs GitLab.\n\n```\ndocker pull busybox:latest\ndocker tag busybox:latest $CI_REGISTRY_IMAGE/busybox:latest\ndocker push $CI_REGISTRY_IMAGE/busybox:latest\n```\n\nPuis ajoutez cette ligne de commande dans votre fichier `.gitlab-ci.yml` :\n\n`image: $CI_REGISTRY_IMAGE/busybox:latest`\n\n**Option 3 : utilisez le proxy de dépendances de GitLab**\n\nLa fonctionnalité de proxy de dépendances de GitLab permet de mettre en cache les images Docker, tout en servant de proxy entre vos pipelines CI/CD et les registres Docker Hub, réduisant ainsi la dépendance aux registres externes et les risques liés aux limites de débit.  \n\nOptions d'authentification actuelles :\n* GitLab 17.10 : configurez l'authentification Docker Hub pour le proxy de dépendances à l'aide de l'[API GraphQL](https://docs.gitlab.com/user/packages/dependency_proxy/#configure-credentials-using-the-graphql-api).\n* GitLab 17.11 : utilisez la nouvelle interface de configuration dans les paramètres de votre groupe (déjà disponible sur GitLab.com).\n\nUne fois l'authentification correctement configurée, vous pouvez procéder comme suit :\n\n1. Configurez les identifiants de connexion Docker Hub dans les paramètres du proxy de dépendances de votre groupe :\n  - Pour GitLab 17.11+ (ou la version actuelle de GitLab.com) : accédez aux paramètres de votre groupe > Paquets et registres > Proxy de dépendances.\n  - Pour GitLab 17.10 : utilisez l'API GraphQL afin de configurer l'authentification.\n2. Mettez à jour vos pipelines de façon à ce qu'ils utilisent les URL du proxy de dépendances pour la configuration de votre pipeline CI/CD :\n`image:${CI_DEPENDENCY_PROXY_GROUP_IMAGE_PREFIX}/busybox:latest`\n\n**Option 4 : envisagez d'acheter un abonnement payant à Docker Hub**\n\nPour les équipes qui utilisent Docker Hub de manière intensive, la mise à niveau vers un abonnement Docker payant (Team ou Business) permet d'accéder à un nombre illimité de pulls, ce qui peut s'avérer la solution la plus simple.\n\n## Comment limiter l'impact des nouveaux quotas de Docker Hub ?\n\nQuelle que soit l'option que vous choisissez, tenez compte de ces bonnes pratiques pour réduire au maximum l'impact des nouvelles limites de débit imposées par Docker Hub :\n\n* Utilisez des tags d'image spécifiques au lieu de `latest` pour éviter les pulls inutiles.\n* Consolidez vos fichiers Docker de façon à ce qu'ils réutilisent les mêmes images de base dans tous vos projets.\n* Planifiez l'exécution des pipelines les moins critiques en dehors des heures de pointe.\n* Tirez parti intelligemment de la mise en cache pour éviter d'effectuer maintes fois un pull des mêmes images.\n\n**Remarque :** selon la [documentation](https://docs.docker.com/docker-hub/usage/pulls/#pull-definition) de Docker Hub, le nombre de pulls augmente dès que vous effectuez le pull d'un manifeste d'image, et non en fonction de la taille de l'image ou du nombre de couches.\n\n## Calendrier et prochaines étapes\n\n**Dès maintenant**\n  * Mettez en œuvre l'authentification pour les pulls directs depuis Docker Hub.\n  * Les utilisateurs de GitLab.com peuvent déjà configurer l'authentification Docker Hub pour le proxy de dépendances en utilisant :\n    * l'API GraphQL, ou\n    * l'interface utilisateur dans les paramètres de groupe.\n  * Les utilisateurs de GitLab Self-Managed 17.10 peuvent configurer l'authentification du proxy de dépendances à l'aide de l'API GraphQL.\n\n**1er avril 2025**\n  * Les limites de débit de Docker Hub entrent en vigueur.\n\n**17 avril 2025**\n  * Sortie de GitLab 17.11 qui prendra en charge l'authentification du proxy de dépendances via l'interface utilisateur pour les instances GitLab Self-Managed. \n\nNous vous recommandons d'appliquer ces mesures bien dès maintenant pour éviter des échecs de pipelines inattendus. Pour la plupart des utilisateurs, configurer le proxy de dépendances avec l'authentification Docker Hub est la solution la plus efficace à long terme.\n\n> Vous avez des questions ou besoin d'aide pour la mise en œuvre ? Consultez [ce ticket](https://gitlab.com/gitlab-org/gitlab/-/issues/526605) dans lequel notre équipe fournit une assistance dédiée à ces changements.","bulletin-board",[9,995,685],"news","2025-03-28",{"slug":998,"featured":91,"template":691},"prepare-now-docker-hub-rate-limits-will-impact-gitlab-ci-cd","content:fr-fr:blog:prepare-now-docker-hub-rate-limits-will-impact-gitlab-ci-cd.yml","Prepare Now Docker Hub Rate Limits Will Impact Gitlab Ci Cd","fr-fr/blog/prepare-now-docker-hub-rate-limits-will-impact-gitlab-ci-cd.yml","fr-fr/blog/prepare-now-docker-hub-rate-limits-will-impact-gitlab-ci-cd",{"_path":1004,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":1005,"content":1010,"config":1019,"_id":1021,"_type":14,"title":1022,"_source":16,"_file":1023,"_stem":1024,"_extension":19},"/fr-fr/blog/seamlessly-migrate-from-jira-to-gitlab-with-jira2lab-at-scale",{"title":1006,"description":1007,"ogTitle":1006,"ogDescription":1007,"noIndex":6,"ogImage":671,"ogUrl":1008,"ogSiteName":673,"ogType":674,"canonicalUrls":1008,"schema":1009},"Jira vers GitLab : migrer facilement à grande échelle avec Jira2Lab","Découvrez comment Jira2GitLab simplifie les migrations à grande échelle de Jira vers GitLab en gérant des transferts de données complexes, en améliorant l'évolutivité et en assurant une intégration efficace.","https://about.gitlab.com/blog/seamlessly-migrate-from-jira-to-gitlab-with-jira2lab-at-scale","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Jira vers GitLab : migrer facilement à grande échelle avec Jira2Lab\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Maximilien Belinga\"}],\n        \"datePublished\": \"2024-10-10\",\n      }",{"title":1006,"description":1007,"authors":1011,"heroImage":671,"date":1013,"body":1014,"category":1015,"tags":1016,"updatedDate":1018},[1012],"Maximilien Belinga","2024-10-10","[Atlassian Server n'est plus disponible depuis février](https://about.gitlab.com/fr-fr/move-to-gitlab-from-atlassian/), ce qui a incité de nombreux clients à explorer des alternatives telles qu'Atlassian Cloud ou Data Center. Cependant, les entreprises qui utilisaient Atlassian Server recherchent de plus en plus des solutions de planification Agile offrant une flexibilité améliorée, une rentabilité plus élevée et une intégration DevSecOps robuste. Elles doivent également relever des défis liés au volume de données, à la personnalisation, au mappage utilisateur, aux performances et à l'intégrité des données pendant la migration. C'est là qu'intervient [Jira2Lab de GitLab](https://gitlab.com/gitlab-org/professional-services-automation/tools/migration/jira2lab). Jira2Lab apporte une solution qui permet des migrations à grande échelle de Jira vers GitLab, tout en offrant une intégration [CI/CD](https://about.gitlab.com/fr-fr/topics/ci-cd/ \"Qu'est-ce que le CI/CD ?\") complète.\n\n## Quels sont les principaux défis des migrations Jira à grande échelle ? \n\nLa migration de Jira vers GitLab peut représenter un obstacle majeur, en particulier lorsque les entreprises ont des workflows complexes et doivent déplacer des milliers de tickets. \n\nVoici les défis les plus courants rencontrés lors de ces migrations :\n\n- **Migration massive de données :** la complexité de la migration qui doit être effectuée sans problèmes de performance ni perte de données augmente proportionnellement avec le nombre de tickets, de pièces jointes, de commentaires et de projets qu'elle inclut.\n\n- **Champs et workflows personnalisés :** les instances Jira contiennent souvent des workflows, des champs et des types de tickets personnalisés qui n'ont pas de mappage individuel dans GitLab. Cet écart crée des frictions lors de la migration, car les outils existants nécessitent souvent une intervention manuelle pour déplacer ces éléments.\n\n- **Absence d'intégration DevSecOps complète :** bien que de nombreux outils de migration gèrent les données de gestion des projets, ils n'intègrent pas toutes les fonctionnalités [DevSecOps](https://about.gitlab.com/fr-fr/topics/devsecops/ \"Qu'est-ce que DevSecOps ?\") de GitLab. En conséquence, les équipes doivent configurer manuellement leurs [pipelines CI/CD](https://about.gitlab.com/fr-fr/topics/ci-cd/cicd-pipeline/ \"Qu'est-ce qu'un pipeline CI/CD ?\") et leurs systèmes de [contrôle de version](https://about.gitlab.com/fr-fr/topics/version-control/ \"Qu'est-ce que le contrôle de version ?\") après la migration.\n\n## Présentation de Jira2Lab\n\nJira2Lab a été entièrement conçu pour résoudre les défis spécifiques à la migration de Jira vers GitLab à grande échelle. Il ne s'agit pas seulement de déplacer des données, mais aussi de permettre aux équipes de passer sans accroc au puissant environnement DevSecOps de GitLab sans temps d’arrêt ni perte de données.\n\n### Quelles sont les principales fonctionnalités de Jira2Lab ? \n\n1. Traitement efficace des données à grande échelle : Jira2Lab est optimisé pour gérer des milliers de tickets, de pièces jointes, de commentaires et de champs personnalisés sur plusieurs projets sans sacrifier les performances. Il s'adapte à tous les besoins, même pour les plus grandes migrations d'entreprise.\n\n2. Workflow personnalisé et mappage des champs : l'une des fonctionnalités de Jira2Lab est sa capacité à associer automatiquement des workflows et des champs personnalisés entre Jira et GitLab. L'outil fournit une configuration de mappage flexible qui élimine les interventions manuelles pendant le processus de migration, en veillant à ce que toutes les données passent sans accroc de Jira vers GitLab.\n\n3. Intégration du pipeline CI/CD : Jira2Lab ne se contente pas de migrer vos tickets et vos projets. L'outil intègre le pipeline CI/CD complet de GitLab dans le processus de migration. Les équipes de développement peuvent ainsi commencer à utiliser les fonctionnalités DevSecOps de GitLab, telles que les tests automatisés et les pipelines de déploiement, immédiatement après la migration.\n\n4. Migrations pilotes : notre outil prend en charge les migrations pilotes pour permettre aux équipes de tester leurs configurations et leurs workflows avant de migrer l'ensemble des données. Tous les problèmes sont détectés rapidement, ce qui évite les interruptions pendant la migration complète.\n\n5. Surveillance en temps réel : l'outil fournit une surveillance et des journaux en temps réel pendant la migration. Cette transparence totale assure que chaque étape est effectuée correctement et sans erreurs.\n\n6. Personnalisation et flexibilité : même si votre instance Jira dispose de configurations ou de workflows uniques, Jira2Lab vous permet de personnaliser la migration en fonction de vos besoins spécifiques, en veillant à ce que rien ne soit perdu au cours de la transition.\n\n### Comparaison des fonctionnalités : Jira et GitLab\n\nLa migration de Jira vers GitLab permet de consolider les workflows et d'accéder aux fonctionnalités avancées natives de GitLab. Voici une comparaison rapide des principales fonctionnalités des deux plateformes :\n\n| **Fonctionnalité**             | **Jira**                        | **GitLab**                    |\n|-------------------------|----------------------------------|-------------------------------|\n| **Suivi des tickets**       | Oui (Hautement personnalisable)       | Oui (Intégré au DevSecOps)   |\n| **Tableaux Agile**         | Oui (tableau Kanban, Scrum)             | Oui (Tableaux des tickets, jalons) |\n| **CI/CD**                | Non (Requiert des outils externes)    | Oui (CI/CD intégré)           |\n| **Contrôle de version**       | Non (Requiert GitHub/Bitbucket)  | Oui (Prise en charge native de [Git](https://about.gitlab.com/fr-fr/blog/what-is-git/ \"Qu'est-ce que Git ? \"))       |\n| **Outils DevSecOps**         | Intégrations limitées            | Cycle de vie DevSecOps complet          |\n\nAvec Jira2Lab, nous veillons à ce que tous les aspects critiques, de la gestion des tickets aux pipelines CI/CD, soient transférés sans heurts. Pour ce faire, nous tirons parti de l'approche intégrée de GitLab en matière de développement et d’opérations.\n\n## La méthodologie de migration\n\nJira2Lab suit une méthodologie de migration structurée en cinq étapes. Cette approche garantit une transition fluide avec un minimum de perturbations :\n\n### 1. Découverte et planification\n\nNous commençons par bien comprendre la configuration Jira du client en identifiant tous les workflows, champs et projets personnalisés qui doivent être migrés. Cette étape implique également une analyse des lacunes pour comparer les fonctionnalités de Jira et de GitLab et planifier le processus de migration.\n\n### 2. Configuration\nAu cours de cette étape, nous configurons l'outil de migration et mettons en place les environnements nécessaires pour Jira et GitLab. Nous vérifions toutes les autorisations et configurons la sauvegarde des données Jira avant le début de la migration.\n\n### 3. Migrations pilotes\nAvant de migrer l'ensemble des données, nous exécutons des migrations pilotes sur des projets sélectionnés afin de tester le processus de migration, les workflows et l'intégrité des données. Nous avons ainsi l'opportunité d'identifier et de résoudre tout problème dès le début du processus.\n\n### 4. Migrations à l'échelle\nAprès avoir validé la migration pilote, nous effectuons la migration de tous les projets, en garantissant des temps d'arrêt minimaux et des transitions en douceur pour les équipes de développement.\n\n### 5. Finalisation et assistance post-migration\nUne fois la migration terminée, nous fournissons une assistance continue afin de garantir que toutes les équipes sont pleinement opérationnelles dans GitLab. Cette étape comprend également la formation des utilisateurs et la désactivation de l'instance Jira, si nécessaire.\n\n## Étude de cas : migration à grande échelle avec Jira2Lab\n\nLors d'une migration récente, une grande entreprise a dû relever le défi de migrer plus de 20 000 tickets sur 50 projets de Jira vers GitLab. Le projet comportait des workflows hautement personnalisés et des milliers de commentaires et de pièces jointes à transférer.\n\nAvec Jira2Lab, nous avons pu :\n\n- Migrer toutes les données, y compris les champs personnalisés, sans aucune perte de données.\n- Configurer des pipelines CI/CD dans GitLab afin que les équipes puissent immédiatement poursuivre leur travail après la migration.\n- Effectuer une migration pilote de deux projets, ce qui nous a permis d'identifier et de corriger des écarts mineurs dans les workflows avant d'effectuer la migration pour l'ensemble de l'entreprise.\n\nEn conséquence, la transition vers GitLab s'est déroulée en toute fluidité. L'ensemble du processus s'est effectué dans les délais prévus et sans temps d'arrêt significatif.\n\n## Commencez dès aujourd'hui avec Jira2Lab\n\nL'outil Jira2Lab apporte une solution aux limitations que d'autres outils de migration ne peuvent pas gérer. Il est conçu spécifiquement pour les migrations à grande échelle et peut s'intégrer au cycle de vie DevSecOps complet de GitLab, contrairement à la plupart des outils qui ne gèrent que les données de gestion de projet. La capacité de l'outil à cartographier des workflows personnalisés et à intégrer des pipelines CI/CD en fait la solution idéale pour les entreprises qui souhaitent améliorer leurs workflows de développement tout en migrant vers GitLab.\n\n> Vous souhaitez faire évoluer vos processus de développement avec GitLab ? Explorez notre [catalogue de services professionnels](https://about.gitlab.com/services/catalog/) pour découvrir comment nous pouvons aider votre équipe à migrer de manière efficace et efficiente. Contactez-nous via le formulaire en bas de page pour planifier une démonstration personnalisée de Jira2Lab de GitLab.\n","agile-planning",[1017,9,859,750,686],"agile","2025-01-02",{"slug":1020,"featured":91,"template":691},"seamlessly-migrate-from-jira-to-gitlab-with-jira2lab-at-scale","content:fr-fr:blog:seamlessly-migrate-from-jira-to-gitlab-with-jira2lab-at-scale.yml","Seamlessly Migrate From Jira To Gitlab With Jira2lab At Scale","fr-fr/blog/seamlessly-migrate-from-jira-to-gitlab-with-jira2lab-at-scale.yml","fr-fr/blog/seamlessly-migrate-from-jira-to-gitlab-with-jira2lab-at-scale",{"_path":1026,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":1027,"content":1033,"config":1040,"_id":1042,"_type":14,"title":1043,"_source":16,"_file":1044,"_stem":1045,"_extension":19},"/fr-fr/blog/tutorial-automated-release-and-release-notes-with-gitlab",{"ogTitle":1028,"schema":1029,"ogImage":1030,"ogDescription":1031,"ogSiteName":673,"noIndex":6,"ogType":674,"ogUrl":1032,"title":1028,"canonicalUrls":1032,"description":1031},"Automatisez vos sorties et notes de version avec GitLab","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Tutoriel : Automatisez vos sorties et notes de version avec GitLab\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Ben Ridley\"}],\n        \"datePublished\": \"2023-11-01\",\n      }","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749659978/Blog/Hero%20Images/automation.png","Découvrez comment automatiser vos livraisons de logiciels avec l'API Changelog de GitLab : créez des artefacts, changelogs complets et notes de version clairs.","https://about.gitlab.com/blog/tutorial-automated-release-and-release-notes-with-gitlab",{"heroImage":1030,"body":1034,"authors":1035,"updatedDate":1037,"date":1038,"title":1028,"tags":1039,"description":1031,"category":686},"**Mise à jour 2025** : l'API Changelog de GitLab continue d'évoluer et offre\ndésormais de nouvelles fonctionnalités avancées, telles que la génération de\nchangelogs personnalisés basés sur l'historique de vos commits. Ces\nnouveautés ne sont pas détaillées dans cet article, mais vous pouvez les\nconsulter dans notre[ documentation officielle dédiée aux\nchangelogs.](https://docs.gitlab.com/user/project/changelogs/)\n\n\nLorsque vous développez un logiciel dont les utilisateurs se servent au quotidien, il est essentiel de les informer des modifications apportées à chaque nouvelle version (nouvelles fonctionnalités, modifications ou suppressions). Ils peuvent ainsi tirer pleinement parti du logiciel et éviter les mauvaises surprises lors des mises à niveau.\n\n\nMais historiquement, rédiger les notes de version et maintenir un changelog ont toujours été des tâches laborieuses qui obligent les équipes et les Release Managers à passer au crible les modifications et l'historique des merge requests. Désormais, avec l'API Changelog de GitLab, vous pouvez tirer parti de l'historique détaillé des modifications enregistrées dans votre dépôt [Git](https://about.gitlab.com/fr-fr/blog/what-is-git/ \"Qu'est-ce que Git ?\") pour créer automatiquement des notes de version et tenir à jour votre changelog.\n\n\nDécouvrez dans ce tutoriel comment intégrer cette automatisation dans vos [pipelines CI/CD](https://about.gitlab.com/fr-fr/topics/ci-cd/cicd-pipeline/ \"Qu'est-ce qu'un pipeline CI/CD ?\").\n\n\n## Sorties de nouvelles versions dans GitLab\n\n\nDans GitLab, une nouvelle version correspond à une version spécifique de votre code, identifiée par un tag git. Elle regroupe les modifications apportées depuis la dernière version, les notes de version associées, ainsi que tous les artefacts générés à partir de cette version du code, tels que les images Docker, les paquets d'installation et la documentation.\n\n\nVous pouvez créer et suivre les sorties de ces nouvelles versions dans GitLab à l'aide de l'interface utilisateur en appelant notre API Release ou en définissant un job de `release` dans un pipeline CI. Nous utiliserons ce dernier dans ce tutoriel afin de bénéficier de l'automatisation déjà en place pour les tests, les scans du code et les autres étapes de validation, et d'automatiser également les sorties de nouvelles versions.\n\n\nNous devons d'abord disposer d'un historique clair de toutes les modifications apportées. C'est ce que fournit précisément le dépôt Git via les messages de commit et le suivi des merge requests. Ce dernier garantit une génération automatisée et fiable des notes de version et du changelog. \n\n\n## Lignes terminales dans un commit\n\n\nLes [lignes terminales dans un commit Git](https://git-scm.com/docs/git-interpret-trailers/fr) sont des métadonnées structurées ajoutées en fin de vos messages de commit, sous la forme simple `\u003CHEADER>:\u003CBODY>`. L'interface de ligne de commande `git` peut ensuite les analyser et les extraire pour les utiliser dans d'autres systèmes, par exemple via la commande `git commit --sign-off` qui permet de confirmer un commit en y ajoutant une ligne terminale `Signed-off-by: \u003CVotre nom>`. Vous pouvez y ajouter n'importe quelle information structurée. Il s'agit donc d'un emplacement idéal pour stocker des métadonnées, et dans notre exemple, pour générer automatiquement notre changelog.\n\n\nEn ajoutant la ligne terminale `Changelog: \u003Cadded/changed/removed>` à la fin de nos messages de commit, l'API Changelog de GitLab l'analysera et créera automatiquement un changelog.\n\n\nNous allons illustrer ce mécanisme en apportant quelques modifications à un code source existant afin de sortir une nouvelle version et de générer automatiquement ses notes de version et les entrées du changelog correspondant.\n\n\n## Exemple concret avec une application Python\n\n\nPartons d'un dépôt contenant une application web simple écrite en Python. Supposons que la version 1.0.0 de cette application vient de sortir et représente l'état actuel du code, et qu'elle a été créée manuellement dans GitLab, sans pipeline de sortie de nouvelle version automatisé :\n\n\n![Capture d'écran de l'interface utilisateur de GitLab montrant la sortie de la nouvelle version 1.0.0](https://about.gitlab.com/images/blogimages/2023-08-22-automated-release-and-release-notes-with-gitlab/1-0-release.png)\n\n\n## Modifications en vue de la version 2.0.0\n\n\nComme nous sommes en mode de développement rapide, nous allons travailler sur la sortie de la version 2.0.0 de notre application dès aujourd'hui. Celle-ci introduira une fonctionnalité de chatbot et supprimera la fonctionnalité de blockchain quantique, qui servait uniquement à impressionner les investisseurs lors de notre premier cycle de financement par capital-risque. Nous allons également ajouter un job de sortie de nouvelle version automatisé à notre pipeline CI/CD.\n\n\nTout d'abord, nous devons supprimer les fonctionnalités obsolètes à l'aide d'une merge request qui contient les suppressions nécessaires en veillant à ce que le message de commit inclue la ligne terminale `Changelog: removed`. Pour cela, nous pouvons par exemple l'inclure directement dans un commit, ou effectuer un [rebasage interactif](https://about.gitlab.com/fr-fr/blog/keep-git-history-clean-with-interactive-rebase/ \"Qu'est-ce que le rebasage interactif ?\") et l'ajouter à l'aide de l'interface de ligne de commande (CLI). \n\n\nMais dans notre exemple, nous traiterons cette étape en dernier, et utiliserons plutôt le bouton `Modifier le message de commit` dans GitLab pour ajouter la ligne terminale au commit comme suit :\n\n\n![Capture d'écran de l'interface utilisateur de GitLab montrant une merge request supprimant les fonctionnalités inutilisées](https://about.gitlab.com/images/blogimages/2023-08-22-automated-release-and-release-notes-with-gitlab/remove-unused-features-mr.png)\n\n\nVous pouvez également modifier le titre du commit pour qu'il soit plus concis. Nous allons donc renommer notre commit « Supprimer les fonctionnalités inutilisées », pour que ce titre apparaisse dans le changelog.\n\n\nEnsuite, ajoutons de nouvelles fonctionnalités pour la version 2.0.0. Là encore, il suffit d'ouvrir une autre merge request qui inclut nos nouvelles fonctionnalités, de modifier le commit pour inclure la ligne terminale `Changelog: added`, puis de modifier son titre pour qu'il soit plus concis :\n\n\n![Capture d'écran de l'interface utilisateur de GitLab montrant une merge request servant à ajouter de nouvelles fonctionnalités](https://about.gitlab.com/images/blogimages/2023-08-22-automated-release-and-release-notes-with-gitlab/add-chatbot-mr.png)\n\n\nNous sommes maintenant prêts à publier la version 2.0.0. Mais cette fois-ci, au lieu de la créer manuellement, nous allons ajouter les jobs nécessaires à notre fichier `.gitlab-ci.yml` : ils gèreront automatiquement la sortie de la nouvelle version à notre place et généreront les notes de version et les entrées du changelog lorsque nous ajouterons à notre code le tag `2.0.0` en référence à la nouvelle version.\n\n\n**Remarque :** pour ajouter facilement des lignes terminales de changelog, utilisez un outil comme [Danger, qui permet de vérifier automatiquement le respect des conventions dans les merge requests](https://docs.gitlab.com/ee/development/dangerbot.html).\n\n\n## Création d'un pipeline automatisé de sortie de nouvelle version\n\n\nLa première étape consiste à créer un token d'accès au projet qui nous permettra d'appeler l'API de GitLab afin de générer les entrées de notre changelog. [Créons un token d'accès au projet avec la portée de l'API](https://docs.gitlab.com/ee/user/project/settings/project_access_tokens.html#create-a-project-access-token), puis [stockons-le dans les variables CI/CD](https://docs.gitlab.com/ee/ci/variables/#define-a-cicd-variable-in-the-ui) du projet sous le nom `CI_API_JETON`. Nous référencerons cette variable à des fins d'authentification auprès de l'API.\n\n\nEnsuite, ajoutons deux nouveaux jobs à notre fichier `gitlab-ci.yml` :\n\n\n```yaml\n\nprepare_job:\n  stage: prepare\n  image: alpine:latest\n  rules:\n  - if: '$CI_COMMIT_TAG =~ /^v?\\d+\\.\\d+\\.\\d+$/'\n  script:\n    - apk add curl jq\n    - 'curl -H \"PRIVATE-TOKEN: $CI_API_TOKEN\" \"$CI_API_V4_URL/projects/$CI_PROJECT_ID/repository/changelog?version=$CI_COMMIT_TAG\" | jq -r .notes > release_notes.md'\n  artifacts:\n    paths:\n    - release_notes.md\n\nrelease_job:\n  stage: release\n  image: registry.gitlab.com/gitlab-org/release-cli:latest\n  needs:\n    - job: prepare_job\n      artifacts: true\n  rules:\n  - if: '$CI_COMMIT_TAG =~ /^v?\\d+\\.\\d+\\.\\d+$/'\n  script:\n    - echo \"Creating release\"\n  release:\n    name: 'Release $CI_COMMIT_TAG'\n    description: release_notes.md\n    tag_name: '$CI_COMMIT_TAG'\n    ref: '$CI_COMMIT_SHA'\n    assets:\n      links:\n        - name: 'Container Image $CI_COMMIT_TAG'\n          url: \"https://$CI_REGISTRE_IMAGE/$CI_COMMIT_REF_SLUG:$CI_COMMIT_SHA\"\n```\n\n\nDans notre configuration, le job `prepare_job` utilise `curl` et `jq` pour appeler le point de terminaison de l'API Changelog de GitLab, puis transmet le résultat à notre job `release_job` chargé de créer automatiquement la nouvelle version. \n\n\nVoici les principaux éléments à retenir :\n\n\n* Nous utilisons le token d'accès au projet créé précédemment pour appeler l'API Changelog de GitLab, qui génère les notes de version que nous stockons en tant qu'artefact.\n\n* Nous utilisons la variable `$CI_COMMIT_TAG` pour identifier la version. Pour que l'API Changelog fonctionne correctement, nous devons utiliser la gestion sémantique de version pour nos tags (par exemple, `2.0.0`). Nous avons également restreint le job de sortie de nouvelle version à l'aide d'une règle spécifique dans la section `rules`, qui vérifie la présence d'un tag de version sémantique.\n\n  * La gestion sémantique de version est nécessaire pour que l'API Changelog de GitLab déclenche le job. Elle utilise ce format pour trouver la version la plus récente à comparer à notre version actuelle.\n* Nous utilisons l'image `release-cli` officielle de GitLab, indispensable pour exploiter le terme `release` dans un job.\n\n* Nous utilisons le terme `release` pour créer une sortie de nouvelle version dans GitLab et pour le remplissage des champs obligatoires.\n\n* Nous pouvons transmettre un fichier en tant qu'argument pour la `description` de la nouvelle version. Dans notre exemple, il s'agit du fichier que nous avons généré lors du job `prepare_job`, puis transmis à ce job sous forme d'artefact.\n\n* Nous avons également inclus notre image de conteneur, qui a été compilée plus tôt dans le pipeline, en tant que ressource associée à la nouvelle version. Vous pouvez également y joindre les ressources de votre choix, générées lors de votre processus de compilation, telles que des binaires ou de la documentation, à condition de fournir l'URL redirigeant vers l'endroit où vous les avez chargés plus tôt dans le pipeline.\n\n\n## Automatisation d'une sortie de nouvelle version\n\n\nAvec cette configuration, il suffit d'effectuer le push d'un tag respectant notre schéma de gestion des versions vers notre dépôt à l'aide de la CLI ou comme dans notre exemple, directement depuis l'interface utilisateur de GitLab, sur la branche principale, en sélectionnant Code -> Tags -> Nouveau tag dans la barre latérale :\n\n![Capture d'écran de l'interface utilisateur de GitLab montrant comment créer un tag](https://about.gitlab.com/images/blogimages/2023-08-22-automated-release-and-release-notes-with-gitlab/create-2-tag.png)\n\n\nDès la création du tag, nos pipelines commenceront à s'exécuter automatiquement. L'API Changelog de GitLab génère alors des notes de version au format markdown contenant toutes les modifications apportées entre cette version et la version précédente. \n\n\nVoici un extrait du markdown généré dans notre exemple :\n\n\n```md\n\n## 2.0.0 (2023-08-25)\n\n\n### added (1 change)\n\n\n- [Add ChatBot](gl-demo-ultimate-bridley/super-devsecops-incorporated/simply-notes-release-demo@0c3601a45af617c5481322bfce4d71db1f911b02) ([merge request](gl-demo-ultimate-bridley/super-devsecops-incorporated/simply-notes-release-demo!4))\n\n\n### removed (1 change)\n\n\n- [Remove Unused Features](gl-demo-ultimate-bridley/super-devsecops-incorporated/simply-notes-release-demo@463d453c5ae0f4fc611ea969e5442e3298bf0d8a) ([merge request](gl-demo-ultimate-bridley/super-devsecops-incorporated/simply-notes-release-demo!3))\n\n```\n\n\nComme vous pouvez le constater, GitLab a extrait automatiquement les entrées de nos notes de version à l'aide des lignes terminales que nous avons intégrées dans nos messages de commit Git. De plus, des notes incluent des liens vers la merge request associée pour accéder rapidement aux compléments d'information et discussions relatifs aux modifications.\n\n\nVoici notre nouvelle version 2.0.0 :\n\n![Interface utilisateur de la nouvelle version de GitLab montrant la nouvelle version 2.0.0](https://about.gitlab.com/images/blogimages/2023-08-22-automated-release-and-release-notes-with-gitlab/2-0-release.png)\n\n\n## Automatisation de la mise à jour du changelog\n\n\nPour maintenir à jour votre changelog (soit l'historique rassemblant toutes vos notes de version), vous pouvez effectuer une requête `POST` vers le point de terminaison de l'API Changelog utilisé précédemment.\n\n\nSi vous effectuez cette opération dans le cadre de votre pipeline de nouvelle version, intégrez cette étape en ajoutant ce qui suit à la section `script` de votre job de préparation :\n\n\n```sh\n\n'curl -H \"PRIVATE-TOKEN: $CI_API_TOKEN\" -X POST \"$CI_API_V4_URL/projects/$CI_PROJECT_ID/repository/changelog?version=$CI_COMMIT_TAG\"\n\n```\n\n\n**Notez que cette opération modifie le dépôt** en créant un commit qui ajoute les notes de la nouvelle version à un fichier `CHANGELOG.md` :\n\n![Capture d'écran du dépôt montrant une validation mettant à jour le fichier changelog](https://about.gitlab.com/images/blogimages/2023-08-22-automated-release-and-release-notes-with-gitlab/changelog-api-commit.png)\n\n\nEt voilà, nous avons terminé ! En utilisant l'historique détaillé fourni par `git` avec quelques lignes terminales de commit pratiques, nous pouvons tirer parti de la puissante de l'API et des pipelines CI/CD de GitLab pour automatiser notre processus de sortie de nouvelle version et de génération de notes de version.\n\n\n> Pour découvrir le projet utilisé dans ce tutoriel, [consultez ce lien](https://gitlab.com/gitlab-learn-labs/sample-projects/release-automation-demo).\n",[1036],"Ben Ridley","2025-07-09","2023-11-01",[774,9,927,859,952],{"slug":1041,"featured":6,"template":691},"tutorial-automated-release-and-release-notes-with-gitlab","content:fr-fr:blog:tutorial-automated-release-and-release-notes-with-gitlab.yml","Tutorial Automated Release And Release Notes With Gitlab","fr-fr/blog/tutorial-automated-release-and-release-notes-with-gitlab.yml","fr-fr/blog/tutorial-automated-release-and-release-notes-with-gitlab",{"_path":1047,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":1048,"content":1053,"config":1060,"_id":1062,"_type":14,"title":1063,"_source":16,"_file":1064,"_stem":1065,"_extension":19},"/fr-fr/blog/ultimate-guide-to-ci-cd-fundamentals-to-advanced-implementation",{"ogTitle":1049,"schema":1050,"ogImage":701,"ogDescription":1051,"ogSiteName":673,"noIndex":6,"ogType":674,"ogUrl":1052,"title":1049,"canonicalUrls":1052,"description":1051},"Approche CI/CD : notre guide complet","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Guide complet sur l'approche CI/CD : des principes fondamentaux à la mise en œuvre avancée\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Sandra Gittlen\"}],\n        \"datePublished\": \"2025-06-25\",\n      }\n                  ","Découvrez comment transformer vos processus CI/CD en automatisant le développement et la livraison de logiciels tout en renforçant la sécurité des pipelines.","https://about.gitlab.com/blog/ultimate-guide-to-ci-cd-fundamentals-to-advanced-implementation",{"title":1049,"description":1051,"authors":1054,"heroImage":701,"date":1056,"body":1057,"category":973,"tags":1058},[1055],"Sandra Gittlen","2025-06-25","L'adoption des pratiques [CI/CD](https://about.gitlab.com/fr-fr/topics/ci-cd/ \"Qu'est-ce que le CI/CD ?\") a révolutionné la création de valeur dans le développement logiciel. L'époque des déploiements manuels et des défis d'intégration complexes est désormais révolue : aujourd'hui, le développement logiciel moderne met l'accent sur l'automatisation, la fiabilité et la rapidité.\n\nL'approche CI/CD repose sur la mise en place d'un pipeline fluide et automatisé qui permet de transférer le code de l'environnement de développement vers l'environnement de production, tout en intégrant les retours et suggestions de modification en temps réel. L'intégration continue (CI) aide les équipes à détecter rapidement les problèmes avant qu'ils ne deviennent coûteux. Les modifications de code sont fréquemment fusionnées dans un dépôt partagé, puis testées automatiquement et validées. La livraison continue (CD) vient compléter cette démarche. Elle vise à automatiser le processus de déploiement, rendant les sorties de nouvelles versions prévisibles et harmonieuses.\n\nGrâce à un pipeline CI/CD robuste, les équipes peuvent compiler, tester et déployer leurs logiciels sans dépendre de processus manuels ou de chaînes d’outils complexes. L'intégration de l'IA aide à optimiser encore davantage ce processus, en générant automatiquement des pipelines CI/CD qui garantissent la cohérence des contrôles de qualité, de conformité et de sécurité.\n\nDécouvrez dans ce guide tout ce que vous devez sur les pipelines CI/CD modernes, des principes de base aux bonnes pratiques, en passant par les stratégies avancées. Apprenez également comment les grandes entreprises leaders dans leur domaine tirent parti de l'approche CI/CD pour atteindre des résultats impressionnants. À l’issue de cette lecture, vous saurez comment faire évoluer votre environnement [DevSecOps](https://about.gitlab.com/fr-fr/topics/devsecops/ \"Qu'est-ce que le DevSecOps ?\") afin de développer et de livrer des logiciels de manière [agile](https://about.gitlab.com/fr-fr/topics/ci-cd/continuous-integration-agile/ \"Intégration continue et développement agile\"), automatisée et efficace.\n\n## Qu'est-ce que l'intégration continue ?\n\nL'[intégration continue](https://about.gitlab.com/fr-fr/topics/ci-cd/benefits-continuous-integration/ \"Qu'est-ce que l’intégration continue ?\") (CI) est une pratique qui consiste à intégrer régulièrement les modifications de code dans la branche principale d'un dépôt de code source partagé. Cette intégration s'effectue dès que possible, et fréquemment. Après chaque validation ou merge, les modifications sont automatiquement testées, puis une compilation est déclenchée sans intervention manuelle. Grâce à l'intégration continue, les équipes peuvent identifier et corriger les erreurs, ainsi que les failles de sécurité, plus facilement et beaucoup plus tôt dans le processus de développement.\n\n## Qu'est-ce que la livraison continue ?\n\n[La livraison continue](https://about.gitlab.com/fr-fr/topics/ci-cd/#what-is-continuous-delivery-cd \"Qu'est-ce que la livraison continue ?\") (CD), également appelée *déploiement continu*, automatise le processus de mise en production des applications. Les équipes de développement ont ainsi plus de temps à consacrer au suivi des déploiements en cours pour en garantir la réussite. Avec la livraison continue, les équipes DevSecOps définissent à l'avance les critères de mise à disposition du code. Une fois ces critères remplis et validés, le code est automatiquement déployé dans l'environnement de production. Cette automatisation permet aux entreprises de gagner en flexibilité et de mettre plus rapidement de nouvelles fonctionnalités à disposition des utilisateurs.\n\n## Quel est le lien entre la gestion du code source et l'approche CI/CD ?\n\nLa [gestion du code source (SCM)](https://about.gitlab.com/fr-fr/solutions/source-code-management/ \"Gestion du code source\") et l'approche CI/CD constituent la base des pratiques modernes de développement logiciel. Les systèmes SCM, comme [Git](https://about.gitlab.com/blog/what-is-git-the-ultimate-guide-to-gits-role-and-functionality/ \"Qu'est-ce que Git?\"), offrent une solution centralisée pour suivre les modifications, gérer les versions de code et faciliter la collaboration entre les membres de l'équipe. Lorsqu’un développeur travaille sur une nouvelle fonctionnalité ou une correction de bogues, il crée une branche à partir du code source et apporte ses modifications avant de les [fusionner à l'aide des merge requests](https://docs.gitlab.com/ee/user/project/merge_requests/). Cette stratégie de gestion de branches permet à plusieurs développeurs de travailler simultanément sans interférer avec le code de leurs collègues, tout en maintenant une branche principale stable qui contient un code prêt à être déployé dans l'environnement de production.\n\nL'approche CI/CD automatise les étapes de compilation, de test et de validation du code géré par le système SCM à chaque push de modifications. Lorsqu'un développeur soumet ses modifications de code, le système CI/CD récupère automatiquement le code le plus récent, le combine avec le code source existant, puis exécute une série de vérifications automatisées. Celles-ci comprennent généralement la compilation du code, l'exécution de tests unitaires, l'analyse statique du code et la vérification de la couverture de code. En cas d’échec d’une de ces étapes, l'équipe en est immédiatement informée, ce qui lui permet de résoudre les problèmes avant qu'ils n'affectent d'autres développeurs ou qu'ils n’apparaissent dans l'environnement de production. Cette intégration étroite entre le contrôle de version et l'intégration continue crée une boucle de rétroaction constante qui garantit la qualité du code et prévient l'accumulation de problèmes d'intégration.\n\n## Quels sont les avantages de l'approche CI/CD ?\n\n[L'approche CI/CD apporte de nombreux avantages qui transforment le développement logiciel moderne](https://about.gitlab.com/blog/ten-reasons-why-your-business-needs-ci-cd/) et réduisent considérablement les délais ainsi que les risques associés à la livraison de nouvelles fonctionnalités et corrections de bogues. Grâce à une boucle de rétroaction continue, les équipes DevSecOps peuvent garantir que leurs modifications sont automatiquement validées sur l'ensemble du code source. \n\nRésultat : des logiciels de meilleure qualité, des cycles de livraison plus courts et des sorties de nouvelles versions plus fréquentes pour répondre rapidement aux besoins des utilisateurs et aux demandes du marché.\n\nAu-delà des aspects techniques, l'approche CI/CD favorise une culture de collaboration et de transparence au sein des équipes de développement logiciel. Grâce à une visibilité en temps réel du statut des compilations, des tests et des déploiements, il est plus facile d'identifier et de résoudre les goulots d'étranglement dans le processus de livraison. L'automatisation offerte par l'approche CI/CD réduit également la charge cognitive des équipes de développement qui peuvent ainsi se concentrer sur l'écriture de code plutôt que sur la gestion de processus de déploiement manuels. La satisfaction et la productivité des équipes s’améliorent, tandis que les risques généralement associés aux étapes critiques du processus de publication de logiciel diminuent. Les équipes peuvent expérimenter de nouvelles idées sans craindre de compromettre le projet, sachant que des mécanismes de contrôle robustes, comme les revues de code rapides, sont intégrés au processus. Elles peuvent rapidement annuler les modifications si nécessaire. L'approche CI/CD encourage donc une culture d'innovation et d'amélioration continue.\n\n### Quelles sont les principales différences entre l'approche CI/CD et le développement traditionnel ?\n\nL'approche CI/CD diffère du développement logiciel traditionnel à bien des égards, notamment en ce qui concerne les points suivants :\n\n**Validations fréquentes du code**\n\nDans le développement traditionnel, les équipes de développement travaillent souvent de manière isolée et intègrent rarement leurs modifications dans le code source. Cette situation entraîne des conflits de merge et d'autres problèmes chronophages. Avec l'approche CI/CD, les équipes effectuent régulièrement des push de validation, parfois plusieurs fois par jour. De cette manière, les conflits de merge sont détectés rapidement et le code source est maintenu à jour.\n\n**Réduction des risques**\n\nLes méthodes de développement logiciel traditionnelles reposent sur des cycles de test à rallonge et une planification rigoureuse avant la sortie de chaque nouvelle version. Bien que ce type de développement ait pour objectif de réduire au maximum les risques, il entrave souvent la capacité à identifier et à résoudre les problèmes. À l’inverse, l'approche CI/CD permet de gérer les risques en appliquant de petites modifications incrémentielles. Ces changements, surveillés de près, peuvent être facilement annulés en cas de problème.\n\n**Tests automatisés et continus**\n\nDans le cadre du développement logiciel traditionnel, les tests sont généralement exécutés à la fin du processus de développement, ce qui peut entraîner des retards de livraison et des corrections de bogues coûteuses. L'approche CI/CD, en revanche, intègre des tests automatisés qui sont exécutés en continu tout au long du processus de développement logiciel et déclenchés à chaque validation de code. Cette approche permet aux équipes de développement de recevoir des retours immédiats et d’implémenter rapidement les correctifs nécessaires.\n\n**Déploiements automatisés, reproductibles et fréquents**\n\nL’automatisation des déploiements dans l’approche CI/CD réduit le stress et les efforts habituellement associés aux déploiements massifs de logiciels. Ce processus automatisé est reproductible dans tous les environnements et garantit ainsi un gain de temps, une réduction des risques d’erreurs ainsi qu'une cohérence accrue dans chaque déploiement.\n\n## Quels sont les principes fondamentaux de l'approche CI/CD ?\n\nL'approche CI/CD constitue un framework essentiel pour la mise en place de processus de livraison de logiciels évolutifs et régulièrement mis à jour. Pour les équipes DevSecOps, une maîtrise parfaite de ses concepts fondamentaux est indispensable. Une solide compréhension des principes CI/CD permet aux équipes d'adapter leurs stratégies et leurs pratiques aux évolutions technologiques, en s’affranchissant des limitations des méthodes traditionnelles. \n\n### Qu'est-ce qu'un pipeline CI/CD ?\n\nUn [pipeline CI/CD](https://about.gitlab.com/fr-fr/topics/ci-cd/cicd-pipeline/) est une série d'étapes (compilation, test et déploiement) qui automatise et rationalise le processus de livraison de logiciels. [Chaque étape agit comme un mur qualité](https://about.gitlab.com/blog/guide-to-ci-cd-pipelines/) et permet de s'assurer que seul le code validé passe à l'étape suivante. Les premières étapes gèrent les vérifications de base, telles que la compilation et les tests unitaires. Les étapes ultérieures, quant à elles, peuvent inclure des tests d'intégration, de performance et de conformité, ainsi que des déploiements échelonnés dans divers environnements.\n\nLe pipeline peut être configuré de manière à nécessiter des approbations manuelles aux points critiques, par exemple avant le déploiement en production, tout en automatisant les tâches routinières. Les équipes de développement obtiennent ainsi un retour rapide sur l'état de leurs modifications. Cette approche structurée assure la cohérence, réduit les erreurs humaines et fournit une piste d'audit claire du transfert des modifications de code de l'environnement de développement vers l'environnement de production. Les pipelines modernes sont souvent implémentés sous forme de code et peuvent ainsi être contrôlés, testés et tenus à jour, de la même manière que le code applicatif.\n\nVoici d'autres termes associés à l'approche CI/CD qu'il est important de connaître :\n\n* **Validation :** une modification apportée au code\n* **Job :** une série d'instructions qu'un runner doit exécuter\n* **Runner :** un agent ou serveur qui exécute chaque job individuellement et qui peut se mettre à l'échelle selon les besoins\n* **Étapes :** un mot-clé qui définit certaines phases spécifiques d'un job, comme la phase de « compilation » et de « déploiement ». Les jobs d'une même étape s’exécutent en parallèle. Les pipelines sont configurés à l'aide d'un fichier YAML nommé `.gitlab-ci.yml`, soumis au contrôle de version et situé à la racine du projet.\n\n![Diagramme représentant un pipeline CI/CD](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749673928/Blog/Content%20Images/1690824533476.png)\n\n## Bonnes pratiques pour réussir votre approche CI/CD\n\nVotre maîtrise de l'approche CI/CD dépend grandement des [bonnes pratiques](https://about.gitlab.com/fr-fr/blog/how-to-keep-up-with-ci-cd-best-practices/) que vous mettez en œuvre. \n\n#### Les bonnes pratiques en matière d'intégration continue\n\n* Validez tôt et souvent.\n* Optimisez les étapes du pipeline.\n* Simplifiez et accélérez les compilations.\n* Utilisez les échecs pour améliorer les processus.\n* Assurez-vous que l'environnement de test reflète l'environnement de production.\n\n#### Les bonnes pratiques en matière de livraison continue\n\n* Lancez-vous avec les outils et infrastructures disponibles, puis itérez pour améliorer vos processus.\n* Utilisez le moins d'outils possibles pour optimiser la livraison continue.\n* Surveillez l’avancée des projets en continu afin d’éviter l’accumulation de tickets ou de merge requests.\n* Simplifiez les tests d'acceptation par l'utilisateur et le déploiement vers l'environnement de préproduction grâce à l'automatisation.\n* Automatisez la gestion du pipeline de sortie des nouvelles versions.\n* Mettez en œuvre la surveillance du pipeline pour gagner en visibilité et en productivité. \n\n> ### Pour en savoir plus sur l'approche CI/CD, consultez notre [webinaire « Intro to CI/CD »](https://www.youtube.com/watch?v=sQ7Nw3o0izc).\n\n\u003C!-- blank line -->\n\n\u003Cfigure class=\"video_container\">\n\u003Ciframe src=\"https://www.youtube.com/embed/sQ7Nw3o0izc?si=3HpNqIClrc2ncr7Y\" title=\"Intro to CI/CD webinar\" frameborder=\"0\" allowfullscreen=\"true\"> \u003C/iframe>\n\u003C/figure>\n\u003C!-- blank line -->\n\n## Premiers pas avec l'approche CI/CD\n\nPour commencer à utiliser l'approche CI/CD, identifiez un projet simple mais représentatif qui servira de projet pilote. Sélectionnez une application simple avec des exigences de test basiques. Vous pourrez ainsi vous concentrer sur l'apprentissage du fonctionnement des pipelines plutôt que sur des scénarios de déploiement complexes. Assurez-vous que votre code est soumis au [contrôle de version](https://about.gitlab.com/fr-fr/topics/version-control/ \"Qu'est-ce que le contrôle de version ?\") et qu'il comporte des [tests automatisés basiques](https://about.gitlab.com/blog/develop-c-unit-testing-with-catch2-junit-and-gitlab-ci/). Même quelques tests unitaires suffisent pour débuter. L'objectif est de [créer un pipeline basique](https://about.gitlab.com/blog/how-to-learn-ci-cd-fast/) que vous pourrez améliorer progressivement à mesure que vos compétences progressent.\n\nDans le cas de GitLab, le processus commence par la création d'un fichier `.gitlab-ci.yml` dans le répertoire racine de votre projet. Ce fichier YAML définit les étapes de base (comme la compilation, les tests et le déploiement) et les jobs de votre pipeline. Voici un exemple de pipeline simple : l'étape de « Compilation » compile votre code et crée des artefacts, l'étape de « Test » exécute les tests unitaires et l'étape de « Déploiement » effectue le push de votre application vers un environnement de préproduction. GitLab détecte automatiquement ce fichier et commence à exécuter votre pipeline chaque fois que des modifications sont transmises via un push vers votre dépôt. La plateforme fournit des [runners intégrés](https://docs.gitlab.com/runner/) pour exécuter les jobs de votre pipeline, mais vous pouvez également configurer vos propres runners si vous souhaitez davantage de contrôle.\n\nÀ mesure que vous maîtrisez les éléments de base, enrichissez votre pipeline progressivement avec des fonctionnalités plus avancées. Par exemple, ajoutez des contrôles de qualité du code, [le scanning de sécurité](https://docs.gitlab.com/ee/user/application_security/#security-scanning) ou le déploiement automatisé du nouveau code en production. La plateforme DevSecOps de GitLab inclut des fonctionnalités telles que la [gestion de la conformité](https://about.gitlab.com/blog/meet-regulatory-standards-with-gitlab/), les [variables de déploiement](https://about.gitlab.com/fr-fr/blog/demystifying-ci-cd-variables/) et les portes d'approbation manuelle que vous pouvez intégrer à mesure que votre pipeline évolue. Soyez attentif à la durée d'exécution du pipeline et exécutez dans la mesure du possible des jobs en parallèle. Pensez à ajouter des notifications et un traitement approprié des erreurs afin que les membres de l'équipe soient rapidement informés en cas d’échec de pipeline. Commencez à documenter les problèmes que vous rencontrez le plus souvent et les solutions adoptées. Ces données seront très utiles quand votre équipe s'agrandira.\n\n> ### Vous souhaitez en savoir plus sur l'approche CI/CD ? Inscrivez-vous à notre [cours GitLab University gratuit sur l'approche CI/CD](https://university.gitlab.com/courses/continuous-integration-and-delivery-ci-cd-with-gitlab).\n\n## Sécurité, conformité et approche CI/CD\n\nL'un des plus grands avantages de l'approche CI/CD est la possibilité d'intégrer des contrôles de sécurité et de conformité réguliers, et ce dès les premières étapes du cycle de développement logiciel. Dans GitLab, les équipes peuvent utiliser la configuration `.gitlab-ci.yml` pour déclencher automatiquement des scans de sécurité à plusieurs étapes, de la validation initiale du code à son déploiement en production. Les fonctionnalités d'analyse des conteneurs, d'analyse des dépendances et de scanning de sécurité ([Test dynamique de sécurité des applications](https://docs.gitlab.com/ee/user/application_security/dast/) et [Analyseur Advanced SAST de GitLab](https://about.gitlab.com/blog/gitlab-advanced-sast-is-now-generally-available/)) de la plateforme peuvent être configurées pour s'exécuter automatiquement à chaque modification de code afin de rechercher les vulnérabilités, les violations des exigences de conformité et les erreurs de configuration de sécurité. L'API de la plateforme permet l'intégration avec des [outils de sécurité externes](https://about.gitlab.com/blog/integrate-external-security-scanners-into-your-devsecops-workflow/), tandis que les fonctionnalités de couverture des tests garantissent que les tests de sécurité répondent aux seuils requis.\n\nLes rapports de test de sécurité de GitLab fournissent des informations détaillées sur les découvertes de vulnérabilités afin de remédier rapidement aux problèmes de sécurité avant qu'ils n'atteignent l'environnement de production. Le tableau de bord relatif à la sécurité fournit une vue centralisée des vulnérabilités détectées dans les différents projets, tandis que des [stratégies de sécurité peuvent être appliquées](https://about.gitlab.com/blog/how-gitlab-supports-the-nsa-and-cisa-cicd-security-guidance/) via les approbations de merge request et les portes dans les pipelines. GitLab offre plusieurs niveaux de gestion des secrets pour protéger les données sensibles tout au long du processus CI/CD, y compris des journaux d'audit permettant de suivre l'accès à ces secrets. De plus, un contrôle d'accès basé sur les rôles (RBAC) garantit que seuls les utilisateurs autorisés peuvent consulter ou modifier les données de configuration sensibles.\n\nGitLab prend également en charge la génération de [nomenclatures logicielles (SBOM)](https://about.gitlab.com/fr-fr/blog/the-ultimate-guide-to-sboms/), qui fournissent un inventaire complet de l'ensemble des composants logiciels, dépendances et licences dans une application. Elles permettent aux équipes d'identifier et de corriger rapidement les vulnérabilités, ainsi que de se conformer aux exigences réglementaires.\n\n## Approche CI/CD et cloud\n\nLa plateforme CI/CD de GitLab offre une intégration robuste avec les principaux fournisseurs de services cloud, notamment [Amazon Web Services](https://about.gitlab.com/fr-fr/partners/technology-partners/aws/), [Google Cloud Platform](https://about.gitlab.com/blog/provision-group-runners-with-google-cloud-platform-and-gitlab-ci/) et [Microsoft Azure](https://docs.gitlab.com/ee/install/azure/). Les équipes de développement logiciel peuvent ainsi automatiser leurs déploiements cloud directement à partir de leurs pipelines. Grâce aux intégrations cloud de GitLab, elles peuvent également gérer les ressources cloud, déployer des applications et surveiller les services cloud directement depuis l'interface de GitLab. Les templates de déploiement cloud intégrés et les fonctionnalités [Auto DevOps](https://docs.gitlab.com/ee/topics/autodevops/) de la plateforme réduisent considérablement la complexité des déploiements cloud. Les membres de l'équipe peuvent ainsi se concentrer sur le développement d'applications plutôt que sur la gestion de l'infrastructure. Pour les entreprises qui souhaitent automatiser leur infrastructure informatique à l'aide de [GitOps](https://about.gitlab.com/fr-fr/topics/gitops/ \"Qu'est-ce que GitOps ?\"), GitLab propose l'[intégration Flux CD](https://about.gitlab.com/blog/why-did-we-choose-to-integrate-fluxcd-with-gitlab/).\n\nLes fonctionnalités cloud de GitLab vont au-delà de la simple automatisation des déploiements. L'[intégration Kubernetes](https://about.gitlab.com/fr-fr/blog/kubernetes-the-container-orchestration-solution/ \"Qu'est-ce que Kubernetes ?\") à la plateforme GitLab permet aux équipes de gérer l'orchestration des conteneurs entre plusieurs fournisseurs de services cloud. De plus, les [options d'installation cloud-native de GitLab](https://about.gitlab.com/fr-fr/topics/ci-cd/cloud-native-continuous-integration/) permettent à la plateforme elle-même de fonctionner dans des environnements cloud. Grâce à ces fonctionnalités cloud-native, les équipes peuvent mettre en œuvre des runners à mise à l'échelle automatique qui provisionnent dynamiquement les ressources cloud pour l'exécution de pipelines afin d'optimiser les coûts et les performances. Enfin, l'intégration de la plateforme avec les services de sécurité des fournisseurs de services cloud garantit le respect des exigences de sécurité et de conformité tout au long du processus de déploiement.\n\nPour les environnements multicloud, GitLab fournit des workflows et des outils cohérents, quel que soit le fournisseur de services cloud sous-jacent. Les équipes de développement peuvent utiliser les fonctionnalités de gestion de l'environnement de GitLab pour gérer différentes configurations cloud dans les environnements de développement, de préproduction et de production. La prise en charge de l'[Infrastructure as Code (IaC)](https://docs.gitlab.com/ee/user/infrastructure/iac/) de la plateforme GitLab, en particulier son intégration native avec Terraform, permet aux équipes de développement de contrôler les versions et d'automatiser le provisionnement de leur infrastructure cloud. Les fonctionnalités de surveillance et d'[observabilité](https://about.gitlab.com/fr-fr/blog/observability-vs-monitoring-in-devops/ \"Qu'est-ce que l'observabilité ?\") de GitLab s'intègrent aux indicateurs des fournisseurs de services cloud, offrant une visibilité complète de l'intégrité des applications et de l'infrastructure dans les différents environnements cloud.\n\n## Pipeline CI/CD avancé\n\nL'approche CI/CD a connu une évolution significative qui va bien au-delà de la simple construction et du déploiement de pipelines. Dans les mises en œuvre avancées, elle implique une orchestration sophistiquée des tests automatisés, du scanning de sécurité, du provisionnement de l'infrastructure, de l'IA et de bien d'autres aspects. Voici quelques stratégies CI/CD avancées pour aider les équipes d'ingénierie à améliorer leurs pipelines et à résoudre les problèmes qui surviennent, même lorsque la complexité de l'architecture augmente.\n\n### Réutilisation et automatisation des pipelines CI/CD\n\nGitLab révolutionne les pratiques des équipes de développement logiciel et de gestion des pipelines CI/CD en introduisant deux innovations majeures : le [catalogue CI/CD](https://about.gitlab.com/blog/ci-cd-catalog-goes-ga-no-more-building-pipelines-from-scratch/) et [CI/CD Steps](https://about.gitlab.com/blog/introducing-ci-cd-steps-a-programming-language-for-devsecops-automation/). Ce dernier est un nouveau langage de programmation expérimental dédié à l'automatisation DevSecOps. Le catalogue CI/CD est une plateforme centralisée où les équipes peuvent découvrir, réutiliser et optimiser les différents composants CI/CD. Ces derniers fonctionnent comme des blocs de construction réutilisables et à usage unique qui simplifient la configuration des pipelines au sein des workflows CI/CD. Parallèlement, CI/CD Steps offre la possibilité de gérer des workflows complexes en permettant aux équipes de configurer les entrées et sorties pour chaque job CI/CD. Avec le catalogue CI/CD et CI/CD Steps, les équipes DevSecOps peuvent facilement standardiser l'approche CI/CD et ses composants, et ainsi simplifier le processus de développement et de maintenance des pipelines CI/CD.\n\n> Pour en savoir plus, consultez notre [FAQ sur le catalogue CI/CD](https://about.gitlab.com/blog/faq-gitlab-ci-cd-catalog/) et notre [documentation sur CI/CD Steps](https://docs.gitlab.com/ee/ci/steps/).\n\n### Dépannage des pipelines avec l'IA\n\nBien qu'une défaillance des pipelines CI/CD soit possible, le dépannage rapide du problème peut considérablement réduire son impact. L'analyse des causes profondes de [GitLab Duo](https://about.gitlab.com/fr-fr/gitlab-duo/ \"Qu'est-ce que GitLab Duo ?\"), l'une des fonctionnalités alimentées par l'IA, élimine les hypothèses en [déterminant la cause profonde de l'échec d'un pipeline CI/CD](https://about.gitlab.com/fr-fr/blog/quickly-resolve-broken-ci-cd-pipelines-with-ai/ \"Échecs de pipelines CI/CD\"). Lorsqu'un pipeline échoue, GitLab fournit des job logs détaillés, des messages d'erreur et des traces d'exécution qui indiquent exactement où et pourquoi l'échec s'est produit. L'analyse des causes profondes utilise ensuite l'IA pour suggérer une solution.\n\nDécouvrez la fonctionnalité d'analyse des causes profondes de GitLab Duo en action :\n\n\u003C!-- blank line -->\n\n\u003Cfigure class=\"video_container\">\n\u003Ciframe src=\"https://www.youtube.com/embed/sTpSLwX5DIs?si=J6-0Bf6PtYjrHX1K\" frameborder=\"0\" allowfullscreen=\"true\"> \u003C/iframe>\n\u003C/figure>\n\u003C!-- blank line -->\n\n## Comment migrer son code vers un pipeline GitLab CI/CD ?\n\nLa migration vers la plateforme DevSecOps de GitLab et son pipeline CI/CD intégré implique l'analyse systématique de vos configurations de pipeline, dépendances et processus de déploiement existants pour les mapper aux fonctionnalités et à la syntaxe équivalentes de GitLab. \n\nConsultez nos ressources pour faciliter votre migration vers GitLab CI/CD : \n\n* [Migration de Bamboo vers GitLab CI/CD](https://about.gitlab.com/blog/migrating-from-bamboo-to-gitlab-cicd/)\n* [De Jenkins à GitLab : le guide complet pour moderniser votre environnement CI/CD](https://about.gitlab.com/blog/jenkins-gitlab-ultimate-guide-to-modernizing-cicd-environment/)\n* [Migrer de GitHub Advanced Security vers GitLab Ultimate : notre guide complet](https://about.gitlab.com/fr-fr/blog/migration-guide-github-advanced-security-to-gitlab-ultimate/)\n\n## Témoignages d'entreprises leaders dans leur domaine\n\nCes entreprises de premier plan ont migré vers GitLab et profitent des innombrables avantages de l'approche CI/CD. Découvrez leurs témoignages.\n\n* [Lockheed Martin](https://about.gitlab.com/fr-fr/customers/lockheed-martin/)\n* [Indeed](https://about.gitlab.com/fr-fr/blog/how-indeed-transformed-its-ci-platform-with-gitlab/)\n* [CARFAX](https://about.gitlab.com/fr-fr/customers/carfax/)\n* [HackerOne](https://about.gitlab.com/fr-fr/customers/hackerone/)\n* [Betstudios](https://about.gitlab.com/blog/betstudios-cto-on-improving-ci-cd-capabilities-with-gitlab-premium/)\n* [Thales et Carrefour](https://about.gitlab.com/blog/how-carrefour-and-thales-are-evolving-their-ci-cd-platforms/)\n\n## Tutoriels CI/CD\n\nDevenez un expert des pipelines CI/CD à l'aide de ces tutoriels : \n\n* [Intégration continue : créez votre premier pipeline CI avec GitLab](https://about.gitlab.com/fr-fr/blog/basics-of-gitlab-ci-updated/)\n* [Configuration de votre premier composant GitLab CI/CD](https://about.gitlab.com/blog/tutorial-how-to-set-up-your-first-gitlab-ci-cd-component/)\n* [GitLab CI/CD : comment créer facilement un pipeline pour un monorepo](https://about.gitlab.com/fr-fr/blog/building-a-gitlab-ci-cd-pipeline-for-a-monorepo-the-easy-way/)\n* [Déployer en continu dans de multiples environnements avec les pipelines enfants](https://about.gitlab.com/fr-fr/blog/using-child-pipelines-to-continuously-deploy-to-five-environments/)\n* [Refactorisation d'un template CI/CD en composant CI/CD](https://about.gitlab.com/blog/refactoring-a-ci-cd-template-to-a-ci-cd-component/)\n\n> ### Commencez un [essai de GitLab Ultimate](https://gitlab.com/-/trials/new) et essayez gratuitement GitLab CI/CD.",[9,859,685,684,1059,686],"security",{"slug":1061,"featured":91,"template":691},"ultimate-guide-to-ci-cd-fundamentals-to-advanced-implementation","content:fr-fr:blog:ultimate-guide-to-ci-cd-fundamentals-to-advanced-implementation.yml","Ultimate Guide To Ci Cd Fundamentals To Advanced Implementation","fr-fr/blog/ultimate-guide-to-ci-cd-fundamentals-to-advanced-implementation.yml","fr-fr/blog/ultimate-guide-to-ci-cd-fundamentals-to-advanced-implementation",{"_path":1067,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":1068,"content":1074,"config":1084,"_id":1086,"_type":14,"title":1087,"_source":16,"_file":1088,"_stem":1089,"_extension":19},"/fr-fr/blog/ultimate-guide-to-migrating-from-aws-codecommit-to-gitlab",{"title":1069,"description":1070,"ogTitle":1069,"ogDescription":1070,"noIndex":6,"ogImage":1071,"ogUrl":1072,"ogSiteName":673,"ogType":674,"canonicalUrls":1072,"schema":1073},"Migrer d'AWS CodeCommit vers GitLab : le guide complet ","Ce tutoriel vous explique comment migrer depuis les services Amazon Web Services (AWS) vers la plateforme DevSecOps de GitLab.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097810/Blog/Hero%20Images/Blog/Hero%20Images/blog-image-template-1800x945%20%2828%29_4mi0l4wzUa5VI4wtf8gInx_1750097810027.png","https://about.gitlab.com/blog/ultimate-guide-to-migrating-from-aws-codecommit-to-gitlab","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Migrer d'AWS CodeCommit vers GitLab : le guide complet \",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Tsukasa Komatsubara\"},{\"@type\":\"Person\",\"name\":\"Darwin Sanoy\"},{\"@type\":\"Person\",\"name\":\"Samer Akkoub\"},{\"@type\":\"Person\",\"name\":\"Bart Zhang\"}],\n        \"datePublished\": \"2024-08-26\",\n      }",{"title":1069,"description":1070,"authors":1075,"heroImage":1071,"date":1080,"body":1081,"category":686,"tags":1082,"updatedDate":1083},[1076,1077,1078,1079],"Tsukasa Komatsubara","Darwin Sanoy","Samer Akkoub","Bart Zhang","2024-08-26","Le 25 juillet 2024, AWS a communiqué une annonce importante concernant son service CodeCommit : AWS a décidé de fermer l'accès des nouveaux clients à CodeCommit. Bien que les clients existants puissent continuer à utiliser ce service, AWS n'introduira pas de nouvelles fonctionnalités, concentrant uniquement son attention sur la sécurité, la disponibilité et l'amélioration des performances.\n\nÀ la suite de cette annonce, les équipes de développement ont commencé à envisager de migrer leurs dépôts vers d'autres fournisseurs Git. En réponse à ces changements, nous avons rédigé ce guide complet dans le but d'aider les équipes à migrer vers GitLab et à s'intégrer avec d'autres services AWS.\n\n**Remarque :** pour en savoir plus sur les recommandations officielles d'AWS en matière de migration, veuillez consulter [leur article de blog](https://aws.amazon.com/blogs/devops/how-to-migrate-your-aws-codecommit-repository-to-another-git-provider/ \"Article de blog d'AWS annonçant l’arrêt d'AWS CodeCommit\").\n\n## À propos de ce guide\n\nCe guide contient des informations complètes destinées aux équipes de développement qui utilisent GitLab et qui envisagent une intégration avec les services AWS, ou à celles qui envisagent de migrer des dépôts [Git](https://about.gitlab.com/fr-fr/blog/what-is-git/ \"Qu'est-ce que Git ? \") hébergés sur AWS vers GitLab.com. \n\nNotre guide est composé de quatre sections principales :\n\n- __Migration en parallèle vers GitLab :__ nous vous expliquons comment migrer progressivement des dépôts existants hébergés sur AWS vers GitLab.com, tout en minimisant les risques.\n\n- __Intégration avec AWS CodeBuild :__ nous détaillons les étapes à suivre pour intégrer les dépôts GitLab avec AWS CodeBuild, et mettre en place un environnement d'[intégration continue (CI)](https://about.gitlab.com/fr-fr/topics/ci-cd/benefits-continuous-integration/ \"Qu'est-ce que l'intégration continue (CI) ?\") puissant.\n\n- __Intégration avec AWS CodePipeline :__ nous décrivons comment connecter les dépôts GitLab avec AWS CodePipeline pour construire des pipelines de [livraison continue (CD)](https://about.gitlab.com/fr-fr/topics/continuous-delivery/ \"Qu'est-ce que la livraison continue (CD) ?\") efficaces.\n\n- __Intégrations downstream pour AWS CodePipeline et CodeStar Connections :__ nous expliquons comment tirer parti des connexions entre GitLab et AWS pour disposer d'un accès étendu aux services, ce qui vous ouvre différentes possibilités d'intégration dans l'écosystème AWS.\n\nGrâce à ce guide, vous apprendrez à construire un workflow de développement efficace et flexible en combinant les puissantes fonctionnalités de [GitLab et AWS](https://about.gitlab.com/fr-fr/partners/technology-partners/aws/ \"GitLab et AWS\").\n\n## Section 1 : migration en parallèle vers GitLab \n\nSi vous envisagez de migrer des dépôts Git hébergés sur AWS vers GitLab.com, cette section présente des méthodes pour réaliser la migration progressivement tout en minimisant les risques. En mettant à profit les capacités de mise en miroir de GitLab, vous pouvez maintenir les flux de développement existants tout en testant le nouvel environnement.\n\n### Pourquoi la migration en parallèle est-elle importante ?\n\nLes migrations de systèmes à grande échelle comportent toujours des risques, en particulier des impacts potentiels sur les projets de développement en cours, les intégrations existantes et les processus automatisés. L'adoption d'une approche de migration en parallèle offre les avantages suivants :\n\n1. __Une minimisation des risques :__ testez le nouvel environnement tout en maintenant les systèmes existants opérationnels \n2. __Une transition fluide :__ les équipes de développement peuvent s'habituer progressivement au nouveau système.\n3. __Des tests d'intégration :__ testez minutieusement toutes les intégrations et l'automatisation dans le nouvel environnement.\n4. __Une pérennité :__ donnez aux équipes les moyens de migrer progressivement vers GitLab [CI/CD](https://about.gitlab.com/fr-fr/topics/ci-cd/ \"Qu'est-ce que le CI/CD ?\"), tout en continuant à utiliser le CI existant.\n\nLa migration en parallèle n'est pas nécessaire si vous savez déjà que vous souhaitez passer directement à GitLab.\n\n### Quelles sont les étapes pour migrer vers GitLab.com ? \n\n#### Étape 1 : configurez GitLab.com\n\n- Vérifiez si votre entreprise utilise déjà un groupe sur GitLab.com et si elle a mis en place une authentification unique (SSO). Si c'est le cas, vous vous servirez des deux.\n- Si votre entreprise n'a pas de compte sur GitLab.com, accédez au [site de GitLab](www.gitlab.com/fr-fr) et créez un nouveau compte ou connectez-vous à votre compte existant.\n- Créez un nouvel espace de nommage pour l'entreprise (un groupe au niveau racine sur GitLab.com).\n- Choisissez un nom disponible qui reflète l'ensemble de votre entreprise.\n\n#### Étape 2 : importez le dépôt\nPour effectuer la migration en parallèle, utilisez la fonctionnalité de mise en miroir de type « pull » de GitLab. Elle vous permet de synchroniser automatiquement les modifications des dépôts hébergés sur AWS vers GitLab.com.\n\n1. Accédez au groupe cible GitLab.com.\n2. En haut à droite, cliquez sur « Nouveau projet ».\n3. Sur la page « Créer un nouveau projet », cliquez sur « Importer un projet ».\n4. Sur la page « Importer un projet », cliquez sur « Dépôt par URL ».\n5. Saisissez l'URL de votre dépôt hébergé sur AWS dans le champ « URL du dépôt Git ».\n6. Sous le champ URL du dépôt Git, cochez « Dépôt miroir ».\n7. Configurez ensuite l'authentification. Dans la console AWS CodeCommit, sélectionnez l'URL du clone du dépôt que vous allez migrer. Si vous prévoyez d'importer des dépôts CodeCommit dans GitLab, vous pouvez utiliser l'URL HTTPS de CodeCommit pour cloner le dépôt en utilisant la fonctionnalité de mise en miroir du dépôt de GitLab. Vous devrez également fournir vos identifiants de connexion Git d'AWS pour votre utilisateur IAM (Identity and Access Management) dans GitLab. Reportez-vous à ce [guide](https://docs.aws.amazon.com/codecommit/latest/userguide/setting-up-gc.html) pour créer des identifiants de connexion Git pour AWS CodeCommit.\n\n![URL du clone](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097822/Blog/Content%20Images/Blog/Content%20Images/clone-url-screenshot__1__aHR0cHM6_1750097822121.png)\n\nCette configuration effectuera automatiquement un pull des modifications du dépôt hébergé sur AWS vers GitLab.com. La fréquence par défaut est de cinq minutes.\n\nPour plus d'informations, consultez notre [documentation sur la fonctionnalité de mise en miroir du dépôt de GitLab](https://docs.gitlab.com/ee/user/project/repository/mirror/).\n\n#### Étape 3 : testez et validez les intégrations\n\n1. __[Pipelines CI/CD](https://about.gitlab.com/fr-fr/topics/ci-cd/cicd-pipeline/ \"Qu'est-ce qu'un pipeline CI/CD ?\") :__ configurez le fichier `.gitlab-ci.yml` dans [GitLab CI](https://about.gitlab.com/fr-fr/blog/ci-deployment-and-environments/ \"Comment déployer du code dans des environnements multiples avec GitLab CI\") pour répliquer les pipelines existants. Plus d'informations sur [la planification d'une migration vers GitLab CI/CD à partir d'autres outils CI](https://docs.gitlab.com/ee/ci/migration/plan_a_migration.html) sont à votre disposition dans notre documentation.\n2. Gestion des tickets : importez les tickets du projet et testez les workflows.\n3. Revue de code : configurez le processus de merge request et testez les workflows de revue.\n#### Étape 4 : migrez progressivement\n\n1. Commencez par des projets de petite envergure ou non critiques pour vous habituer à travailler sur GitLab.com.\n2. Proposez une formation aux membres de votre équipe et laissez-leur le temps de s'adapter aux nouveaux workflows.\n3. Migrez les projets progressivement en vous assurant que les intégrations et les workflows fonctionnent correctement.\n\nPour plus d'informations, consultez la section [Automatisation des migrations de CodeCommit vers GitLab](https://gitlab.com/guided-explorations/aws/migrating-from-codecommit-to-gitlab/-/blob/main/migrating_codecommit_to_gitlab.md).\n\n#### Étape 5 : finalisez la migration\nUne fois que vous avez terminé tous les tests et validations et que votre équipe s'est habituée au nouvel environnement, planifiez une migration complète. Pour chaque projet :\n\n1. Fixez une date de migration et informez toutes les parties prenantes.\n2. Effectuez la synchronisation finale des données.\n3. Supprimez les paramètres de mise en miroir du projet GitLab.\n4. Passez les dépôts hébergés sur AWS en lecture seule et transférez tous les projets de développement vers GitLab.com.\n\n#### Étape 6 : évaluez l'adoption de nouvelles capacités\n\nAvec GitLab, la collaboration et l'automatisation des workflows offrent aux équipes de développement beaucoup plus d'opportunités qu’avec CodeCommit. Comme le processus de merge request est particulièrement sophistiqué par rapport à CodeCommit, cela peut prendre un peu de temps pour comprendre les capacités des fonctionnalités. \n\nUne fois que les dépôts sont stables sur GitLab, il est très facile d'expérimenter GitLab CI/CD en parallèle d'une solution existante. Les équipes peuvent prendre le temps de perfectionner leur automatisation GitLab CI/CD sans affecter les workflows de production.\n\nLa gestion des artefacts GitLab est également très performante, notamment la fonctionnalité Releases et les nombreux registres de paquet.\n\n### En résumé\nEn adoptant une approche de migration en parallèle vers GitLab, vous pouvez réaliser une transition en douceur tout en minimisant les risques. Ce processus permet aux équipes de s'adapter progressivement au nouvel environnement et de s'assurer que toutes les intégrations et automatisations fonctionnent correctement. \n\n## Section 2 : intégrez GitLab avec AWS CodeBuild\n\nSi vous souhaitez compiler et tester du code à partir de dépôts GitLab à l'aide d'AWS CodeBuild, notre guide complet vous aidera à mettre en place un pipeline CI efficace.\n\n### Prérequis\n\n- Compte GitLab.com\n- Compte AWS\n- AWS CLI (configurée)\n\n### Étape 1 : créez une connexion entre GitLab et AWS CodeStar Connections\n\n1. Connectez-vous à la console de gestion AWS et accédez au service AWS CodeBuild.\n2. Sélectionnez « Paramètres » > « Connexions » dans le panneau de navigation de gauche.\n3. Cliquez sur le bouton « Créer une connexion ».\n4. Choisissez « GitLab » comme fournisseur.\n5. Donnez un nom à la connexion et cliquez sur « Connecter à GitLab ».\n6. Vous serez redirigé vers la page d'authentification de GitLab.\n7. Approuvez les autorisations nécessaires.\n8. Une fois la connexion effectuée, son statut passera à « Disponible ».\n\n![Configuration de CodeStar Connect](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097822/Blog/Content%20Images/Blog/Content%20Images/codestar-connections-setup_aHR0cHM6_1750097822122.png)\n\n### Étape 2 : créez un projet AWS CodeBuild\n\n1. Cliquez sur « Créer un projet de construction » dans le tableau de bord d'AWS CodeBuild.\n2. Saisissez le nom du projet et une description.\n3. Pour les paramètres source, sélectionnez « GitLab » comme fournisseur.\n4. Choisissez la connexion que vous venez de créer, puis indiquez la branche et le dépôt GitLab.\n\n![Ajout d'un projet CodeBuild](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097822/Blog/Content%20Images/Blog/Content%20Images/codepipeline_step_3_add_codebuild_aHR0cHM6_1750097822123.png)\n\n**Remarque : à partir de l'étape 3, veuillez configurer les paramètres en fonction de votre environnement et de vos besoins spécifiques.**\n\n### En résumé\nCette section détaille comment intégrer les dépôts GitLab avec AWS CodeBuild. Cette configuration met en place un pipeline d'[intégration continue](https://about.gitlab.com/fr-fr/topics/ci-cd/benefits-continuous-integration/ \"Qu'est-ce que l'intégration continue (CI) ?\") où les modifications de code effectuées dans GitLab sont automatiquement compilées et testées à l'aide d'AWS CodeBuild.\n\n## Section 3 : intégrez GitLab avec AWS CodePipeline\n\nCe guide détaillé vous apportera les informations nécessaires si vous souhaitez mettre en œuvre la livraison continue à partir de dépôts GitLab à l'aide d'AWS CodePipeline. L'intégration est encore plus facile maintenant que GitLab est un fournisseur AWS CodeStar Connections.\n\n### Prérequis\n\n- Compte GitLab.com\n- Compte AWS\n- AWS CLI (configurée)\n\n### Étape 1 : créez une connexion entre GitLab et AWS CodeStar Connections\n\n1. Connectez-vous à la console de gestion AWS et accédez au service AWS CodePipeline.\n2. Sélectionnez « Paramètres » > « Connexions » dans le panneau de navigation de gauche.\n3. Cliquez sur le bouton « Créer une connexion ».\n4. Choisissez « GitLab » comme fournisseur.\n5. Donnez un nom à la connexion et cliquez sur « Connecter à GitLab ».\n6. Vous serez redirigé vers la page d'authentification de GitLab.\n7. Approuvez les autorisations nécessaires.\n8. Une fois la connexion effectuée, son statut passera à « Disponible ».\n\n![Configuration de CodeStar Connections](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097822/Blog/Content%20Images/Blog/Content%20Images/codestar-connections-setup_aHR0cHM6_1750097822122.png)\n\n### Étape 2 : créez un pipeline AWS CodePipeline\n\n1. Cliquez sur « Créer un pipeline » dans le tableau de bord d'AWS CodePipeline.\n2. Donnez un nom au pipeline et cliquez sur « Suivant ».\n3. Sélectionnez « GitLab » comme fournisseur source.\n4. Choisissez la connexion que vous venez de créer, puis indiquez la branche et le dépôt GitLab.\n5. Sélectionnez le type de déclencheur : vous pouvez déclencher l'exécution du pipeline AWS CodePipeline en fonction d'événements pull ou push pour des branches et des types de fichiers spécifiques au sein de votre dépôt.\n\n![Ajout du fournisseur source](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097822/Blog/Content%20Images/Blog/Content%20Images/codestar-connections-setup_aHR0cHM6_1750097822125.png)\n\n![Ajout d'une configuration source](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097822/Blog/Content%20Images/Blog/Content%20Images/codepipeline_step_2_source_provider_aHR0cHM6_1750097822127.png)\n\n**Remarque : à partir de l'étape 3, veuillez configurer les paramètres en fonction de votre environnement et de vos besoins spécifiques.**\n\n### En résumé \nCette section explique comment intégrer les dépôts GitLab avec AWS CodePipeline. Cette configuration crée un pipeline de livraison continue où les modifications de code effectuées dans GitLab sont automatiquement déployées dans votre environnement AWS.\n\n## Section 4 : migrez vers GitLab\n\nL'intégration de GitLab avec AWS vous donne accès à de puissantes fonctionnalités pour optimiser vos workflows de développement et de déploiement. Elle vous aide aussi à résoudre vos problèmes de gestion du code source. Cette intégration peut être réalisée de plusieurs manières, qui offrent chacune des avantages uniques :\n\n- L'utilisation d'AWS CodeStar Connections pour associer GitLab aux services AWS favorise la cohérence du workflow en permettant la connexion de dépôts Git externes, comme GitLab, à divers services AWS. Cette configuration prend en charge les compilations automatisées, les déploiements et d'autres actions essentielles directement à partir de votre dépôt GitLab, ce qui optimise l'intégration de votre processus de développement.\n\n- La connexion de GitLab avec AWS CodePipeline à l'aide de AWS CodeStar Connections fait passer l'automatisation au niveau supérieur en vous permettant de créer un pipeline CI/CD complet. Cette approche intègre GitLab avec AWS CodePipeline. Vous pouvez ainsi automatiser l'ensemble du processus (du contrôle des sources et des compilations, aux tests et déploiement) en utilisant des services AWS tels que AWS CodeBuild et AWS CodeDeploy. Vous bénéficiez ainsi d'un processus de livraison robuste, évolutif et efficace.\n\n![Tableau des nouvelles technologies et solutions pour associer GitLab et AWS](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097822/Blog/Content%20Images/Blog/Content%20Images/codepipeline_step_2_source_configured_aHR0cHM6_1750097822129.png)\n\n### 1. Connectez GitLab aux services AWS à l'aide d'AWS CodeStar Connections\n\nLe service AWS CodeStar Connections vous permet de connecter des dépôts Git externes (tels que GitHub ou Bitbucket) aux services AWS. Vous pouvez également utiliser CodeStar Connections pour connecter GitLab aux services AWS. Si vous utilisez GitLab, vous devrez peut-être configurer une connexion personnalisée en tant que serveur HTTP Git. \n\nCette méthode permet de connecter les services AWS suivants à GitLab :\n\n- **AWS Service Catalog**\n\nAWS Service Catalog aide les entreprises à standardiser et à gérer les ressources AWS. Son intégration à GitLab améliore la transparence de la gestion des ressources et simplifie le suivi des changements. Plus précisément, vous pouvez automatiser les mises à jour du catalogue en fonction des validations GitLab, ce qui améliore l'efficacité opérationnelle.\n\n- __AWS CodeBuild__\n\nAWS CodeBuild est un service qui compile votre code source, exécute des tests et produit des packages logiciels prêts à être déployés. L'intégration de GitLab avec AWS CodeBuild lance des processus de compilation automatisés à chaque fois qu'un push de modifications de code sur GitLab est effectué. La cohérence des compilations est ainsi garantie, tandis que la collaboration et le [contrôle des versions](https://about.gitlab.com/fr-fr/topics/version-control/ \"Qu'est-ce que le contrôle de version ?\") sont facilités.\n\n- __AWS Glue__\n\nLe service de blocs-notes intégrés à AWS Glue vous permet de développer et d'exécuter de manière interactive des tâches de préparation de données et ETL (processus d'extraction, de transformation et de chargement). L'intégration de GitLab avec les blocs-notes intégrés à AWS Glue vous permet de contrôler les versions des blocs-notes et des scripts ETL, de favoriser la collaboration entre les membres de l'équipe et d'améliorer la gestion de la qualité des pipelines de traitement des données.\n\n- __AWS Proton__\n\nAWS Proton automatise le développement et le déploiement de [microservices](https://about.gitlab.com/fr-fr/blog/what-are-the-benefits-of-a-microservices-architecture/ \"Architecture de microservices\") et d'applications [serverless](https://about.gitlab.com/fr-fr/topics/serverless/ \"Qu'est-ce que le serverless ?\"). En intégrant GitLab à AWS Proton, vous pouvez gérer l'[Infrastructure as Code](https://about.gitlab.com/fr-fr/topics/gitops/infrastructure-as-code/ \"Qu'est-ce que l'infrastructure en tant que code (IaC) ?\"), automatiser les déploiements et gérer l'environnement de façon cohérente. L'efficacité des processus de développement s'en trouve améliorée.\n\nAWS CodeStar Connections prend en charge davantage de services, ce qui facilite la connexion de GitLab avec d'autres services AWS. Nous vous conseillons de vérifier régulièrement si de nouveaux services prennent en charge CodeStar Connections.\n\n### 2. Connectez AWS CodePipeline à GitLab à l'aide AWS CodeStar Connections (y compris CodeDeploy)\n\nAWS CodePipeline est un service de livraison continue qui automatise le processus de livraison de logiciels. Pour connecter GitLab à AWS CodePipeline, vous devez utiliser AWS CodeStar Connections. Cette configuration vous permet de désigner un dépôt GitLab comme source et d'automatiser l'ensemble du pipeline CI/CD.\n\nAWS CodePipeline prend en charge les actions principales suivantes :\n- **Contrôle de version :** Amazon AWS CodeCommit, GitHub, Bitbucket, GitLab\n- **Compilations et tests :** AWS CodeBuild, Jenkins\n- **Déploiement :** AWS CodeDeploy, Elastic Beanstalk, ECS, S3\n- **Approbation :** approbation manuelle\n- **Gestion de l'infrastructure :** AWS CloudFormation\n- **Serverless :** AWS Lambda\n- **Tests :** AWS Device Farm\n- **Actions personnalisées :** AWS Step Functions\n\nEn intégrant GitLab avec AWS CodePipeline, vous pouvez automatiquement déclencher le pipeline chaque fois qu'un push de modifications de code sur GitLab est effectué, ce qui garantit la cohérence à chaque étape du processus, de la compilation au déploiement. De plus, avec les capacités de contrôle de version de GitLab, il est plus facile de suivre l'historique et les statuts de déploiement, ce qui permet une livraison de logiciels plus flexible et plus fiable.\n\n## Conclusion\n\nCe guide complet vous a expliqué comment effectuer la migration et l'intégration de GitLab avec AWS. La stratégie d'hébergement et d'intégration de code est propre à chaque entreprise. C’est pourquoi nous vous invitons à utiliser ce tutoriel comme point de départ pour établir votre propre stratégie d'intégration et de mise en œuvre de GitLab + AWS.\n\nPour consulter des informations plus détaillées et des configurations avancées, reportez-vous aux ressources suivantes :\n\n- [Documentation GitLab](https://docs.gitlab.com/)\n- [Guide de l'utilisateur AWS CodeBuild](https://docs.aws.amazon.com/codebuild/latest/userguide/welcome.html)\n- [Guide de l'utilisateur AWS CodePipeline](https://docs.aws.amazon.com/codepipeline/latest/userguide/welcome.html)\n- [Documentation GitLab CI/CD](https://docs.gitlab.com/ee/ci/)\n- [Intégration avec AWS](https://docs.gitlab.com/ee/solutions/cloud/aws/gitlab_aws_integration.html)\n\nSi vous avez des questions ou si vous avez besoin d'aide, contactez [l'assistance GitLab](https://about.gitlab.com/support/) ou l'assistance AWS. Nous espérons que ce guide complet vous aidera à progresser dans votre parcours d'intégration AWS-GitLab.",[9,683,685,684,687,686,233],"2024-09-05",{"slug":1085,"featured":91,"template":691},"ultimate-guide-to-migrating-from-aws-codecommit-to-gitlab","content:fr-fr:blog:ultimate-guide-to-migrating-from-aws-codecommit-to-gitlab.yml","Ultimate Guide To Migrating From Aws Codecommit To Gitlab","fr-fr/blog/ultimate-guide-to-migrating-from-aws-codecommit-to-gitlab.yml","fr-fr/blog/ultimate-guide-to-migrating-from-aws-codecommit-to-gitlab",{"_path":1091,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":1092,"content":1098,"config":1109,"_id":1111,"_type":14,"title":1112,"_source":16,"_file":1113,"_stem":1114,"_extension":19},"/fr-fr/blog/using-ansible-and-gitlab-as-infrastructure-for-code",{"ogTitle":1093,"schema":1094,"ogImage":1095,"ogDescription":1096,"ogSiteName":673,"noIndex":6,"ogType":674,"ogUrl":1097,"title":1093,"canonicalUrls":1097,"description":1096},"Créez des pipelines IaC évolutifs avec GitLab","\n                        { \"@context\": \"https://schema.org\", \"@type\": \"Article\", \"headline\": \"How to use GitLab and Ansible to create infrastructure as code\", \"author\": [{\"@type\":\"Person\",\"name\":\"Brad Downey\"},{\"@type\":\"Person\",\"name\":\"Sara Kassabian\"}], \"datePublished\": \"2019-07-01\", }","https://res.cloudinary.com/about-gitlab-com/image/upload/f_auto,q_auto,w_820,h_500,c_lfill/v1746211002/zlet4rmfg2z0j6lg16mc.png","Automatisez la gestion de votre infrastructure avec des pipelines CI/CD sécurisés, un scan de sécurité intégré, à l’aide de GitLab, Terraform/OpenTofu, Ansible.","https://about.gitlab.com/blog/using-ansible-and-gitlab-as-infrastructure-for-code",{"heroImage":1095,"body":1099,"authors":1100,"updatedDate":1103,"date":1104,"title":1105,"tags":1106,"description":1108,"category":681},"Les outils d'Infrastructure as Code (IaC), tels que TerraForm/OpenTofu, ou\nde gestion des configurations, tels qu'Ansible, jouent un rôle clé dans de\nnombreux workflows critiques. Ces projets commencent parfois par de simples\nscripts d'automatisations, sans nécessairement suivre les bonnes pratiques\nde développement logiciel ni répondre aux contrôles réglementaires exigés\npour les applications logicielles d'entreprise.\n\n\nSouvent développées par des ingénieurs système ou des ingénieurs d'infrastructure, ces automatisations sont mises en place sans réelle expertise des approches [DevOps](https://about.gitlab.com/fr-fr/topics/devops/ \"Qu'est-ce que le DevOps ?\"), DevSecOps, [CI/CD](https://about.gitlab.com/topics/ci-cd/ \"Qu'est-ce que le CI/CD ?\") et d'automatisation des tests. Dans les grandes entreprises employant de nombreuses équipes d'ingénierie parfois cloisonnées, la situation est encore plus compliquée.\n\n\nChez GitLab, nous maîtrisons l'[approche DevSecOps](https://about.gitlab.com/fr-fr/topics/devsecops/ \"Qu'est-ce que le DevSecOps ?\") depuis plus de 10 ans et utilisons notre plateforme DevSecOps unifiée en interne pour automatiser des tâches critiques à l'échelle de l'entreprise. Nous accompagnons des milliers de clients qui s'appuient sur notre plateforme GitLab pour une variété de processus : Infrastructure as Code (IaC), automatisation, gestion cloud, [ingénierie de plateforme](https://about.gitlab.com/fr-fr/the-source/platform/driving-business-results-with-platform-engineering/ \"Qu'est-ce que l’ingénierie de plateforme ?\") et bien d'autres encore.\n\n\nDécouvrez dans cet article les principales fonctionnalités pour transformer vos puissantes automatisations en pipelines de livraison de logiciels évolutifs et auditables.\n\n\n![Liste d'automatisation](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750433380/oipm6tq8qutoh1ctredd.png)\n\n\n## Mise en œuvre\n\n\n[Ce projet de démonstration](https://gitlab.com/gl-demo-ultimate-saberkan/public/ansible-demo) illustre un workflow DevOps complet qui combine la puissance d'OpenTofu avec les pratiques modernes d'Ansible, le tout orchestré via les [pipelines CI/CD](https://about.gitlab.com/fr-fr/topics/ci-cd/cicd-pipeline/ \"Qu'est-ce qu'un pipeline CI/CD ?\") de GitLab. Il met en scène le provisionnement d'un environnement de test AWS à l'aide de composants OpenTofu intégrés à GitLab, suivi du déploiement d'un serveur web Tomcat à l'aide de la version la plus récente d'Ansible, avec exécution dans un environnement personnalisé et prise en charge des collections.\n\n\nLe projet tire parti de nombreuses fonctionnalités de GitLab :\n\n\n* Création et stockage d'environnements d'exécution Ansible personnalisés dans le [registre de conteneurs de GitLab](https://docs.gitlab.com/user/packages/container_registry/)\n\n* [Scan de sécurité des scripts d'IaC et des conteneurs permettant de détecter des vulnérabilités](https://docs.gitlab.com/user/application_security/iac_scanning/)\n\n* Intégration du [linting Ansible avec GitLab Code Quality](https://docs.gitlab.com/user/application_security/iac_scanning/)\n\n* Stockage des binaires Tomcat dans le [dépôt de paquets génériques](https://docs.gitlab.com/user/packages/generic_packages/)\n\n* Utilisation des [variables d'environnement CI/CD à des fins de configuration](https://docs.gitlab.com/ci/variables/)\n\n\nL'ensemble du workflow est automatisé par le biais d'un [pipeline GitLab](https://docs.gitlab.com/ci/pipelines/) qui gère toutes les étapes, du provisionnement de l'infrastructure au déploiement des applications, en passant par les tests de sécurité.\n\n\n![ Workflow automatisé via un pipeline GitLab ](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750433380/giatmolwn9inusi4cev2.png)\n\n\n### Provisionnement de l'environnement avec OpenTofu\n\n\nLe projet commence par le provisionnement d'un environnement de test AWS à l'aide d'OpenTofu, en s'appuyant sur l'intégration native des [composants OpenTofu de GitLab](https://docs.gitlab.com/user/infrastructure/iac/), qui rationalisent le processus de provisionnement de l'infrastructure. Le pipeline inclut des étapes de validation, de planification et d'application qui garantissent un déploiement approprié de l'infrastructure tout en maintenant les bonnes pratiques IaC de GitLab.\n\n\nCe projet tire parti des capacités de l'[outil de gestion des fichiers d'état de Terraform intégré à GitLab](https://docs.gitlab.com/user/infrastructure/iac/terraform_state/) ainsi que du [Terraform Module Registry](https://docs.gitlab.com/user/packages/terraform_module_registry/), tous deux compatibles avec OpenTofu et HashiCorp Terraform. Il est également possible d'utiliser les composants OpenTofu de GitLab avec HashiCorp Terraform en procédant à une [légère personnalisation](https://gitlab.com/components/opentofu#can-i-use-this-component-with-terraform) : vous devez créer votre propre image incluant un script nommé `gitlab-tofu` pour maintenir sa compatibilité avec les jobs de composants. Vous pouvez ensuite remplacer les commandes `tofu` par les commandes `Terraform` équivalentes.\n\n\nL'exemple de composant « OpenTofu Module Release » montre comment créer un module Terraform et le stocker dans Terraform Module Registry dans GitLab. Ce module est ensuite importé dans le fichier `provision_lab.tf` directement depuis GitLab pour déployer l'environnement de test sur AWS. Ensuite, il génère un fichier d'inventaire contenant l'adresse IP publique de l'instance provisionnée, qui peut être utilisée dans les étapes de gestion des configurations avec Ansible.\n\n\n```\n\n# From .gitlab-ci.yml\n - component: gitlab.com/components/opentofu/module-release@1.1.0\n   inputs:\n     root_dir: tofu\n     as: 🔍 tofu-module-release\n     stage: 🏗️ build-tofu-module\n     module_version: 0.0.1\n     module_system: aws\n     module_name: aws-lab\n     root_dir: tofu/modules/ansible-demo/aws-lab\n     rules:\n       - if: \"$CI_COMMIT_BRANCH\"\n         when: manual\n```\n\n\n```\n\n# From provision_lab.tf\n\nmodule \"aws-lab\" {\n  source = \"https://gitlab.com/api/v4/projects/67604719/packages/terraform/modules/aws-lab/aws/0.0.1\"\n}\n\n```\n\n\nLes composants de validation, de planification et de déploiement sont configurés avec le paramètre `**auto_define_backend: true**`. Ils s'intègrent automatiquement au backend de stockage d’état Terraform intégré à GitLab et éliminent le besoin de configuration manuelle du backend ou de solutions de stockage d'état externes telles que des compartiments S3.\n\n\n```\n\n# From gitlab-ci.yml\n\n- component: gitlab.com/components/opentofu/apply@0.55.0\n  inputs:\n    version: 0.55.0\n    opentofu_version: 1.8.8\n    root_dir: tofu\n    state_name: demo\n    as: ✅ tofu-apply\n    stage: 🏗️ provision-lab\n    auto_define_backend: true\n    rules:\n      - if: \"$CI_COMMIT_BRANCH\"\n        when: manual\n```\n\n\n![Les composants de validation, de planification et de déploiement sont configurés avec le paramètre `auto_define_backend: true`](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750433380/giatmolwn9inusi4cev2.png)\n\n\nLa configuration de l'infrastructure crée une instance EC2 CentOS Stream 9 avec des groupes de sécurité appropriés pour autoriser l'accès SSH depuis les runners GitLab et l'accès HTTP au serveur Tomcat.\n\n\nL'accès SSH et la configuration HTTP sont configurés par le biais des [variables d'environnement GitLab CI/CD](https://docs.gitlab.com/ci/variables/#define-a-cicd-variable-in-the-ui).\n\n\n![Accès SSH et configuration HTTP](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750433381/cmqtzg6ahz8ua5w8ybgs.png)\n\n\nPour un accès sécurisé au cloud, le projet met en œuvre [l'intégration OpenID Connect de GitLab](https://docs.gitlab.com/ci/cloud_services/aws/) avec AWS, en utilisant des identifiants de connexion temporaires via AWS Security Token Service (STS) :\n\n\n```\n\n# From .gitlab-ci.yml\n\n.tofu_aws_setup:\n id_tokens:\n   OIDC_TOKEN:\n     aud: https://gitlab.com\n before_script:\n   - echo \"${OIDC_TOKEN}\" > /tmp/web_identity_token\n   - export AWS_PROFILE=\"\"\n   - export AWS_ROLE_ARN=\"${AWS_ROLE_ARN}\"\n   - export AWS_WEB_IDENTITY_TOKEN_FILE=\"/tmp/web_identity_token\"\n```\n\n\n### Création de l'environnement d'exécution Ansible\n\n\nLes déploiements modernes avec Ansible reposent largement sur l'utilisation d'[environnements d'exécution](https://docs.ansible.com/ansible/latest/getting_started_ee/index.html) : il s'agit de versions conteneurisées qui encapsulent Ansible avec toutes ses dépendances, y compris les rôles et les collections préinstallés nécessaires. Dans ce projet, un environnement d'exécution personnalisé est créé, basé sur Fedora 39, qui inclut ansible-core, ansible-runner ainsi que des collections spécifiques, telle que ansible.posix, requise dans cet exemple pour configurer le pare-feu et SELinux.\n\n\nLes rôles et collections tiers de ce projet sont téléchargés en mode natif à partir du dépôt communautaire Ansible Galaxy. Cette approche s'appuie sur l'écosystème de contenu Ansible réutilisable de la communauté, comme le montre la configuration de l'environnement d'exécution. Bien que cette démonstration utilise des ressources Ansible de la communauté, cette mise en œuvre de pipeline est entièrement compatible avec Red Hat Ansible Automation Platform. La structure du pipeline reste identique ; seules les sources de contenu changent. Ainsi, les entreprises qui utilisent la version Enterprise peuvent simplement rediriger leurs sources de contenu d'automatisation vers leur Automation Hub privé au lieu du dépôt Ansible Galaxy par défaut issu de la communauté. Selon la documentation officielle d'Ansible, vous pouvez réaliser cette opération en [configurant votre serveur Automation Hub privé et votre token d'accès dans le fichier ansible.cfg](https://docs.redhat.com/en/documentation/red_hat_ansible_automation_platform/1.2/html/getting_started_with_red_hat_ansible_automation_hub/proc-configure-automation-hub-server#proc-configure-automation-hub-server).\n\n\n```\n\n# From execution-environment.yml\n\n---\n\nversion: 3\n\n\nimages:\n  base_image:\n    name: quay.io/fedora/fedora:39\n\ndependencies:\n  ansible_core:\n    package_pip: ansible-core\n  ansible_runner:\n    package_pip: ansible-runner\n  system:\n    - openssh-clients\n    - sshpass\n  galaxy:\n    collections:\n    - name: ansible.posix\n      version: \">=2.0.0\"\n```\n\n\n![Environnement d'exécution faisant l'objet d'un push vers le registre de conteneurs de GitLab ](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750433384/dh1o2ojjmb04ru4tfr9k.png)\n\n\nL'environnement d'exécution est défini dans un fichier YAML, généré à l'aide d'ansible-builder, puis faisant l'objet d'un push vers le [registre de conteneurs de GitLab](https://docs.gitlab.com/user/packages/container_registry/). Cette approche garantit des environnements d'exécution cohérents d'un système à l'autre, tout en simplifiant la gestion des dépendances.\n\n\n```\n\n# From gitlab-ci.yml\n\n🔨 ansible-build-ee:\n  stage: 📦 ansible-build-ee\n  image: docker:24.0.5\n  needs: []\n  services:\n    - docker:24.0.5-dind\n  before_script:\n    - apk add --no-cache python3 py3-pip\n    - pip install ansible-builder\n    - cd ansible/execution-environment\n  script:\n    - ansible-builder build -t ${EE_IMAGE_NAME}:${EE_IMAGE_TAG} --container-runtime docker\n    - docker tag ${EE_IMAGE_NAME}:${EE_IMAGE_TAG} ${CI_REGISTRY_IMAGE}/${EE_IMAGE_NAME}:${EE_IMAGE_TAG}\n    - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY\n    - docker push ${CI_REGISTRY_IMAGE}/${EE_IMAGE_NAME}:${EE_IMAGE_TAG}\n```\n\n\n### Déploiement de Tomcat avec Ansible\n\n\nUne fois l'infrastructure provisionnée et l'environnement d'exécution construit, le pipeline déploie Tomcat à l'aide d'[Ansible Navigator](https://ansible.readthedocs.io/projects/navigator/). L'environnement d'exécution créé à l'étape précédente est utilisé comme image pour le job de déploiement dans le pipeline GitLab.\n\n\n```\n\n# From gitlab-ci.yml\n\n🚀 ansible-deploy:\n  stage: 🚀 ansible-deploy\n  image: ${CI_REGISTRY_IMAGE}/${EE_IMAGE_NAME}:${EE_IMAGE_TAG}\n  needs:\n    - ✅ tofu-apply\n  extends: [.ssh_private_key_setup, .default_rules]\n  script:\n    - ansible-navigator run ansible/playbook.yml \n      -i ansible/inventory/hosts.ini\n      --execution-environment false\n      --mode stdout \n      --log-level debug\n```\n\n\nCe processus récupère le paquet applicatif depuis le [dépôt de paquets générique de GitLab](https://docs.gitlab.com/user/packages/generic_packages/), configure les utilisateurs et les autorisations système, et définit Tomcat comme service systemd.\n\n\n```\n\n# From playbook.yml\n\n---\n\n- name: Deploy Tomcat Server\n  hosts: all\n  become: true\n  roles:\n      - role: tomcat\n  \n  vars:\n    # Tomcat package and installation\n    tomcat_package: \"https://gitlab.com/api/v4/projects/67604719/packages/generic/apache-tomcat/10.1.39/apache-tomcat-10.1.39.tar.gz\"\n    tomcat_install_dir: \"/opt/tomcat\"\n    java_package: \"java-17-openjdk-devel\"\n```\n\n\n![Registre de paquets de GitLab](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750433381/mynak8i2k7ms9vhdijqg.png)\n\n\n### Scan de sécurité et qualité du code\n\n\nLa sécurité est intégrée tout au long du pipeline avec plusieurs outils de scan. Ce projet utilise le [scanner SAST IaC intégré de GitLab](https://docs.gitlab.com/user/application_security/iac_scanning/) pour détecter les vulnérabilités dans le code Terraform et Ansible. L'[analyse des conteneurs](https://docs.gitlab.com/user/application_security/container_scanning/) est appliquée à l'image de l'environnement d'exécution pour identifier tout problème de sécurité et générer une [nomenclature logicielle (SBOM)](https://about.gitlab.com/fr-fr/blog/the-ultimate-guide-to-sboms/ \"Qu'est-ce qu'une nomenclature logicielle ?\").\n\n\n```\n\n# From gitlab-ci.yml\n\ninclude: \n\n- template: Jobs/SAST-IaC.gitlab-ci.yml \n\n- template: Jobs/Container-Scanning.gitlab-ci.yml\n\n```\n\n\n![La sécurité est intégrée à chaque étape du pipeline avec plusieurs outils de scanning](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750433386/e6ejckcv5kdyhhosej2f.png)\n\n\nDe plus, le projet utilise Ansible Linter et ses résultats sont intégrés à [GitLab Code Quality](https://docs.gitlab.com/ci/testing/code_quality/#import-code-quality-results-from-a-cicd-job). Cette intégration produit des rapports qui sont affichés directement dans l'interface de GitLab, ce qui facilite l'identification et la résolution des anomalies.\n\n\n```\n\n# From gitlab-ci.yml\n\n🔍 ansible-lint:\n  stage: 🚀 ansible-deploy\n  image: ${CI_REGISTRY_IMAGE}/${EE_IMAGE_NAME}:${EE_IMAGE_TAG}\n  needs: []\n  script:\n    - ansible-lint ansible/playbook.yml -f codeclimate | python3 -m json.tool | tee gl-code-quality-report.json || true\n  artifacts:\n    reports:\n      codequality:\n        - gl-code-quality-report.json\n```\n\n\n![Le projet utilise Ansible Linter et ses résultats sont intégrés à GitLab Code Quality](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750433380/gsfpaldra4rmtkseaudo.png)\n\n\n### Vérification de l'état du déploiement\n\n\nAprès le déploiement, le pipeline effectue des vérifications de l'état pour s'assurer que le serveur Tomcat fonctionne correctement. Ce job tente d'établir une connexion au port HTTP du serveur et vérifie qu'il renvoie une réponse confirmant que le service est bien actif. Cette étape garantit que le déploiement s'est correctement terminé et que l'application est accessible.\n\n\nVous pouvez également tester l'accès de votre navigateur à l'instance provisionnée par Tomcat en utilisant l'adresse IP publique de l'instance provisionnée EC2.\n\n\n![Vérification de l'état d'un job](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750433385/uksdkjryydxhu94v1naj.png)\n\n\n## Destruction de l'environnement de test\n\n\nDernière étape du pipeline : le processus de nettoyage détruit l'environnement de test. Cette opération est mise en œuvre à l'aide du composant de destruction OpenTofu, qui garantit que toutes les ressources créées au cours de l'étape de provisionnement sont correctement supprimées.\n\n\n## Récapitulatif\n\n\nGitLab offre une plateforme DevSecOps unifiée et un framework pour gérer, à l'échelle de l'entreprise, les pratiques d'automatisation critiques telles que la gestion des configurations et de l'IaC (Infrastructure as Code). Ce framework inclut le [contrôle de version](https://about.gitlab.com/fr-fr/topics/version-control/ \"Qu'est-ce que le contrôle de version ?\"), la planification de projet, la gestion des tickets, la collaboration entre les équipes, les pipelines CI/CD, la gestion du paquet de binaires et du registre de conteneurs, le scan de sécurité et de nombreuses autres fonctionnalités utiles. Il permet également de renforcer la gouvernance grâce à des contrôles intégrés dans les processus. Si vous cherchez à développer vos pratiques cloud (qu’il s’agisse d’un cloud privé ou public) ou plus généralement, de tout workflow d'automatisation en libre-service doté de règles de gouvernance, envisagez d'utiliser GitLab, TerraForm et Ansible comme les trois piliers d'une plateforme d'automatisation à la fois évolutive et conforme aux exigences de gouvernance.\n\n\n> Lancez-vous avec un [essai gratuit de GitLab Ultimate](http://bout.gitlab.com/free-trial/). Inscrivez-vous dès aujourd'hui !\n",[1101,1102],"George Kichukov","Salahddine Aberkan","2025-07-17","2019-07-01","GitLab DevSecOps : des pipelines IaC au service de votre croissance",[1107,9],"demo","Découvrez comment automatiser la gestion de votre infrastructure pour accompagner la croissance de votre entreprise grâce à des pipelines CI/CD sécurisés et un scan de sécurité intégré, à l'aide de GitLab, Terraform/OpenTofu et Ansible.",{"slug":1110,"featured":6,"template":691},"using-ansible-and-gitlab-as-infrastructure-for-code","content:fr-fr:blog:using-ansible-and-gitlab-as-infrastructure-for-code.yml","Using Ansible And Gitlab As Infrastructure For Code","fr-fr/blog/using-ansible-and-gitlab-as-infrastructure-for-code.yml","fr-fr/blog/using-ansible-and-gitlab-as-infrastructure-for-code",{"_path":1116,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":1117,"content":1123,"config":1131,"_id":1133,"_type":14,"title":1134,"_source":16,"_file":1135,"_stem":1136,"_extension":19},"/fr-fr/blog/using-child-pipelines-to-continuously-deploy-to-five-environments",{"ogTitle":1118,"schema":1119,"ogImage":1120,"ogDescription":1121,"ogSiteName":673,"noIndex":6,"ogType":674,"ogUrl":1122,"title":1118,"canonicalUrls":1122,"description":1121},"Déployer en continu dans de multiples environnements","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Déployer en continu dans de multiples environnements avec les pipelines enfants\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Olivier Dupré\"}],\n        \"datePublished\": \"2024-09-26\",\n      }","https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097012/Blog/Hero%20Images/Blog/Hero%20Images/AdobeStock_397632156_3Ldy1urjMStQCl4qnOBvE0_1750097011626.jpg","Découvrez comment créer un workflow rationalisé dans GitLab pour gérer le déploiement continu dans de multiples environnements.","https://about.gitlab.com/blog/using-child-pipelines-to-continuously-deploy-to-five-environments",{"heroImage":1120,"body":1124,"authors":1125,"updatedDate":1127,"date":1128,"title":1129,"tags":1130,"description":1121,"category":681},"Les équipes DevSecOps doivent parfois coordonner le déploiement continu dans\ndes environnements différents, tout en préservant leurs workflows. La\n[plateforme DevSecOps de GitLab](https://about.gitlab.com/fr-fr) répond à ce\nbesoin, de manière simple et efficace, y compris avec des environnements\nsandbox temporaires créés à la demande. Découvrez dans cet article un\nexemple de mise en œuvre de ce processus en déployant une architecture avec\nTerraform sur plusieurs environnements cibles.\n\n\nCette stratégie s'adapte facilement qu'il s'agisse d'un projet d'Infrastructure as Code (IaC) utilisant une autre technologie comme [Pulumi](https://www.pulumi.com/) ou [Ansible](https://www.ansible.com/), d'un projet de code source ou d'un projet de dépôt monolithique combinant plusieurs langages.\n\n\nÀ la fin de ce tutoriel, le pipeline que vous aurez créé permettra de déployer :\n\n\n* Un environnement temporaire de **développement** pour chaque branche de fonctionnalité.\n\n* Un environnement d'**intégration**, qu'il est facile de supprimer et redéployer à partir de la branche principale.\n\n* Un environnement d'**assurance qualité (QA)**, également déployé à partir de la branche principale, pour exécuter les étapes de QA.\n\n* Un environnement de **préproduction** pour chaque tag, dernière étape avant la phase de production.\n\n* Un environnement de **production** qui dans cet exemple sera déployé manuellement, mais qui peut également être déployé en continu.\n\n\n> Légende des schémas figurant dans cet article :\n\n>\n\n> * Les encarts aux angles arrondis représentent les branches de GitLab.\n\n> * Les encarts rectangulaires représentent les environnements.\n\n> * Le texte sur les flèches représente les actions requises pour passer d'un encart à l'autre.\n\n> * Les encarts carrés représentent une prise de décision.\n\n\n\u003Cpre class=\"mermaid\">\n\nflowchart LR\n    A(main) -->|new feature| B(feature_X)\n\n    B -->|auto deploy| C[review/feature_X]\n    B -->|merge| D(main)\n    C -->|destroy| D\n\n    D -->|auto deploy| E[integration]\n    E -->|manual| F[qa]\n\n    D -->|tag| G(X.Y.Z)\n    F -->|validate| G\n\n    G -->|auto deploy| H[staging]\n    H -->|manual| I{plan}\n    I -->|manual| J[production]\n\u003C/pre>\n\n\nNous allons vous expliquer les [raisons](#why) des [actions](#what) présentées dans le flowchart ci-dessus, ainsi que [les étapes à suivre](#how) pour chacune d'elles. Ce tutoriel sera ainsi plus facile à suivre et vous pourrez le reproduire sans difficulté.\n\n\n## Raisons\n\n\n* [L'intégration continue (CI)](https://about.gitlab.com/fr-fr/topics/ci-cd/) constitue quasiment une norme établie. La plupart des entreprises implémentent des pipelines CI ou cherchent à standardiser leurs pratiques.\n\n* La [livraison continue (CD)](https://about.gitlab.com/fr-fr/topics/ci-cd/), qui consiste à effectuer la publication des artefacts vers un dépôt ou un registre à la fin du pipeline CI, est également courante.\n\n* L'étape suivante, le [déploiement continu](https://about.gitlab.com/fr-fr/topics/ci-cd/#what-is-continuous-deployment \"Qu'est-ce que le déploiement continu ? \"), qui automatise le déploiement de ces artefacts, est en revanche moins répandu. Il est essentiellement implémenté dans le domaine des applications. Le déploiement continu d'une infrastructure est plus compliqué et implique la gestion de plusieurs environnements. Tester, sécuriser et vérifier le code de l'infrastructure constitue un défi supplémentaire et c'est un domaine où le processus [DevOps](https://about.gitlab.com/fr-fr/topics/devops/ \"Que signifie DevOps ?\") n'a pas encore atteint sa pleine maturité. L'intégration de la sécurité en amont, qui nécessite l'implication des équipes de sécurité, représente également une difficulté. Et il est très important de prendre en compte les problèmes de sécurité dès les premières étapes du développement, afin de passer d'une approche DevOps à un processus **[DevSecOps](https://about.gitlab.com/fr-fr/topics/devsecops/ \"Qu'est-ce que DevSecOps ?\")**.\n\n\nCe tutoriel vous invite à tester une méthode simple et efficace pour adopter une approche DevSecOps pour votre infrastructure. Nous prendrons l'exemple du déploiement de ressources dans cinq environnements, du développement à la production.\n\n\n**Remarque :** même si je préconise l'adoption d'une [approche FinOps](https://about.gitlab.com/fr-fr/the-source/platform/finops-balancing-financial-responsibility-and-innovation/ \"Qu'est-ce que l'approche FinOps ? \") et la réduction du nombre d'environnements, il existe parfois d'excellentes raisons de ne pas se limiter aux simples étapes de développement, préproduction et production. N'hésitez pas à adapter les exemples en fonction de vos besoins.\n\n\n## Actions\n\n\nL’avènement du cloud a boosté l'utilisation de l'IaC. Ansible et Terraform ont ouvert la voie, suivis par OpenTofu, Pulumi, AWS CDK, Google Deploy Manager et bien d'autres.\n\n\nUne Infrastructure as Code est la solution parfaite pour déployer une infrastructure de manière sécurisée. Vous pouvez la tester, la déployer et la réappliquer autant de fois que nécessaire pour atteindre votre objectif.\n\n\nMalheureusement, les entreprises maintiennent souvent plusieurs branches, voire de multiples dépôts, pour chacun de leurs environnements cibles, ce qui crée des problèmes. Elles ne respectent plus un processus rigoureux. Elles ne s'assurent plus que chaque modification du code en production a été soigneusement testée dans les environnements précédents. Par conséquent, des décalages apparaissent peu à peu d'un environnement à l'autre.\n\n\nJ'ai réalisé que ce tutoriel était nécessaire lors d'une conférence à laquelle j'ai assisté : tous les participants ont déclaré que leur workflow n'imposait des tests rigoureux de l'infrastructure qu'avant le déploiement en production. Et ils ont tous convenu qu'ils appliquaient parfois des correctifs directement en production. Bien sûr, cette démarche permet d'aller vite, mais est-elle sûre ? Comment reporter les correctifs sur les environnements précédents ? Comment vérifier qu'il n'y a pas d'effets de bord ? Comment limiter les risques auxquels votre entreprise est exposée lorsque vous déployez votre code trop rapidement en production ?\n\n\nLa question essentielle est de savoir *pourquoi* les [équipes DevOps](https://about.gitlab.com/fr-fr/topics/devops/build-a-devops-team/ \"Créer une structure d'équipe DevOps idéale\") déploient directement en production. Le pipeline devrait-il être plus efficace ou plus rapide ? N'est-il pas possible d'automatiser le processus ? Ou, pire encore, n'y a-t-il *aucun moyen de tester le code en dehors de l'environnement de production* ?\n\n\nDans la section suivante, vous apprendrez à automatiser votre infrastructure et à garantir que votre équipe DevOps mène des tests efficaces avant d'effectuer un push vers un environnement qui affectera le reste du processus. Vous verrez comment sécuriser votre code et contrôler son déploiement de bout en bout.\n\n\n## Les étapes à suivre\n\n\nComme mentionné précédemment, de nombreux langages permettent actuellement de gérer l'IaC et nous ne pouvons pas *tous* les aborder ici. Je vais m'appuyer sur un code Terraform version 1.4. Ne prêtez pas attention au langage utilisé pour gérer l'IaC, mais plutôt au processus transposable à votre écosystème.\n\n\n### Le code Terraform\n\n\nCommençons par un code Terraform de base.\n\n\nNous allons déployer sur AWS, un cloud privé virtuel (VPC), qui est un réseau virtuel. Dans ce VPC, nous déploierons un sous-réseau public et un sous-réseau privé. Comme leur nom l'indique, il s'agit de sous-réseaux du VPC principal. Enfin, nous ajouterons une instance Elastic Cloud Compute (EC2) (une machine virtuelle) dans le sous-réseau public.\n\n\nNous allons ainsi déployer quatre ressources de manière relativement simple. L'idée est de se concentrer sur le pipeline, et non sur le code.\n\n\nVoici la cible que nous voulons atteindre pour votre dépôt.\n\n\n![cible du dépôt](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097033/Blog/Content%20Images/Blog/Content%20Images/image5_aHR0cHM6_1750097033415.png)\n\n\nDécomposons le processus.\n\n\nTout d'abord, nous déclarons toutes les ressources dans un fichier `terraform/main.tf` :\n\n\n```terraform\n\nprovider \"aws\" {\n  region = var.aws_default_region\n}\n\n\nresource \"aws_vpc\" \"main\" {\n  cidr_block = var.aws_vpc_cidr\n\n  tags = {\n    Name     = var.aws_resources_name\n  }\n}\n\n\nresource \"aws_subnet\" \"public_subnet\" {\n  vpc_id     = aws_vpc.main.id\n  cidr_block = var.aws_public_subnet_cidr\n\n  tags = {\n    Name = \"Public Subnet\"\n  }\n}\n\nresource \"aws_subnet\" \"private_subnet\" {\n  vpc_id     = aws_vpc.main.id\n  cidr_block = var.aws_private_subnet_cidr\n\n  tags = {\n    Name = \"Private Subnet\"\n  }\n}\n\n\nresource \"aws_instance\" \"sandbox\" {\n  ami           = var.aws_ami_id\n  instance_type = var.aws_instance_type\n\n  subnet_id = aws_subnet.public_subnet.id\n\n  tags = {\n    Name     = var.aws_resources_name\n  }\n}\n\n```\n\n\nComme vous pouvez le constater, ce code nécessite plusieurs variables. Nous les déclarons dans un fichier `terraform/variables.tf` :\n\n\n```terraform\n\nvariable \"aws_ami_id\" {\n  description = \"The AMI ID of the image being deployed.\"\n  type        = string\n}\n\n\nvariable \"aws_instance_type\" {\n  description = \"The instance type of the VM being deployed.\"\n  type        = string\n  default     = \"t2.micro\"\n}\n\n\nvariable \"aws_vpc_cidr\" {\n  description = \"The CIDR of the VPC.\"\n  type        = string\n  default     = \"10.0.0.0/16\"\n}\n\n\nvariable \"aws_public_subnet_cidr\" {\n  description = \"The CIDR of the public subnet.\"\n  type        = string\n  default     = \"10.0.1.0/24\"\n}\n\n\nvariable \"aws_private_subnet_cidr\" {\n  description = \"The CIDR of the private subnet.\"\n  type        = string\n  default     = \"10.0.2.0/24\"\n}\n\n\nvariable \"aws_default_region\" {\n  description = \"Default region where resources are deployed.\"\n  type        = string\n  default     = \"eu-west-3\"\n}\n\n\nvariable \"aws_resources_name\" {\n  description = \"Default name for the resources.\"\n  type        = string\n  default     = \"demo\"\n}\n\n```\n\n\nÀ ce stade, nous avons presque terminé la partie IaC. Il nous manque simplement une méthode pour partager les états Terraform. Si vous l'ignorez, Terraform fonctionne schématiquement comme suit :\n\n\n* La commande `plan` vérifie les différences entre l'infrastructure actuelle et celle définie dans le code. Elle génère ensuite un rapport des différences.\n\n* La commande `apply` exécute les modifications en fonction du rapport `plan` et met à jour l'état.\n\n\nLors du premier passage, l'état est vide. Il comporte ensuite les détails (ID, etc.) des ressources appliquées par Terraform.\n\n\nLe problème est le suivant : où cet état est-il stocké ? Comment le partager pour permettre à plusieurs développeurs et développeuses de collaborer sur le code ?\n\n\nLa solution est assez simple : stockez et partagez l'état dans GitLab via un [backend HTTP Terraform](https://docs.gitlab.com/ee/user/infrastructure/iac/terraform_state.html).\n\n\nLorsque vous utilisez ce backend, la première étape consiste à créer le fichier `terraform/backend.tf` le plus simple qui soit. La deuxième étape est prise en charge dans le pipeline.\n\n\n```terraform\n\nterraform {\n  backend \"http\" {\n  }\n}\n\n```\n\n\nEt voilà ! Nous disposons maintenant d'un code Terraform minimaliste pour déployer ces quatre ressources. Nous renseignerons les valeurs des variables lors de l'exécution à une étape ultérieure.\n\n\n### Le workflow\n\n\nMettons en œuvre le workflow suivant :\n\n\n\u003Cpre class=\"mermaid\">\n\nflowchart LR\n    A(main) -->|new feature| B(feature_X)\n\n    B -->|auto deploy| C[review/feature_X]\n    B -->|merge| D(main)\n    C -->|destroy| D\n\n    D -->|auto deploy| E[integration]\n    E -->|manual| F[qa]\n\n    D -->|tag| G(X.Y.Z)\n    F -->|validate| G\n\n    G -->|auto deploy| H[staging]\n    H -->|manual| I{plan}\n    I -->|manual| J[production]\n\u003C/pre>\n\n\n1. Créez une branche de **fonctionnalité**. Elle exécute tous les scanners en continu sur le code pour s'assurer qu'il est toujours conforme et sécurisé. Ce code est déployé en continu dans un environnement temporaire `review/feature_branch` portant le nom de la branche actuelle. Il s'agit d'un environnement sûr où les équipes de développement et d'opérations peuvent tester leur code sans impact sur le reste du Système d’Information (SI). Le processus, comme les revues de code et l'exécution de scanners, est imposé à cette étape pour assurer que la qualité et la sécurité du code sont suffisantes et ne mettent pas votre SI en danger. L'infrastructure déployée par cette branche est automatiquement détruite lorsque la branche est fermée. Vous pouvez ainsi contrôler votre budget.\n\n2. Une fois approuvée, la branche de fonctionnalité est **fusionnée** dans la branche principale. Il s'agit d'une [branche protégée](https://docs.gitlab.com/ee/user/project/protected_branches.html) où aucun push ne peut être effectué directement. Elle est nécessaire pour veiller à ce que chaque demande de modification de l'environnement de production soit minutieusement testée. Cette branche est également déployée en continu. La cible ici est l'environnement `integration`. La suppression de cet environnement n'est pas automatisée pour des questions de stabilité, mais elle peut être déclenchée manuellement.\n\n\n\u003Cpre class=\"mermaid\">\n\nflowchart LR\n    D(main) -->|auto deploy| E[integration]\n\u003C/pre>\n\n\n3. Une approbation manuelle est ensuite nécessaire pour déclencher le déploiement suivant. La branche principale sera déployée dans l'environnement `qa`. J'ai défini une règle ici pour empêcher la suppression depuis le pipeline. Cet environnement devrait être assez stable (après tout, c'est déjà le troisième) et je souhaite éviter une suppression accidentelle. N'hésitez pas à adapter les règles à vos processus.\n\n\n\u003Cpre class=\"mermaid\">\n\nflowchart LR\n    D(main)-->|auto deploy| E[integration]\n    E -->|manual| F[qa]\n\u003C/pre>\n\n\n4. Pour continuer, nous devons **ajouter un tag** au code. Nous utilisons les [tags protégés](https://docs.gitlab.com/ee/user/project/protected_tags.html) pour que seul un ensemble spécifique d'utilisateurs ait l'autorisation de déployer dans ces deux derniers environnements. Ce tag va immédiatement déclencher un déploiement dans l'environnement `staging`.\n\n\n\u003Cpre class=\"mermaid\">\n\nflowchart LR\n    D(main) -->|tag| G(X.Y.Z)\n    F[qa] -->|validate| G\n\n    G -->|auto deploy| H[staging]\n\u003C/pre>\n\n\n5. Nous arrivons enfin à l'environnement `production`. Il est souvent difficile de déployer l'infrastructure progressivement (10 %, 25 %, etc.). Nous la déployons donc dans son intégralité. Nous contrôlons toutefois ce déploiement à l'aide d'un déclencheur manuel intégré dans cette dernière étape. Afin de garder un contrôle maximal sur cet environnement hautement critique, nous le contrôlons en tant qu'[environnement protégé](https://docs.gitlab.com/ee/ci/environments/protected_environments.html).\n\n\n\u003Cpre class=\"mermaid\">\n\nflowchart LR\n    H[staging] -->|manual| I{plan}\n    I -->|manual| J[production]\n\u003C/pre>\n\n\n### Le pipeline\n\n\nPour mettre en œuvre le [workflow](#the-workflow) ci-dessus, nous allons maintenant implémenter un pipeline comportant deux [pipelines enfants](https://docs.gitlab.com/ee/ci/pipelines/downstream_pipelines.html).\n\n\n#### Le pipeline principal\n\n\nCommençons par le pipeline principal. Il est déclenché automatiquement par un **push effectué vers une branche de fonctionnalité**, une **fusion vers la branche par défaut** ou un **tag**. *Il* effectue un vrai **déploiement continu** dans les environnements suivants : `dev`, `integration` et `staging`. Il est déclaré dans le fichier `.gitlab-ci.yml` à la racine de votre projet.\n\n\n![la cible du dépôt](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097033/Blog/Content%20Images/Blog/Content%20Images/image1_aHR0cHM6_1750097033417.png)\n\n\n```yml\n\nstages:\n  - test\n  - environments\n\n.environment:\n  stage: environments\n  variables:\n    TF_ROOT: terraform\n    TF_CLI_ARGS_plan: \"-var-file=../vars/$variables_file.tfvars\"\n  trigger:\n    include: .gitlab-ci/.first-layer.gitlab-ci.yml\n    strategy: depend            # Wait for the triggered pipeline to successfully complete\n    forward:\n      yaml_variables: true      # Forward variables defined in the trigger job\n      pipeline_variables: true  # Forward manual pipeline variables and scheduled pipeline variables\n\nreview:\n  extends: .environment\n  variables:\n    environment: review/$CI_COMMIT_REF_SLUG\n    TF_STATE_NAME: $CI_COMMIT_REF_SLUG\n    variables_file: review\n    TF_VAR_aws_resources_name: $CI_COMMIT_REF_SLUG  # Used in the tag Name of the resources deployed, to easily differenciate them\n  rules:\n    - if: $CI_COMMIT_BRANCH && $CI_COMMIT_BRANCH != $CI_DEFAULT_BRANCH\n\nintegration:\n  extends: .environment\n  variables:\n    environment: integration\n    TF_STATE_NAME: $environment\n    variables_file: $environment\n  rules:\n    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH\n\nstaging:\n  extends: .environment\n  variables:\n    environment: staging\n    TF_STATE_NAME: $environment\n    variables_file: $environment\n  rules:\n    - if: $CI_COMMIT_TAG\n\n#### TWEAK\n\n# This tweak is needed to display vulnerability results in the merge widgets.\n\n# As soon as this issue https://gitlab.com/gitlab-org/gitlab/-/issues/439700 is resolved, the `include` instruction below can be removed.\n\n# Until then, the SAST IaC scanners will run in the downstream pipelines, but their results will not be available directly in the merge request widget, making it harder to track them.\n\n# Note: This workaround is perfectly safe and will not slow down your pipeline.\n\ninclude:\n  - template: Security/SAST-IaC.gitlab-ci.yml\n#### END TWEAK\n\n```\n\n\nCe pipeline n'exécute que deux étapes : `test` et  `environments`. La première est nécessaire pour que le *TWEAK* exécute les scanners. La seconde déclenche un pipeline enfant contenant un ensemble de variables différent pour chaque cas défini ci-dessus (push vers la branche, fusion dans la branche par défaut ou tag).\n\n\nNous ajoutons ici une dépendance avec le mot-clé [strategy:depend](https://docs.gitlab.com/ee/ci/yaml/index.html#triggerstrategy) sur notre pipeline enfant afin que la vue du pipeline dans GitLab ne soit mise à jour qu'une fois le déploiement terminé.\n\n\nComme vous le voyez, nous définissons un job de base [masqué](https://docs.gitlab.com/ee/ci/jobs/#hide-jobs), puis nous ajoutons des variables et des règles spécifiques afin de déclencher un seul déploiement pour chaque environnement cible.\n\n\nOutre les [variables prédéfinies](https://docs.gitlab.com/ee/ci/variables/predefined_variables.html), nous utilisons deux nouveaux éléments que nous devons définir :\n\n\n1. [Les variables spécifiques](#the-variable-definitions) à chaque environnement : `../vars/$variables_file.tfvars`\n\n2. [Le pipeline enfant](#the-child-pipeline), défini dans `.gitlab-ci/.first-layer.gitlab-ci.yml`\n\n\nCommençons par le plus rapide, les définitions des variables.\n\n\n### Les définitions des variables\n\n\nNous allons ici mélanger deux solutions pour fournir des variables à Terraform :\n\n\n* La première utilise des [fichiers .tfvars](https://developer.hashicorp.com/terraform/language/values/variables#variable-definitions-tfvars-files) pour tous les intrants ne contenant pas de données sensibles, qui doivent être stockées dans GitLab.\n\n\n![solution 1 pour fournir des variables à Terraform](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097034/Blog/Content%20Images/Blog/Content%20Images/image2_aHR0cHM6_1750097033419.png)\n\n\n* La seconde utilise des [variables d'environnement](https://developer.hashicorp.com/terraform/language/values/variables#environment-variables) avec le préfixe `TF_VAR`. Combinée à la capacité de GitLab à [masquer les variables](https://docs.gitlab.com/ee/ci/variables/#mask-a-cicd-variable), à [les protéger](https://docs.gitlab.com/ee/ci/variables/#protect-a-cicd-variable) et à les rendre [accessibles uniquement pour certains environnements](https://docs.gitlab.com/ee/ci/environments/index.html#limit-the-environment-scope-of-a-cicd-variable), cette deuxième façon d'injecter des variables est une solution puissante pour **empêcher les fuites d'informations contenant des données sensibles**. Par exemple, si vous considérez que le routage CIDR privé de votre environnement de production est une donnée sensible, vous pouvez le protéger de cette manière. Veillez à ce qu'il ne soit disponible que pour l'environnement `production`, pour les pipelines fonctionnant avec des branches et des tags protégés, et que sa valeur soit masquée dans les journaux du job.\n\n\n![solution 2 pour fournir des variables à Terraform](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097034/Blog/Content%20Images/Blog/Content%20Images/image4_aHR0cHM6_1750097033422.png)\n\n\nDe plus, chaque fichier de variables doit être contrôlé via un [fichier `CODEOWNERS`](https://docs.gitlab.com/ee/user/project/codeowners/) où sont définies les personnes ayant l'autorisation d'apporter des modifications.\n\n\n```\n\n[Production owners] \n\nvars/production.tfvars @operations-group\n\n\n[Staging owners]\n\nvars/staging.tfvars @odupre @operations-group\n\n\n[CodeOwners owners]\n\nCODEOWNERS @odupre\n\n```\n\n\nCet article n'a pas pour but d'expliquer Terraform, nous allons donc simplement montrer le fichier `vars/review.tfvars`. Les fichiers d'environnement suivants sont, bien sûr, très similaires. Il suffit de définir les variables ne contenant pas de données sensibles et leurs valeurs ici.\n\n\n```shell\n\naws_vpc_cidr = \"10.1.0.0/16\"\n\naws_public_subnet_cidr = \"10.1.1.0/24\"\n\naws_private_subnet_cidr = \"10.1.2.0/24\"\n\n```\n\n\n#### Le pipeline enfant\n\n\nC'est dans ce pipeline que le travail concret est effectué. Il est donc un peu plus complexe que le premier. Mais rien qu'on ne puisse surmonter ensemble !\n\n\nComme nous l'avons vu dans la définition du pipeline principal, ce pipeline enfant est déclaré dans le fichier `.gitlab-ci/.first-layer.gitlab-ci.yml`.\n\n\n![Pipeline downstream déclaré dans le fichier](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097033/Blog/Content%20Images/Blog/Content%20Images/image3_aHR0cHM6_1750097033424.png)\n\n\nDécomposons-le en petites étapes avant de revenir à une vue d'ensemble.\n\n\n##### Exécution des commandes Terraform et sécurisation du code\n\n\nNous allons d'abord mettre en place un pipeline pour Terraform. GitLab est une plateforme open source tout comme notre template de pipeline pour Terraform. Il vous suffit de l'inclure, en utilisant l'extrait de code suivant :\n\n\n```yml\n\ninclude:\n  - template: Terraform.gitlab-ci.yml\n```\n\n\nCe template exécute les vérifications Terraform sur le formatage et valide votre code, avant de le planifier et de l'appliquer. Il vous permet également de détruire ce que vous avez déployé.\n\n\nEn tant que plateforme DevSecOps unifiée, GitLab intègre deux scanners de sécurité directement dans ce template afin de détecter les menaces potentielles dans votre code et de vous avertir avant tout déploiement dans les environnements suivants.\n\n\nMaintenant que nous avons vérifié, sécurisé, compilé et déployé notre code, explorons quelques astuces supplémentaires.\n\n\n##### Partage du cache entre les jobs\n\n\nPour réutiliser les résultats des jobs dans les étapes suivantes du pipeline, nous allons activer la mise en cache. Il suffit d'ajouter le code suivant :\n\n\n```yml\n\ndefault:\n  cache:  # Use a shared cache or tagged runners to ensure terraform can run on apply and destroy\n    - key: cache-$CI_COMMIT_REF_SLUG\n      fallback_keys:\n        - cache-$CI_DEFAULT_BRANCH\n      paths:\n        - .\n```\n\n\nNous définissons ici un cache différent pour chaque commit, en revenant au nom de la branche principale si nécessaire.\n\n\nEn regardant de près les templates utilisés, on observe qu’ils contiennent des règles contrôlant l’exécution des jobs. Nous voulons exécuter tous les contrôles (assurance qualité et sécurité) sur toutes les branches. Nous allons donc personnaliser ces paramètres.\n\n\n##### Exécution des contrôles sur toutes les branches\n\n\nLes templates GitLab offrent une fonctionnalité puissante permettant de modifier uniquement certaines parties d’un template. Nous souhaitons seulement remplacer les règles de certains jobs afin de toujours exécuter des contrôles d'assurance qualité et de sécurité. Les autres paramètres de ces jobs resteront conformes au template.\n\n\n```yml\n\nfmt:\n  rules:\n    - when: always\n\nvalidate:\n  rules:\n    - when: always\n\nkics-iac-sast:\n  rules:\n    - when: always\n\niac-sast:\n  rules:\n    - when: always\n```\n\n\nMaintenant que nous avons appliqué les contrôles d'assurance qualité et de sécurité, nous voulons différencier le comportement des environnements principaux (intégration et préproduction) dans le [workflow](#the-workflow) par rapport aux environnements de revue. Commençons par définir le comportement des environnements principaux. Nous modifierons ensuite cette configuration pour les environnements de revue.\n\n\n##### Pipeline CD pour l'intégration et la préproduction\n\n\nComme indiqué, nous voulons déployer la branche principale et les tags dans ces deux environnements. Nous ajoutons des règles pour contrôler ce déploiement sur les jobs `build` et `deploy`. Ensuite, nous activons la fonction `destroy` uniquement pour `integration`, car l'environnement `staging` est trop critique pour être supprimé en un seul clic. Les erreurs sont possibles et nous souhaitons les éviter.\n\n\nEnfin, nous relions le job `deploy` au job `destroy`, afin de pouvoir déclencher un `stop` sur l'environnement directement à partir de l'interface utilisateur graphique de GitLab.\n\n\n`GIT_STRATEGY` positionné à `none` empêche la récupération du code de la branche source dans le runner lors de la destruction. L'opération échouerait si la branche avait été supprimée manuellement. Nous comptons donc sur le cache pour obtenir tout ce dont nous avons besoin pour exécuter les instructions Terraform.\n\n\n```yml\n\nbuild:  # terraform plan\n  environment:\n    name: $TF_STATE_NAME\n    action: prepare\n  rules:\n    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH\n    - if: $CI_COMMIT_TAG\n\ndeploy: # terraform apply --> automatically deploy on corresponding env (integration or staging) when merging to default branch or tagging. Second layer environments (qa and production) will be controlled manually\n  environment: \n    name: $TF_STATE_NAME\n    action: start\n    on_stop: destroy\n  rules:\n    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH\n    - if: $CI_COMMIT_TAG\n\ndestroy:\n  extends: .terraform:destroy\n  variables:\n    GIT_STRATEGY: none\n  dependencies:\n    - build\n  environment:\n    name: $TF_STATE_NAME\n    action: stop\n  rules:\n    - if: $CI_COMMIT_TAG  # Do not destroy production\n      when: never\n    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH && $TF_DESTROY == \"true\" # Manually destroy integration env.\n      when: manual\n```\n\n\nComme indiqué, cela nous permet de déployer sur les environnements `integration` et `staging`. Mais il manque toujours un environnement temporaire où les développeurs et développeuses peuvent expérimenter et valider leur code sans affecter le travail des autres. C'est tout l'intérêt du déploiement dans l'environnement `review`.\n\n\n##### Pipeline CD pour les environnements de revue\n\n\nLe déploiement dans l'environnement de revue n'est pas très différent du déploiement dans les environnements `integration` et `staging`. Nous allons une fois de plus tirer parti de la capacité de GitLab à remplacer uniquement des éléments de définition de job.\n\n\nTout d'abord, nous définissons des règles pour exécuter ces jobs uniquement sur les branches de fonctionnalités.\n\n\nEnsuite, nous relions le job `deploy_review` à `destroy_review`. Nous pouvons ainsi arrêter l'environnement **manuellement** à partir de l'interface utilisateur de GitLab. Plus important encore, ce job **déclenche automatiquement la destruction de l'environnement** lorsque la branche de fonctionnalité est fermée. Cette bonne pratique FinOps vous aide à contrôler vos dépenses opérationnelles.\n\n\nPuisque Terraform a besoin d'un fichier de plan pour la destruction d'une infrastructure, comme pour la compilation, nous ajoutons une dépendance de `destroy_review` à `build_review` afin de récupérer ses artefacts.\n\n\nEnfin, nous voyons ici que le nom de l'environnement est `$environment`. Il a été défini sur `review/$CI_COMMIT_REF_SLUG` dans le [pipeline principal](#the-main-pipeline) et transmis à ce pipeline enfant avec l'instruction `trigger:forward:yaml_variables:true`.\n\n\n```yml\n\nbuild_review:\n  extends: build\n  rules:\n    - if: $CI_COMMIT_TAG\n      when: never\n    - if: $CI_COMMIT_BRANCH != $CI_DEFAULT_BRANCH\n      when: on_success\n\ndeploy_review:\n  extends: deploy\n  dependencies:\n    - build_review\n  environment:\n    name: $environment\n    action: start\n    on_stop: destroy_review\n    # url: https://$CI_ENVIRONMENT_SLUG.example.com\n  rules:\n    - if: $CI_COMMIT_TAG\n      when: never\n    - if: $CI_COMMIT_BRANCH != $CI_DEFAULT_BRANCH\n      when: on_success\n\ndestroy_review:\n  extends: destroy\n  dependencies:\n    - build_review\n  environment:\n    name: $environment\n    action: stop\n  rules:\n    - if: $CI_COMMIT_TAG  # Do not destroy production\n      when: never\n    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH   # Do not destroy staging\n      when: never\n    - when: manual\n```\n\n\nPour récapituler, nous avons maintenant un pipeline qui peut :\n\n\n* Déployer des environnements de revue temporaires, qui sont automatiquement détruits lorsque la branche de fonctionnalité est fermée\n\n* Déployer en continu la **branche par défaut** sur `integration`\n\n* Déployer en continu les **tags** sur l'environnement `staging`\n\n\nAjoutons maintenant un niveau supplémentaire, où nous allons déployer sur les environnements `qa` et `production` avec un déclencheur manuel.\n\n\n##### Pipeline CD pour l'assurance qualité et la production\n\n\nComme tout le monde n'est pas prêt à effectuer des déploiements continus en production, nous ajoutons une validation manuelle pour les deux prochains déploiements. À strictement parler, nous ne devrions pas ajouter ce déclencheur dans un processus **CD**, mais profitons de cette occasion pour vous apprendre à exécuter des jobs à partir d'autres déclencheurs.\n\n\nJusqu'à présent, nous avons lancé un [pipeline enfant](#the-child-pipeline) à partir du [pipeline principal](#the-main-pipeline) pour exécuter tous les déploiements.\n\n\nComme nous voulons exécuter d'autres déploiements à partir de la branche par défaut et des tags, nous ajoutons un nouveau niveau pour ces étapes supplémentaires. Rien de bien nouveau. Nous allons répéter le processus utilisé pour le [pipeline principal](#the-main-pipeline). En procédant de cette façon, vous pouvez manipuler autant de niveaux que vous le souhaitez. J'ai déjà vu jusqu'à neuf environnements.\n\n\nSans revenir sur les avantages d'un nombre limité d'environnements, le processus que nous utilisons ici permet d'implémenter très facilement le même pipeline, de la phase initiale jusqu’à la livraison finale, tout en gardant la définition de votre pipeline simple et divisée en petits segments que vous pouvez maintenir facilement.\n\n\nPour éviter les conflits de variables, nous utilisons simplement de nouveaux noms pour identifier l'état Terraform et le fichier d'intrant.\n\n\n```yml\n\n.2nd_layer:\n  stage: 2nd_layer\n  variables:\n    TF_ROOT: terraform\n  trigger:\n    include: .gitlab-ci/.second-layer.gitlab-ci.yml\n    # strategy: depend            # Do NOT wait for the downstream pipeline to finish to mark upstream pipeline as successful. Otherwise, all pipelines will fail when reaching the pipeline timeout before deployment to 2nd layer.\n    forward:\n      yaml_variables: true      # Forward variables defined in the trigger job\n      pipeline_variables: true  # Forward manual pipeline variables and scheduled pipeline variables\n\nqa:\n  extends: .2nd_layer\n  variables:\n    TF_STATE_NAME_2: qa\n    environment: $TF_STATE_NAME_2\n    TF_CLI_ARGS_plan_2: \"-var-file=../vars/$TF_STATE_NAME_2.tfvars\"\n  rules:\n    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH\n\nproduction:\n  extends: .2nd_layer\n  variables:\n    TF_STATE_NAME_2: production\n    environment: $TF_STATE_NAME_2\n    TF_CLI_ARGS_plan_2: \"-var-file=../vars/$TF_STATE_NAME_2.tfvars\"\n  rules:\n    - if: $CI_COMMIT_TAG\n```\n\n\n**Un point important ici est la stratégie utilisée pour le nouveau pipeline enfant.** Nous maintenons la valeur par défaut du déclencheur `trigger:strategy`. Dans le cas contraire, le [pipeline principal](#the-main-pipeline) attend la fin de votre [pipeline de niveau « petit-enfant »](#the-grand-child-pipeline). Si vous utilisez un déclencheur manuel, cette opération peut prendre beaucoup de temps et rendre votre tableau de bord de pipeline plus difficile à lire et à comprendre.\n\n\nVous vous demandez probablement ce que contient le fichier `.gitlab-ci/.second-layer.gitlab-ci.yml` qui est inclus ici. Nous aborderons cette question dans la section suivante.\n\n\n##### Le premier niveau complet de définition de pipeline\n\n\nSi vous recherchez une vue complète de ce premier niveau (stocké dans `.gitlab-ci/.first-layer.gitlab-ci.yml`), consultez la section suivante.\n\n\n```yml\n\nvariables:\n  TF_VAR_aws_ami_id: $AWS_AMI_ID\n  TF_VAR_aws_instance_type: $AWS_INSTANCE_TYPE\n  TF_VAR_aws_default_region: $AWS_DEFAULT_REGION\n\ninclude:\n  - template: Terraform.gitlab-ci.yml\n\ndefault:\n  cache:  # Use a shared cache or tagged runners to ensure terraform can run on apply and destroy\n    - key: cache-$CI_COMMIT_REF_SLUG\n      fallback_keys:\n        - cache-$CI_DEFAULT_BRANCH\n      paths:\n        - .\n\nstages:\n  - validate\n  - test\n  - build\n  - deploy\n  - cleanup\n  - 2nd_layer       # Use to deploy a 2nd environment on both the main branch and on the tags\n\nfmt:\n  rules:\n    - when: always\n\nvalidate:\n  rules:\n    - when: always\n\nkics-iac-sast:\n  rules:\n    - if: $SAST_DISABLED == 'true' || $SAST_DISABLED == '1'\n      when: never\n    - if: $SAST_EXCLUDED_ANALYZERS =~ /kics/\n      when: never\n    - when: on_success\n\niac-sast:\n  rules:\n    - if: $SAST_DISABLED == 'true' || $SAST_DISABLED == '1'\n      when: never\n    - if: $SAST_EXCLUDED_ANALYZERS =~ /kics/\n      when: never\n    - when: on_success\n\n###########################################################################################################\n\n## Integration env. and Staging. env\n\n##  * Auto-deploy to Integration on merge to main.\n\n##  * Auto-deploy to Staging on tag.\n\n##  * Integration can be manually destroyed if TF_DESTROY is set to true.\n\n##  * Destroy of next env. is not automated to prevent errors.\n\n###########################################################################################################\n\nbuild:  # terraform plan\n  environment:\n    name: $TF_STATE_NAME\n    action: prepare\n  rules:\n    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH\n    - if: $CI_COMMIT_TAG\n\ndeploy: # terraform apply --> automatically deploy on corresponding env (integration or staging) when merging to default branch or tagging. Second layer environments (qa and production) will be controlled manually\n  environment: \n    name: $TF_STATE_NAME\n    action: start\n    on_stop: destroy\n  rules:\n    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH\n    - if: $CI_COMMIT_TAG\n\ndestroy:\n  extends: .terraform:destroy\n  variables:\n    GIT_STRATEGY: none\n  dependencies:\n    - build\n  environment:\n    name: $TF_STATE_NAME\n    action: stop\n  rules:\n    - if: $CI_COMMIT_TAG  # Do not destroy production\n      when: never\n    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH && $TF_DESTROY == \"true\" # Manually destroy integration env.\n      when: manual\n###########################################################################################################\n\n\n###########################################################################################################\n\n## Dev env.\n\n##  * Temporary environment. Lives and dies with the Merge Request.\n\n##  * Auto-deploy on push to feature branch.\n\n##  * Auto-destroy on when Merge Request is closed.\n\n###########################################################################################################\n\nbuild_review:\n  extends: build\n  rules:\n    - if: $CI_COMMIT_TAG\n      when: never\n    - if: $CI_COMMIT_BRANCH != $CI_DEFAULT_BRANCH\n      when: on_success\n\ndeploy_review:\n  extends: deploy\n  dependencies:\n    - build_review\n  environment:\n    name: $environment\n    action: start\n    on_stop: destroy_review\n    # url: https://$CI_ENVIRONMENT_SLUG.example.com\n  rules:\n    - if: $CI_COMMIT_TAG\n      when: never\n    - if: $CI_COMMIT_BRANCH != $CI_DEFAULT_BRANCH\n      when: on_success\n\ndestroy_review:\n  extends: destroy\n  dependencies:\n    - build_review\n  environment:\n    name: $environment\n    action: stop\n  rules:\n    - if: $CI_COMMIT_TAG  # Do not destroy production\n      when: never\n    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH   # Do not destroy staging\n      when: never\n    - when: manual\n###########################################################################################################\n\n\n###########################################################################################################\n\n## Second layer\n\n##  * Deploys from main branch to qa env.\n\n##  * Deploys from tag to production.\n\n###########################################################################################################\n\n.2nd_layer:\n  stage: 2nd_layer\n  variables:\n    TF_ROOT: terraform\n  trigger:\n    include: .gitlab-ci/.second-layer.gitlab-ci.yml\n    # strategy: depend            # Do NOT wait for the downstream pipeline to finish to mark upstream pipeline as successful. Otherwise, all pipelines will fail when reaching the pipeline timeout before deployment to 2nd layer.\n    forward:\n      yaml_variables: true      # Forward variables defined in the trigger job\n      pipeline_variables: true  # Forward manual pipeline variables and scheduled pipeline variables\n\nqa:\n  extends: .2nd_layer\n  variables:\n    TF_STATE_NAME_2: qa\n    environment: $TF_STATE_NAME_2\n    TF_CLI_ARGS_plan_2: \"-var-file=../vars/$TF_STATE_NAME_2.tfvars\"\n  rules:\n    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH\n\nproduction:\n  extends: .2nd_layer\n  variables:\n    TF_STATE_NAME_2: production\n    environment: $TF_STATE_NAME_2\n    TF_CLI_ARGS_plan_2: \"-var-file=../vars/$TF_STATE_NAME_2.tfvars\"\n  rules:\n    - if: $CI_COMMIT_TAG\n###########################################################################################################\n\n```\n\n\nÀ cette étape, nous avons déjà effectué des déploiements vers trois environnements en toute sécurité. Je trouve personnellement que cette démarche est idéale. Cependant, si vous avez besoin d'autres environnements, ajoutez-les à votre pipeline CD.\n\n\nVous avez sûrement remarqué que nous incluons un pipeline enfant avec le mot-clé `trigger:include`. Il inclut le fichier `.gitlab-ci/.second-layer.gitlab-ci.yml`. Nous souhaitons exécuter un pipeline très similaire, son contenu ressemble donc évidemment beaucoup à celui présenté ci-dessus. Le principal avantage de ce [pipeline de niveau « petit-enfant »](#the-grand-child-pipeline) est qu'il existe par lui-même, ce qui facilite la définition des variables et des règles.\n\n\n### Le pipeline de niveau « petit-enfant »\n\n\nCe pipeline de deuxième couche est tout nouveau. Par conséquent, il doit imiter la définition de la première couche, à savoir :\n\n\n* [Il doit inclure le template Terraform](#run-terraform-commands-and-secure-the-code).\n\n* [Il doit exécuter des contrôles de sécurité](#run-controls-on-all-branches). La validation Terraform dupliquerait le premier niveau, mais les scanners de sécurité peuvent identifier des menaces qui n'existaient pas encore lors des précédents scans (par exemple, si vous déployez en production quelques jours après votre déploiement en préproduction).\n\n* [Il doit remplacer les jobs de compilation et de déploiement pour définir des règles spécifiques](#cd-to-review-environments). Notez que l'étape `destroy` n'est plus automatisée pour éviter des suppressions accidentelles.\n\n\nComme expliqué ci-dessus, les variables `TF_STATE_NAME` et `TF_CLI_ARGS_plan` sont copiées du pipeline principal au pipeline enfant. Nous avions besoin d'un nom de variable différent pour transférer ces valeurs du pipeline enfant au pipeline « petit-enfant ». C'est pourquoi, dans le pipeline enfant, les noms de ces variables incluent le suffixe `_2`. La valeur est ensuite copiée dans la variable correspondante appropriée lors de l'exécution de la section `before_script`.\n\n\nComme nous avons déjà décomposé chaque étape, nous pouvons passer directement à la vue d'ensemble du deuxième niveau (codé dans `.gitlab-ci/.second-layer.gitlab-ci.yml`).\n\n\n```yml\n\n# Use to deploy a second environment on both the default branch and the tags.\n\n\ninclude:\n  template: Terraform.gitlab-ci.yml\n\nstages:\n  - validate\n  - test\n  - build\n  - deploy\n\nfmt:\n  rules:\n    - when: never\n\nvalidate:\n  rules:\n    - when: never\n\nkics-iac-sast:\n  rules:\n    - if: $SAST_DISABLED == 'true' || $SAST_DISABLED == '1'\n      when: never\n    - if: $SAST_EXCLUDED_ANALYZERS =~ /kics/\n      when: never\n    - when: always\n\n###########################################################################################################\n\n## QA env. and Prod. env\n\n##  * Manually trigger build and auto-deploy in QA\n\n##  * Manually trigger both build and deploy in Production\n\n##  * Destroy of these env. is not automated to prevent errors.\n\n###########################################################################################################\n\nbuild:  # terraform plan\n  cache:  # Use a shared cache or tagged runners to ensure terraform can run on apply and destroy\n    - key: $TF_STATE_NAME_2\n      fallback_keys:\n        - cache-$CI_DEFAULT_BRANCH\n      paths:\n        - .\n  environment:\n    name: $TF_STATE_NAME_2\n    action: prepare\n  before_script:  # Hack to set new variable values on the second layer, while still using the same variable names. Otherwise, due to variable precedence order, setting new value in the trigger job, does not cascade these new values to the downstream pipeline\n    - TF_STATE_NAME=$TF_STATE_NAME_2\n    - TF_CLI_ARGS_plan=$TF_CLI_ARGS_plan_2\n  rules:\n    - when: manual\n\ndeploy: # terraform apply\n  cache:  # Use a shared cache or tagged runners to ensure terraform can run on apply and destroy\n    - key: $TF_STATE_NAME_2\n      fallback_keys:\n        - cache-$CI_DEFAULT_BRANCH\n      paths:\n        - .\n  environment: \n    name: $TF_STATE_NAME_2\n    action: start\n  before_script:  # Hack to set new variable values on the second layer, while still using the same variable names. Otherwise, due to variable precedence order, setting new value in the trigger job, does not cascade these new values to the downstream pipeline\n    - TF_STATE_NAME=$TF_STATE_NAME_2\n    - TF_CLI_ARGS_plan=$TF_CLI_ARGS_plan_2\n  rules:\n    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH\n    - if: $CI_COMMIT_TAG && $TF_AUTO_DEPLOY == \"true\"\n    - if: $CI_COMMIT_TAG\n      when: manual\n###########################################################################################################\n\n```\n\n\nVoilà qui est fait. **Tout est prêt.** N'hésitez pas à changer la façon dont vous contrôlez l'exécution de vos jobs, en tirant parti, par exemple, de la capacité de GitLab à [retarder un job](https://docs.gitlab.com/ee/ci/jobs/job_control.html#run-a-job-after-a-delay) avant de le déployer en production.\n\n\n## Essayez par vous-même\n\n\nCe tutoriel est maintenant terminé. Nous savons désormais comment contrôler les **déploiements vers cinq environnements différents** en utilisant uniquement les **branches de fonctionnalités**, la **branche principale** et les **tags**.\n\n\n* Nous réutilisons intensivement les templates open source GitLab pour assurer la productivité et la sécurité de nos pipelines.\n\n* Nous tirons parti des capacités du template GitLab pour remplacer uniquement les blocs nécessitant un contrôle personnalisé.\n\n* Nous avons divisé le pipeline en petits segments et contrôlons les pipelines enfants afin qu'ils correspondent exactement à nos besoins.\n\n\nÀ vous de jouer maintenant. Vous pouvez, par exemple, facilement mettre à jour le pipeline principal afin de déclencher des pipelines enfants, pour votre code source logiciel, avec le mot-clé [trigger:rules:changes](https://docs.gitlab.com/ee/ci/yaml/#ruleschanges). Vous pouvez utiliser un autre [template](https://gitlab.com/gitlab-org/gitlab/-/tree/master/lib/gitlab/ci/templates/) en fonction des changements qui se sont produits. Mais c'est une autre histoire.\n",[1126],"Olivier Dupré","2025-01-09","2024-09-26","Déployer en continu dans de multiples environnements avec les pipelines enfants",[9,774,772,685,684],{"slug":1132,"featured":6,"template":691},"using-child-pipelines-to-continuously-deploy-to-five-environments","content:fr-fr:blog:using-child-pipelines-to-continuously-deploy-to-five-environments.yml","Using Child Pipelines To Continuously Deploy To Five Environments","fr-fr/blog/using-child-pipelines-to-continuously-deploy-to-five-environments.yml","fr-fr/blog/using-child-pipelines-to-continuously-deploy-to-five-environments",{"_path":1138,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":1139,"content":1142,"config":1149,"_id":1151,"_type":14,"title":1152,"_source":16,"_file":1153,"_stem":1154,"_extension":19},"/fr-fr/blog/why-now-is-the-time-for-embedded-devsecops",{"noIndex":6,"title":1140,"description":1141},"Approche DevSecOps et développement de systèmes embarqués","Surmontez la lenteur des boucles de rétroaction, la lourdeur des processus de conformité et l'isolement des équipes en adoptant une plateforme DevSecOps.",{"heroImage":1030,"body":1143,"authors":1144,"updatedDate":1146,"date":1146,"title":1147,"tags":1148,"description":1141,"category":973},"Longtemps perçue comme réservée aux applications SaaS, l'approche [DevSecOps](https://about.gitlab.com/fr-fr/topics/devsecops/ \"Qu'est-ce que le DevSecOps ?\") s'impose désormais dans le développement de systèmes embarqués. Cette approche est portée par l'évolution du rôle des logiciels, qui sont devenus un facteur de différenciation majeur. Face aux nouvelles attentes du marché, les pratiques de développement modernes sont désormais incontournables. En réponse, les entreprises adoptent l'approche DevSecOps dans le développement de systèmes embarqués.\n\nCette approche consiste à appliquer des pratiques d'ingénierie collaborative, des chaînes d'outils intégrées et une automatisation des processus de compilation, de test et de sécurisation des logiciels au développement de systèmes embarqués. Elle introduit également les ajustements nécessaires pour tenir compte des spécificités matérielles.\n\n## Convergence des forces du marché\n\nLes équipes en charge des systèmes embarqués doivent désormais faire face à une convergence de trois grandes forces du marché qui rendent la modernisation de leurs pratiques inévitable.\n\n### 1. L'essor des produits définis par logiciel\n\nLes produits autrefois définis principalement par leur composant matériel se différencient désormais par leurs capacités logicielles. Cette évolution est particulièrement visible sur le marché des véhicules définis par logiciel (SDV), dont la valeur devrait passer de 213,5 milliards de dollars en 2024 à [1,24 billions de dollars](https://www.marketsandmarkets.com/Market-Reports/software-defined-vehicles-market-187205966.html) d'ici 2030, soit un taux de croissance annuel moyen de 34 %.\nLa part du contenu logiciel embarqué de ces véhicules explose. D'ici fin 2025, chaque véhicule contiendra en moyenne [650 millions de lignes de code](https://www.statista.com/statistics/1370978/automotive-software-average-lines-of-codes-per-vehicle-globally/). Les approches traditionnelles du développement de systèmes embarqués ne parviennent pas à gérer ce niveau de complexité logicielle. \n\n### 2. La virtualisation matérielle comme catalyseur technique\n\nLa virtualisation matérielle joue un rôle technique central dans l'approche DevSecOps pour le développement de systèmes embarqués. Les unités de commande électronique virtuelles (vECU), les processeurs ARM hébergés sur le cloud et les environnements de simulation sophistiqués sont de plus en plus répandus. Le matériel virtuel permet d'effectuer des tests qui nécessitaient autrefois du matériel physique.\n\nCes technologies de virtualisation posent les bases de l'[intégration continue (CI)](https://about.gitlab.com/fr-fr/topics/ci-cd/ \"Qu'est-ce que l'intégration continue ?\"). Toutefois, ce n'est que lorsqu'elles sont intégrées dans des workflows automatisés que leur utilisation fait sens. Combinés à des pratiques de développement collaboratif et à des [pipelines CI/CD](https://about.gitlab.com/fr-fr/topics/ci-cd/cicd-pipeline/ \"Qu'est-ce qu'un pipeline CI/CD ?\") automatisés, les tests virtuels aident les équipes à détecter les problèmes beaucoup plus tôt, lorsque l'application de correctifs est bien moins onéreuse. Sans approche DevSecOps pour le développement de systèmes embarqués et sans outils pour orchestrer ces ressources virtuelles, les entreprises ne peuvent pas tirer profit de la virtualisation.\n\n### 3. La pression concurrentielle et économique\n\nTrois dynamiques corrélées modifient le paysage concurrentiel du développement de systèmes embarqués :\n\n* Les nouvelles générations d'ingénieurs ont des attentes bien précises. Comme l'explique un responsable du développement de systèmes embarqués chez un client de GitLab : « Les jeunes diplômés développant des systèmes embarqués ne connaissent pas les outils hérités comme Perforce. Ils ont été formés sur [Git](https://about.gitlab.com/fr-fr/blog/what-is-git/ \"Qu'est-ce que Git ?\"). S'ils doivent utiliser des outils dépassés, ils démissionnent au bout de six mois. » Les entreprises qui persistent à utiliser des outils obsolètes risquent de perdre leur capacité à attirer les meilleurs ingénieurs.\n* À l'inverse, les entreprises à la pointe de la technologie qui attirent les ingénieurs les plus talentueux avec des pratiques modernes ont un avantage majeur sur leurs concurrents et obtiennent des résultats remarquables. Par exemple, en 2024, [SpaceX](https://spacenews.com/spacex-launch-surge-helps-set-new-global-launch-record-in-2024/) a réalisé le plus grand nombre de lancements orbitaux dans le monde. Les entreprises qui utilisent les dernières technologies excellent dans le développement logiciel et adoptent une culture de développement moderne. Elles obtiennent notamment des résultats que les entreprises qui continuent de faire appel à des outils traditionnels ont du mal à égaler. \n* Les longs cycles de rétroaction alourdissent considérablement les coûts du développement embarqué et rendent l'adoption d'une approche DevSecOps plus urgente que jamais. Lorsque les équipes de développement doivent patienter plusieurs semaines pour tester leur code sur des bancs d'essai matériels, la productivité chute intrinsèquement : les ingénieurs perdent le fil et doivent changer de contexte lorsque les résultats des tests leur parviennent. Ce phénomène s'aggrave encore lorsque des bogues sont découverts tardivement, et les correctifs deviennent plus coûteux à implémenter. Dans les systèmes embarqués, ces délais sont structurels.\n\nSeule une approche DevSecOps permet de répondre efficacement à ces problématiques.\n\n## Axes de transformation prioritaires\n\nPortées par ces dynamiques de marché, les entreprises avant-gardistes dans le domaine des systèmes embarqués adoptent une approche DevSecOps pour transformer en profondeur leurs pratiques. \n\n### Mise en place de tests continus\n\nLes goulots d'étranglement matériels représentent l'une des contraintes les plus importantes du développement traditionnel de systèmes embarqués. Ces retards créent des conditions économiques défavorables dues à l'accès tardif au matériel et à l'augmentation des coûts qui en résultent.\nPour résoudre ce problème, il est nécessaire d'adopter une approche multidimensionnelle : \n\n* Automatiser l'orchestration des bancs de test matériel partagés, souvent coûteux, entre les développeurs  \n* Intégrer les tests SIL (Software-in-the-Loop) et HIL (Hardware-in-the-Loop) dans des pipelines CI automatisés  \n* Standardiser les environnements de compilation avec un [contrôle de version](https://about.gitlab.com/fr-fr/topics/version-control/ \"Qu'est-ce que le contrôle de version ?\") rigoureux\n\nAvec le composant [CI/CD](https://about.gitlab.com/fr-fr/topics/ci-cd/ \"Qu'est-ce que l'approche CI/CD ?\") [On-Premises Device Cloud](https://gitlab.com/gitlab-accelerates-embedded/comp/device-cloud) de GitLab, les équipes de développement de systèmes embarqués peuvent automatiser l'orchestration des tests de micrologiciels sur du matériel virtuel et réel. Elles réduisent ainsi plus facilement les cycles de rétroaction de plusieurs semaines à quelques heures et détectent les bogues dès le début du cycle du développement logiciel.\n\n### Automatisation de la conformité et de la sécurité\n\nLes systèmes embarqués évoluent dans un environnement fortement réglementé, où les processus de conformité manuels ne sont plus viables.\nLes entreprises à la pointe automatisent la gouvernance de leurs processus de sécurité et de conformité en adoptant plusieurs pratiques clés : \n\n* Elles remplacent les workflows manuels par des [frameworks de conformité](https://about.gitlab.com/fr-fr/blog/introducing-custom-compliance-frameworks-in-gitlab/ \"Qu'est-ce qu'un framework de conformité ?\") automatisés.  \n* Elles intègrent des outils spécialisés de sécurité fonctionnelle, de cybersécurité et de qualité du code dans des pipelines CI automatisés.  \n* Elles automatisent les workflows d'approbation, en appliquant systématiquement des revues de code et en maintenant des pistes d'audit complètes.  \n* Elles configurent des frameworks de conformité alignés sur des normes sectorielles, telles que ISO 26262 ou DO-178C.\n\nCette approche permet une plus grande maturité en matière de conformité sans effectifs supplémentaires. Ce qui constituait autrefois un fardeau devient un avantage concurrentiel. Un grand constructeur de véhicules électriques exécute ainsi 120 000 jobs CI/CD par jour avec GitLab, dont une part importante inclut des contrôles de conformité. Grâce à cette automatisation, l'entreprise peut corriger les bogues et déployer des corrections sur ses véhicules dans l'heure qui suit leur découverte. Un tel niveau d'évolutivité et de réactivité serait extrêmement difficile à atteindre sans l'automatisation des workflows de conformité.\n\n### Innovation collaborative\n\nHistoriquement, pour des raisons commerciales et techniques légitimes, les équipes chargées du développement de systèmes embarqués travaillaient souvent seules à leur bureau. Les possibilités de collaboration étaient ainsi limitées. Pour remédier à cette situation, les entreprises innovantes fournissent une visibilité partagée du code grâce à un contrôle de version intégré et à des workflows CI/CD. Ces pratiques modernes attirent et fidélisent les ingénieurs tout en favorisant l'innovation.\nComme le souligne le directeur [DevOps](https://about.gitlab.com/fr-fr/topics/devops/ \"Qu'est-ce que l'approche DevOps ?\") d'un grand constructeur automobile à la pointe de la technologie (client de GitLab) : « Il est vraiment essentiel pour nous de travailler sur une seule plateforme où il est facile de vérifier le statut de nos workflows. Lorsque les développeurs soumettent une merge request, ils ont immédiatement une visibilité sur le statut du workflow concerné afin de pouvoir agir le plus rapidement possible. » Cette transparence accélère l'innovation. Elle permet aux constructeurs automobiles d'itérer rapidement sur les fonctionnalités logicielles qui différencient leurs véhicules sur un marché de plus en plus concurrentiel.\n\n## Une fenêtre d'opportunité\n\nLes leaders du développement de systèmes embarqués disposent aujourd'hui d'une fenêtre d'opportunité unique pour prendre une longueur d'avance en adoptant l'approche DevSecOps. Mais ils doivent agir rapidement, car à mesure que les logiciels deviennent le principal levier de différenciation des produits embarqués, l'écart entre les pionniers et les retardataires ne cessera de se creuser.\nLes entreprises qui réussiront cette transition réduiront leurs coûts, accéléreront leurs délais de mise sur le marché et développeront des logiciels plus innovants qui leur permettront de se différencier. Les leaders du secteur de demain seront ceux qui, dès aujourd'hui, font le choix de l'approche DevSecOps.\n\n> Bien que cet article mette en lumière les raisons pour lesquelles il est désormais essentiel pour les équipes de développement de systèmes embarqués d'adopter l'approche DevSecOps, vous vous demandez peut-être par où commencer. Pour passer à l'action, découvrez comment mettre ces concepts en pratique dans notre guide : [Accélérez le développement de systèmes embarqués avec GitLab](https://about.gitlab.com/blog/4-ways-to-accelerate-embedded-development-with-gitlab/).",[1145],"Matt DeLaney","2025-08-06","DevSecOps et systèmes embarqués : pourquoi adopter cette approche ?",[9],{"featured":6,"template":691,"slug":1150},"why-now-is-the-time-for-embedded-devsecops","content:fr-fr:blog:why-now-is-the-time-for-embedded-devsecops.yml","Why Now Is The Time For Embedded Devsecops","fr-fr/blog/why-now-is-the-time-for-embedded-devsecops.yml","fr-fr/blog/why-now-is-the-time-for-embedded-devsecops",{"_path":1156,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":1157,"content":1162,"config":1168,"_id":1170,"_type":14,"title":1171,"_source":16,"_file":1172,"_stem":1173,"_extension":19},"/fr-fr/blog/automating-agile-workflows-with-the-gitlab-triage-gem",{"title":1158,"description":1159,"ogTitle":1158,"ogDescription":1159,"noIndex":6,"ogImage":808,"ogUrl":1160,"ogSiteName":673,"ogType":674,"canonicalUrls":1160,"schema":1161},"La gemme gitlab-triage : votre alliée pour des workflows Agile automatisés","Découvrez comment automatiser les tâches répétitives pour permettre à vos équipes de se concentrer sur des missions à plus forte valeur ajoutée.","https://about.gitlab.com/blog/automating-agile-workflows-with-the-gitlab-triage-gem","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"La gemme gitlab-triage : votre alliée pour des workflows Agile automatisés\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"GitLab\"}],\n        \"datePublished\": \"2025-03-13\",\n      }\n                  ",{"title":1158,"description":1159,"authors":1163,"heroImage":808,"date":1164,"body":1165,"category":686,"tags":1166,"updatedDate":1167},[813],"2025-03-13","*Bienvenue dans notre série d'articles de blog baptisée « Premiers pas avec GitLab », dans laquelle nous aidons les nouveaux utilisateurs à se familiariser avec la plateforme [DevSecOps](https://about.gitlab.com/fr-fr/topics/devsecops/ \"Qu'est-ce que DevSecOps ?\") de GitLab.*\n\nDécouvrez dans cet article une alliée précieuse pour automatiser vos workflows Agile : la gemme [`gitlab-triage`](https://gitlab.com/gitlab-org/ruby/gems/gitlab-triage). Finies les tâches manuelles fastidieuses, place à une productivité maximale et à des processus simplifiés !\n\n## Pourquoi automatiser votre workflow ?\n\nDans le domaine du développement logiciel, la productivité est la clé du succès. En automatisant des tâches répétitives telles que le classement des tickets et des merge requests par ordre de priorité, votre équipe peut se concentrer sur sa mission première : concevoir des logiciels robustes et innovants.\n\nAvec la gemme `gitlab-triage`, vous pouvez :\n\n- **Assurer la cohérence :** appliquez des labels et attribuez des tickets automatiquement en fonction de règles prédéfinies.  \n- **Améliorer les temps de réponse :** obtenez des retours immédiats et traitez rapidement les nouveaux tickets et merge requests.  \n- **Éliminer les tâches manuelles :** triez, classez, priorisez, mettez à jour les tickets sans intervention humaine.  \n- **Stimuler la productivité :** offrez à votre équipe plus de temps pour coder, innover et se concentrer sur des tâches à forte valeur ajoutée.\n\n## Qu'est-ce que la gemme `gitlab-triage` ?\n\nLa gemme `gitlab-triage` est une bibliothèque Ruby qui vous permet de créer des bots capables d'interagir intelligemment avec vos projets GitLab et qui peuvent effectuer automatiquement un large éventail d'actions, notamment :\n\n- **Ajout de labels :** classez automatiquement vos tickets et vos merge requests.  \n- **Commentaires automatisés :** fournissez des retours, posez des questions ou partagez des informations clés.  \n- **Attribution intelligente :** attribuez les tickets et les merge requests aux membres appropriés de votre équipe, selon des critères définis.  \n- **Fermeture automatique :** clôturez les tickets et merge requests obsolètes ou résolus.  \n- **Création conditionnelle :** générez de nouveaux tickets en fonction d'événements ou de conditions spécifiques.  \n- **Et bien plus encore !**\n\nPour en savoir plus, consultez le [dépôt de la gemme `gitlab-triage`](https://gitlab.com/gitlab-org/ruby/gems/gitlab-triage). \n\n## Configuration de votre bot de classement\n\nPrêt à mettre en place votre premier bot de tri automatisé ? Suivez le guide !\n\n1. Installez la gemme. Remarque : assurez-vous que Ruby est installé sur votre machine, puis exécutez la commande `gem` suivante :\n\n```bash\ngem install gitlab-triage\n```\n\n2. Récupérez votre token d'API GitLab.\n\n* Accédez aux [paramètres de votre profil](https://gitlab.com/-/profile/preferences) GitLab.  \n* Cliquez sur **Jetons d'accès**.  \n* Créez un nouveau jeton d’accès avec la portée `api`.  \n* **Conservez-le en lieu sûr et définissez sa date d'expiration selon la durée de ce tutoriel.**\n\n3. Définissez vos stratégies de classement.\n\nCréez un fichier nommé `.triage-policies.yml` dans le répertoire racine de votre projet. Il contiendra les règles qui régissent le comportement de votre bot. Voici un exemple simple :\n\n```yaml\n\n---\n- name: \"Apply 'WIP' label\"\n  condition:\n    draft: true\n  action:\n    labels:\n      - status::wip\n\n- name: \"Request more information on old issue\"\n  condition:\n   date:\n    attribute: updated_at\n    condition: older_than\n    interval_type: months\n    interval: 12\n  action:\n    comment: |\n      {{author}} This issue has been open for more than 12 months, is this still an issue?\n```\n\nCette configuration définit deux stratégies :\n\n* La première applique automatiquement le label `status::wip` à tout ticket enregistré en tant que brouillon.  \n* La deuxième ajoute un commentaire à tout ticket qui n'a pas été mis à jour depuis 12 mois.\n\n4. Exécutez votre bot.\n\nVous pouvez exécuter votre bot manuellement à l'aide de la commande suivante :\n\n```bash\ngitlab-triage -t \u003Cyour_api_token> -p \u003Cyour_project_id>\n```\n\nRemplacez `\u003Cyour_api_token>` par votre token d'API GitLab et `\u003Cyour_project_id>` par l'[ID de votre projet GitLab](https://docs.gitlab.com/user/project/working_with_projects/#access-a-project-by-using-the-project-id). Pour effectuer un test sans appliquer les actions (mode simulation), ajoutez l’option `-n` ou `--dry-run`.\n\n## Automatisation avec GitLab CI/CD\n\nPour aller plus loin, vous pouvez intégrer l’exécution de votre bot directement dans vos pipelines GitLab [CI/CD](https://about.gitlab.com/fr-fr/topics/ci-cd/). Voici un exemple de configuration `.gitlab-ci.yml` :\n\n```yaml\n\ntriage:\n  script:\n    - gem install gitlab-triage\n    - gitlab-triage -t $GITLAB_TOKEN -p $CI_PROJECT_ID\n  only:\n    - schedules\n```\n\nCette configuration définit un job nommé « triage » qui installe la gemme `gitlab-triage` et exécute le bot à l'aide de deux [variables CI/CD](https://about.gitlab.com/fr-fr/blog/demystifying-ci-cd-variables/) prédéfinis : `$GITLAB_TOKEN` et `$CI_PROJECT_ID`. La clause `only: schedules` garantit que ce job s'exécute uniquement selon un calendrier défini.\n\nPour [automatiser l’exécution de votre bot à intervalles réguliers](https://docs.gitlab.com/ee/ci/pipelines/schedules.html), accédez aux paramètres **CI/CD** de votre projet GitLab, puis à l'onglet **Calendriers**. Créez un calendrier de planification et définissez la fréquence d'exécution de votre bot (par exemple, quotidiennement, toutes les heures).\n\n## Stratégies de classement avancées\n\nLa gemme `gitlab-triage` offre un large éventail de fonctionnalités avancées pour créer des stratégies de classement plus complexes :\n\n- **Expressions régulières :** pour des correspondances plus puissantes dans vos stratégies.  \n- **Stratégies de synthèse :** pour regrouper des tickets associés en un ticket unique récapitulatif. \n- **Actions personnalisées :** pour effectuer des opérations plus complexes à l'aide de l'API GitLab, en utilisant des [blocs de code Ruby](https://gitlab.com/gitlab-org/ruby/gems/gitlab-triage#can-i-customize). \n\nVoici deux exemples concrets utilisés par l'équipe Developer Advocacy de GitLab. Vous pouvez consulter l'intégralité des stratégies dans [ce fichier](https://gitlab.com/gitlab-da/projects/devrel-bot/-/blob/master/.triage-policies.yml?ref_type=heads).\n\n```yaml\n- name: Issues where DA team member is an assignee outside DA-Meta project i.e. DevRel-Influenced\n  conditions:\n    assignee_member:\n      source: group\n      condition: member_of\n      source_id: 1008\n    state: opened\n    ruby: get_project_id != 18 \n    forbidden_labels:\n      - developer-advocacy\n  actions:   \n    labels:\n      - developer-advocacy\n      - DevRel-Influenced\n      - DA-Bot::Skip\n```\n\nCet exemple concerne les tickets d'un groupe, à l'exclusion de ceux appartenant au projet portant l'ID 18. Il montre des tickets assignés à des membres du groupe portant l'ID 1008 et qui n'incluent pas le label `developer-advocacy`. Cette stratégie permet à l'équipe Developer Advocacy de GitLab d'identifier les tickets attribués à ses membres, sur lesquels ils ont contribué mais pour un autre projet, et de suivre facilement ces contributions en y ajoutant automatiquement le label de l'équipe pour une vision claire de l'impact transversal de ses membres.\n\n```\n- name: Missing Due Dates\n  conditions:\n    ruby: missing_due_date\n    state: opened\n    labels:\n      - developer-advocacy\n    forbidden_labels:\n      - DA-Due::N/A\n      - DA-Bot::Skip\n      - DA-Status::FYI\n      - DA-Status::OnHold\n      - CFP\n      - DA-Bot::Triage\n  actions:\n    labels:\n      - DA-Bot-Auto-Due-Date\n    comment: |\n      /due #{get_current_quarter_last_date}\n```\n\nCe deuxième exemple permet de trier tous les tickets portant le label `developer-advocacy`, qui n'incluent aucun label figurant dans la liste des labels interdits, et dont la date d'échéance est dépassée. Cette stratégie de classement met automatiquement à jour la date d'échéance en ajoutant un commentaire au ticket avec une commande slash et d'une nouvelle date générée dynamiquement à l'aide de Ruby.\n\nLes scripts Ruby utilisés dans ces stratégies sont définis dans un fichier séparé, comme illustré ci-dessous. Cette approche offre une grande souplesse dans la création de filtres et d’actions personnalisés. Vous pouvez notamment voir des fonctions dédiées aux différentes commandes Ruby que nous avons utilisées dans nos stratégies de classement. \n\n```\nrequire 'json'\nrequire 'date'\nrequire \"faraday\"\nrequire 'dotenv/load'\n\nmodule DATriagePlugin\n  def last_comment_at\n    conn = Faraday.new(\n      url: notes_url+\"?sort=desc&order_by=created_at&pagination=keyset&per_page=1\",\n      headers: {'PRIVATE-TOKEN' => ENV.fetch(\"PRIV_KEY\"), 'Content-Type' => 'application/json' }\n    )\n\n    response = conn.get()\n    if response.status == 200\n      jsonData = JSON.parse(response.body)\n      if jsonData.length > 0\n        Date.parse(jsonData[0]['created_at'])\n      else\n        Date.parse(resource[:created_at])\n      end\n    else\n      Date.parse(resource[:created_at])\n    end\n  end\n\n  def notes_url\n    resource[:_links][:notes]\n  end\n\n  def get_project_id\n    resource[:project_id]\n  end\n\n  def get_current_quarter_last_date()\n    yr = Time.now.year\n    case Time.now.month\n    when 2..4\n      lm = 4\n    when 5..7\n      lm = 7\n    when 8..10\n      lm = 10\n    when 11..12\n      lm = 1\n      yr = yr + 1\n    else\n      lm = 1    \n    end\n\n    return Date.new(yr, lm, -1) \n  end\n\n  def one_week_to_due_date\n    if(resource[:due_date] == nil)\n      false\n    else\n      days_to_due = (Date.parse(resource[:due_date]) - Date.today).to_i\n      if(days_to_due > 0 && days_to_due \u003C 7)\n        true\n      else\n        false\n      end\n    end\n  end\n\n  def due_date_past\n    if(resource[:due_date] == nil)\n      false\n    else\n      Date.today > Date.parse(resource[:due_date])\n    end\n  end\n\n  def missing_due_date\n    if(resource[:due_date] == nil)\n      true\n    else\n      false\n    end\n  end\n\nend\n\nGitlab::Triage::Resource::Context.include DATriagePlugin\n\n```\nLe bot de classement par ordre de priorité est exécuté à l'aide de la commande suivante :\n\n``` \n`gitlab-triage -r ./triage_bot/issue_triage_plugin.rb --debug --token $PRIV_KEY --source-id gitlab-com --source groups`  \n```\n\n- `-r` : transmet un fichier de prérequis pour le classement par ordre de priorité en cours. Dans le cas présent, il s’agit d’un fichier contenant des fonctions Ruby personnalisées.  \n- `--debug` : affiche les informations de débogage en sortie.  \n- `--token` : permet de transmettre un token d'API GitLab valide.  \n- `--source` : spécifie si les tickets à analyser se trouvent dans un groupe ou un projet.  \n- `--source-id` : reçoit l'ID du type de source sélectionné. Dans le cas présent, celui du groupe ciblé.\n\nDans le projet GitLab [triage-ops](https://gitlab.com/gitlab-org/quality/triage-ops), autre exemple concret plus complexe, vous apprendrez à créer votre propre bot de classement par ordre de priorité à grande échelle.\n\n## Bonnes pratiques\n\n* **Commencez par les bases :** utilisez des stratégies simples et augmentez progressivement leur complexité. \n* **Testez minutieusement :** testez vos stratégies dans un environnement de préproduction avant de les déployer en production.  \n* **Surveillez régulièrement :** surveillez l'activité de votre bot pour vous assurer qu'il se comporte comme prévu. \n* **Nommez clairement vos stratégies :** attribuez à vos stratégies des noms clairs et descriptifs pour faciliter leur maintenance. \n* **Définissez attentivement la portée de vos filtres :** évitez de filtrer les tickets dans des groupes incluant des milliers de tickets, car cela pourrait ralentir le processus de classement par ordre de priorité, voire le faire échouer en raison des limites de débit de l'API GitLab.  \n* **Priorisez l'utilisation de labels pour le classement :** pour éviter de spammer les autres utilisateurs avec des commentaires et des tickets, les labels sont un moyen efficace d'effectuer un classement par ordre de priorité, clair, propre, non intrusif.\n\n## Prenez le contrôle de votre workflow\n\nAvec la gemme `gitlab-triage`, vous pouvez automatiser votre workflow GitLab et améliorer la productivité de vos équipes. Commencez par créer des bots de classement simples, puis explorez progressivement les fonctionnalités plus avancées. Vous serez surpris du temps et de l’énergie que vous pouvez économiser !\n\nDécouvrez les autres articles de cette série « Premiers pas avec GitLab » :\n\n- [Comment gérer les utilisateurs](https://about.gitlab.com/fr-fr/blog/getting-started-with-gitlab-how-to-manage-users/)\n\n- [Comment importer vos projets dans GitLab](https://about.gitlab.com/fr-fr/blog/getting-started-with-gitlab-how-to-import-your-projects-to-gitlab/)  \n- [Comment maîtriser la gestion de projet](https://about.gitlab.com/fr-fr/blog/getting-started-with-gitlab-mastering-project-management/)\n",[685,684,686,1017,9],"2025-04-15",{"slug":1169,"featured":6,"template":691},"automating-agile-workflows-with-the-gitlab-triage-gem","content:fr-fr:blog:automating-agile-workflows-with-the-gitlab-triage-gem.yml","Automating Agile Workflows With The Gitlab Triage Gem","fr-fr/blog/automating-agile-workflows-with-the-gitlab-triage-gem.yml","fr-fr/blog/automating-agile-workflows-with-the-gitlab-triage-gem",3,[666,696,717,736,758,782,803,824,843],1759347871399]