[{"data":1,"prerenderedAt":1203},["ShallowReactive",2],{"/fr-fr/blog/categories/product/":3,"navigation-fr-fr":22,"banner-fr-fr":442,"footer-fr-fr":455,"product-category-page-fr-fr":666},{"_path":4,"_dir":5,"_draft":6,"_partial":6,"_locale":7,"seo":8,"content":11,"config":12,"_id":15,"_type":16,"title":17,"_source":18,"_file":19,"_stem":20,"_extension":21},"/fr-fr/blog/categories/product","categories",false,"",{"title":9,"description":10},"Produit","Browse articles related to Produit on the GitLab Blog",{"name":9},{"template":13,"slug":14,"hide":6},"BlogCategory","product","content:fr-fr:blog:categories:product.yml","yaml","Product","content","fr-fr/blog/categories/product.yml","fr-fr/blog/categories/product","yml",{"_path":23,"_dir":24,"_draft":6,"_partial":6,"_locale":7,"data":25,"_id":438,"_type":16,"title":439,"_source":18,"_file":440,"_stem":441,"_extension":21},"/shared/fr-fr/main-navigation","fr-fr",{"logo":26,"freeTrial":31,"sales":36,"login":41,"items":46,"search":379,"minimal":415,"duo":429},{"config":27},{"href":28,"dataGaName":29,"dataGaLocation":30},"/fr-fr/","gitlab logo","header",{"text":32,"config":33},"Commencer un essai gratuit",{"href":34,"dataGaName":35,"dataGaLocation":30},"https://gitlab.com/-/trial_registrations/new?glm_source=about.gitlab.com&glm_content=default-saas-trial/","free trial",{"text":37,"config":38},"Contacter l'équipe commerciale",{"href":39,"dataGaName":40,"dataGaLocation":30},"/fr-fr/sales/","sales",{"text":42,"config":43},"Connexion",{"href":44,"dataGaName":45,"dataGaLocation":30},"https://gitlab.com/users/sign_in/","sign in",[47,91,189,194,300,360],{"text":48,"config":49,"cards":51,"footer":74},"Plateforme",{"dataNavLevelOne":50},"platform",[52,58,66],{"title":48,"description":53,"link":54},"La plateforme DevSecOps alimentée par l'IA la plus complète",{"text":55,"config":56},"Découvrir notre plateforme",{"href":57,"dataGaName":50,"dataGaLocation":30},"/fr-fr/platform/",{"title":59,"description":60,"link":61},"GitLab Duo (IA)","Créez des logiciels plus rapidement en tirant parti de l'IA à chaque étape du développement",{"text":62,"config":63},"Découvrez GitLab Duo",{"href":64,"dataGaName":65,"dataGaLocation":30},"/fr-fr/gitlab-duo/","gitlab duo ai",{"title":67,"description":68,"link":69},"Choisir GitLab","10 raisons pour lesquelles les entreprises choisissent GitLab",{"text":70,"config":71},"En savoir plus",{"href":72,"dataGaName":73,"dataGaLocation":30},"/fr-fr/why-gitlab/","why gitlab",{"title":75,"items":76},"Démarrer avec",[77,82,87],{"text":78,"config":79},"Ingénierie de plateforme",{"href":80,"dataGaName":81,"dataGaLocation":30},"/fr-fr/solutions/platform-engineering/","platform engineering",{"text":83,"config":84},"Expérience développeur",{"href":85,"dataGaName":86,"dataGaLocation":30},"/fr-fr/developer-experience/","Developer experience",{"text":88,"config":89},"MLOps",{"href":90,"dataGaName":88,"dataGaLocation":30},"/fr-fr/topics/devops/the-role-of-ai-in-devops/",{"text":9,"left":92,"config":93,"link":95,"lists":99,"footer":171},true,{"dataNavLevelOne":94},"solutions",{"text":96,"config":97},"Voir toutes les solutions",{"href":98,"dataGaName":94,"dataGaLocation":30},"/fr-fr/solutions/",[100,126,149],{"title":101,"description":102,"link":103,"items":108},"Automatisation","CI/CD et automatisation pour accélérer le déploiement",{"config":104},{"icon":105,"href":106,"dataGaName":107,"dataGaLocation":30},"AutomatedCodeAlt","/solutions/delivery-automation/","automated software delivery",[109,113,117,122],{"text":110,"config":111},"CI/CD",{"href":112,"dataGaLocation":30,"dataGaName":110},"/fr-fr/solutions/continuous-integration/",{"text":114,"config":115},"Développement assisté par l'IA",{"href":64,"dataGaLocation":30,"dataGaName":116},"AI assisted development",{"text":118,"config":119},"Gestion du code source",{"href":120,"dataGaLocation":30,"dataGaName":121},"/fr-fr/solutions/source-code-management/","Source Code Management",{"text":123,"config":124},"Livraison de logiciels automatisée",{"href":106,"dataGaLocation":30,"dataGaName":125},"Automated software delivery",{"title":127,"description":128,"link":129,"items":134},"Securité","Livrez du code plus rapidement sans compromettre la sécurité",{"config":130},{"href":131,"dataGaName":132,"dataGaLocation":30,"icon":133},"/fr-fr/solutions/security-compliance/","security and compliance","ShieldCheckLight",[135,140,145],{"text":136,"config":137},"Application Security Testing",{"href":138,"dataGaName":139,"dataGaLocation":30},"/solutions/application-security-testing/","Application security testing",{"text":141,"config":142},"Sécurité de la chaîne d'approvisionnement logicielle",{"href":143,"dataGaLocation":30,"dataGaName":144},"/fr-fr/solutions/supply-chain/","Software supply chain security",{"text":146,"config":147},"Software Compliance",{"href":148,"dataGaName":146,"dataGaLocation":30},"/solutions/software-compliance/",{"title":150,"link":151,"items":156},"Mesures",{"config":152},{"icon":153,"href":154,"dataGaName":155,"dataGaLocation":30},"DigitalTransformation","/fr-fr/solutions/visibility-measurement/","visibility and measurement",[157,161,166],{"text":158,"config":159},"Visibilité et mesures",{"href":154,"dataGaLocation":30,"dataGaName":160},"Visibility and Measurement",{"text":162,"config":163},"Gestion de la chaîne de valeur",{"href":164,"dataGaLocation":30,"dataGaName":165},"/fr-fr/solutions/value-stream-management/","Value Stream Management",{"text":167,"config":168},"Données d'analyse et informations clés",{"href":169,"dataGaLocation":30,"dataGaName":170},"/fr-fr/solutions/analytics-and-insights/","Analytics and insights",{"title":172,"items":173},"GitLab pour",[174,179,184],{"text":175,"config":176},"Entreprises",{"href":177,"dataGaLocation":30,"dataGaName":178},"/fr-fr/enterprise/","enterprise",{"text":180,"config":181},"PME",{"href":182,"dataGaLocation":30,"dataGaName":183},"/fr-fr/small-business/","small business",{"text":185,"config":186},"Secteur public",{"href":187,"dataGaLocation":30,"dataGaName":188},"/fr-fr/solutions/public-sector/","public sector",{"text":190,"config":191},"Tarifs",{"href":192,"dataGaName":193,"dataGaLocation":30,"dataNavLevelOne":193},"/fr-fr/pricing/","pricing",{"text":195,"config":196,"link":198,"lists":202,"feature":287},"Ressources",{"dataNavLevelOne":197},"resources",{"text":199,"config":200},"Afficher toutes les ressources",{"href":201,"dataGaName":197,"dataGaLocation":30},"/fr-fr/resources/",[203,236,259],{"title":204,"items":205},"Premiers pas",[206,211,216,221,226,231],{"text":207,"config":208},"Installation",{"href":209,"dataGaName":210,"dataGaLocation":30},"/fr-fr/install/","install",{"text":212,"config":213},"Guides de démarrage rapide",{"href":214,"dataGaName":215,"dataGaLocation":30},"/fr-fr/get-started/","quick setup checklists",{"text":217,"config":218},"Apprentissage",{"href":219,"dataGaLocation":30,"dataGaName":220},"https://university.gitlab.com/","learn",{"text":222,"config":223},"Documentation sur le produit",{"href":224,"dataGaName":225,"dataGaLocation":30},"https://docs.gitlab.com/","product documentation",{"text":227,"config":228},"Vidéos sur les bonnes pratiques",{"href":229,"dataGaName":230,"dataGaLocation":30},"/fr-fr/getting-started-videos/","best practice videos",{"text":232,"config":233},"Intégrations",{"href":234,"dataGaName":235,"dataGaLocation":30},"/fr-fr/integrations/","integrations",{"title":237,"items":238},"Découvrir",[239,244,249,254],{"text":240,"config":241},"Histoires de succès client",{"href":242,"dataGaName":243,"dataGaLocation":30},"/fr-fr/customers/","customer success stories",{"text":245,"config":246},"Blog",{"href":247,"dataGaName":248,"dataGaLocation":30},"/fr-fr/blog/","blog",{"text":250,"config":251},"Travail à distance",{"href":252,"dataGaName":253,"dataGaLocation":30},"https://handbook.gitlab.com/handbook/company/culture/all-remote/","remote",{"text":255,"config":256},"TeamOps",{"href":257,"dataGaName":258,"dataGaLocation":30},"/fr-fr/teamops/","teamops",{"title":260,"items":261},"Connecter",[262,267,272,277,282],{"text":263,"config":264},"Services GitLab",{"href":265,"dataGaName":266,"dataGaLocation":30},"/fr-fr/services/","services",{"text":268,"config":269},"Communauté",{"href":270,"dataGaName":271,"dataGaLocation":30},"/community/","community",{"text":273,"config":274},"Forum",{"href":275,"dataGaName":276,"dataGaLocation":30},"https://forum.gitlab.com/","forum",{"text":278,"config":279},"Événements",{"href":280,"dataGaName":281,"dataGaLocation":30},"/events/","events",{"text":283,"config":284},"Partenaires",{"href":285,"dataGaName":286,"dataGaLocation":30},"/partners/","partners",{"backgroundColor":288,"textColor":289,"text":290,"image":291,"link":295},"#2f2a6b","#fff","L'avenir du développement logiciel. Tendances et perspectives.",{"altText":292,"config":293},"carte promo The Source",{"src":294},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1758208064/dzl0dbift9xdizyelkk4.svg",{"text":296,"config":297},"Lire les articles les plus récents",{"href":298,"dataGaName":299,"dataGaLocation":30},"/fr-fr/the-source/","the source",{"text":301,"config":302,"lists":304},"Société",{"dataNavLevelOne":303},"company",[305],{"items":306},[307,312,318,320,325,330,335,340,345,350,355],{"text":308,"config":309},"À propos",{"href":310,"dataGaName":311,"dataGaLocation":30},"/fr-fr/company/","about",{"text":313,"config":314,"footerGa":317},"Emplois",{"href":315,"dataGaName":316,"dataGaLocation":30},"/jobs/","jobs",{"dataGaName":316},{"text":278,"config":319},{"href":280,"dataGaName":281,"dataGaLocation":30},{"text":321,"config":322},"Leadership",{"href":323,"dataGaName":324,"dataGaLocation":30},"/company/team/e-group/","leadership",{"text":326,"config":327},"Équipe",{"href":328,"dataGaName":329,"dataGaLocation":30},"/company/team/","team",{"text":331,"config":332},"Manuel",{"href":333,"dataGaName":334,"dataGaLocation":30},"https://handbook.gitlab.com/","handbook",{"text":336,"config":337},"Relations avec les investisseurs",{"href":338,"dataGaName":339,"dataGaLocation":30},"https://ir.gitlab.com/","investor relations",{"text":341,"config":342},"Centre de confiance",{"href":343,"dataGaName":344,"dataGaLocation":30},"/fr-fr/security/","trust center",{"text":346,"config":347},"Centre pour la transparence de l'IA",{"href":348,"dataGaName":349,"dataGaLocation":30},"/fr-fr/ai-transparency-center/","ai transparency center",{"text":351,"config":352},"Newsletter",{"href":353,"dataGaName":354,"dataGaLocation":30},"/company/contact/","newsletter",{"text":356,"config":357},"Presse",{"href":358,"dataGaName":359,"dataGaLocation":30},"/press/","press",{"text":361,"config":362,"lists":363},"Nous contacter",{"dataNavLevelOne":303},[364],{"items":365},[366,369,374],{"text":37,"config":367},{"href":39,"dataGaName":368,"dataGaLocation":30},"talk to sales",{"text":370,"config":371},"Aide",{"href":372,"dataGaName":373,"dataGaLocation":30},"/support/","get help",{"text":375,"config":376},"Portail clients GitLab",{"href":377,"dataGaName":378,"dataGaLocation":30},"https://customers.gitlab.com/customers/sign_in/","customer portal",{"close":380,"login":381,"suggestions":388},"Fermer",{"text":382,"link":383},"Pour rechercher des dépôts et des projets, connectez-vous à",{"text":384,"config":385},"gitlab.com",{"href":44,"dataGaName":386,"dataGaLocation":387},"search login","search",{"text":389,"default":390},"Suggestions",[391,394,399,401,406,411],{"text":59,"config":392},{"href":64,"dataGaName":393,"dataGaLocation":387},"GitLab Duo (AI)",{"text":395,"config":396},"Suggestions de code (IA)",{"href":397,"dataGaName":398,"dataGaLocation":387},"/fr-fr/solutions/code-suggestions/","Code Suggestions (AI)",{"text":110,"config":400},{"href":112,"dataGaName":110,"dataGaLocation":387},{"text":402,"config":403},"GitLab sur AWS",{"href":404,"dataGaName":405,"dataGaLocation":387},"/fr-fr/partners/technology-partners/aws/","GitLab on AWS",{"text":407,"config":408},"GitLab sur Google Cloud ",{"href":409,"dataGaName":410,"dataGaLocation":387},"/fr-fr/partners/technology-partners/google-cloud-platform/","GitLab on Google Cloud",{"text":412,"config":413},"Pourquoi utiliser GitLab ?",{"href":72,"dataGaName":414,"dataGaLocation":387},"Why GitLab?",{"freeTrial":416,"mobileIcon":421,"desktopIcon":426},{"text":417,"config":418},"Commencer votre essai gratuit",{"href":419,"dataGaName":35,"dataGaLocation":420},"https://gitlab.com/-/trials/new/","nav",{"altText":422,"config":423},"Icône GitLab",{"src":424,"dataGaName":425,"dataGaLocation":420},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1758203874/jypbw1jx72aexsoohd7x.svg","gitlab icon",{"altText":422,"config":427},{"src":428,"dataGaName":425,"dataGaLocation":420},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1758203875/gs4c8p8opsgvflgkswz9.svg",{"freeTrial":430,"mobileIcon":434,"desktopIcon":436},{"text":431,"config":432},"En savoir plus sur GitLab Duo",{"href":64,"dataGaName":433,"dataGaLocation":420},"gitlab duo",{"altText":422,"config":435},{"src":424,"dataGaName":425,"dataGaLocation":420},{"altText":422,"config":437},{"src":428,"dataGaName":425,"dataGaLocation":420},"content:shared:fr-fr:main-navigation.yml","Main Navigation","shared/fr-fr/main-navigation.yml","shared/fr-fr/main-navigation",{"_path":443,"_dir":24,"_draft":6,"_partial":6,"_locale":7,"title":444,"titleMobile":444,"button":445,"config":450,"_id":452,"_type":16,"_source":18,"_file":453,"_stem":454,"_extension":21},"/shared/fr-fr/banner","La plateforme GitLab Duo Agent est maintenant disponible en version bêta publique !",{"text":446,"config":447},"Essayer la version bêta",{"href":448,"dataGaName":449,"dataGaLocation":30},"/fr-fr/gitlab-duo/agent-platform/","duo banner",{"layout":451},"release","content:shared:fr-fr:banner.yml","shared/fr-fr/banner.yml","shared/fr-fr/banner",{"_path":456,"_dir":24,"_draft":6,"_partial":6,"_locale":7,"data":457,"_id":662,"_type":16,"title":663,"_source":18,"_file":664,"_stem":665,"_extension":21},"/shared/fr-fr/main-footer",{"text":458,"source":459,"edit":465,"contribute":470,"config":475,"items":480,"minimal":653},"Git est une marque déposée de Software Freedom Conservancy et notre utilisation de « GitLab » est sous licence",{"text":460,"config":461},"Afficher le code source de la page",{"href":462,"dataGaName":463,"dataGaLocation":464},"https://gitlab.com/gitlab-com/marketing/digital-experience/about-gitlab-com/","page source","footer",{"text":466,"config":467},"Modifier cette page",{"href":468,"dataGaName":469,"dataGaLocation":464},"https://gitlab.com/gitlab-com/marketing/digital-experience/about-gitlab-com/-/blob/main/content/","web ide",{"text":471,"config":472},"Veuillez contribuer",{"href":473,"dataGaName":474,"dataGaLocation":464},"https://gitlab.com/gitlab-com/marketing/digital-experience/about-gitlab-com/-/blob/main/CONTRIBUTING.md/","please contribute",{"twitter":476,"facebook":477,"youtube":478,"linkedin":479},"https://twitter.com/gitlab","https://www.facebook.com/gitlab","https://www.youtube.com/channel/UCnMGQ8QHMAnVIsI3xJrihhg","https://www.linkedin.com/company/gitlab-com",[481,504,558,590,624],{"title":48,"links":482,"subMenu":487},[483],{"text":484,"config":485},"Plateforme DevSecOps",{"href":57,"dataGaName":486,"dataGaLocation":464},"devsecops platform",[488],{"title":190,"links":489},[490,494,499],{"text":491,"config":492},"Voir les forfaits",{"href":192,"dataGaName":493,"dataGaLocation":464},"view plans",{"text":495,"config":496},"Pourquoi choisir GitLab Premium ?",{"href":497,"dataGaName":498,"dataGaLocation":464},"/fr-fr/pricing/premium/","why premium",{"text":500,"config":501},"Pourquoi choisir GitLab Ultimate ?",{"href":502,"dataGaName":503,"dataGaLocation":464},"/fr-fr/pricing/ultimate/","why ultimate",{"title":505,"links":506},"Solutions",[507,512,515,517,522,527,531,534,537,542,544,546,548,553],{"text":508,"config":509},"Transformation digitale",{"href":510,"dataGaName":511,"dataGaLocation":464},"/fr-fr/topics/digital-transformation/","digital transformation",{"text":513,"config":514},"Sécurité et conformité",{"href":138,"dataGaName":139,"dataGaLocation":464},{"text":123,"config":516},{"href":106,"dataGaName":107,"dataGaLocation":464},{"text":518,"config":519},"Développement agile",{"href":520,"dataGaName":521,"dataGaLocation":464},"/fr-fr/solutions/agile-delivery/","agile delivery",{"text":523,"config":524},"Transformation cloud",{"href":525,"dataGaName":526,"dataGaLocation":464},"/fr-fr/topics/cloud-native/","cloud transformation",{"text":528,"config":529},"SCM",{"href":120,"dataGaName":530,"dataGaLocation":464},"source code management",{"text":110,"config":532},{"href":112,"dataGaName":533,"dataGaLocation":464},"continuous integration & delivery",{"text":162,"config":535},{"href":164,"dataGaName":536,"dataGaLocation":464},"value stream management",{"text":538,"config":539},"GitOps",{"href":540,"dataGaName":541,"dataGaLocation":464},"/fr-fr/solutions/gitops/","gitops",{"text":175,"config":543},{"href":177,"dataGaName":178,"dataGaLocation":464},{"text":180,"config":545},{"href":182,"dataGaName":183,"dataGaLocation":464},{"text":185,"config":547},{"href":187,"dataGaName":188,"dataGaLocation":464},{"text":549,"config":550},"Formation",{"href":551,"dataGaName":552,"dataGaLocation":464},"/fr-fr/solutions/education/","education",{"text":554,"config":555},"Services financiers",{"href":556,"dataGaName":557,"dataGaLocation":464},"/fr-fr/solutions/finance/","financial services",{"title":195,"links":559},[560,562,564,566,569,571,574,576,578,580,582,584,586,588],{"text":207,"config":561},{"href":209,"dataGaName":210,"dataGaLocation":464},{"text":212,"config":563},{"href":214,"dataGaName":215,"dataGaLocation":464},{"text":217,"config":565},{"href":219,"dataGaName":220,"dataGaLocation":464},{"text":222,"config":567},{"href":224,"dataGaName":568,"dataGaLocation":464},"docs",{"text":245,"config":570},{"href":247,"dataGaName":248},{"text":572,"config":573},"Histoires de réussite client",{"href":242,"dataGaLocation":464},{"text":240,"config":575},{"href":242,"dataGaName":243,"dataGaLocation":464},{"text":250,"config":577},{"href":252,"dataGaName":253,"dataGaLocation":464},{"text":263,"config":579},{"href":265,"dataGaName":266,"dataGaLocation":464},{"text":255,"config":581},{"href":257,"dataGaName":258,"dataGaLocation":464},{"text":268,"config":583},{"href":270,"dataGaName":271,"dataGaLocation":464},{"text":273,"config":585},{"href":275,"dataGaName":276,"dataGaLocation":464},{"text":278,"config":587},{"href":280,"dataGaName":281,"dataGaLocation":464},{"text":283,"config":589},{"href":285,"dataGaName":286,"dataGaLocation":464},{"title":301,"links":591},[592,594,596,598,600,602,604,608,613,615,617,619],{"text":308,"config":593},{"href":310,"dataGaName":303,"dataGaLocation":464},{"text":313,"config":595},{"href":315,"dataGaName":316,"dataGaLocation":464},{"text":321,"config":597},{"href":323,"dataGaName":324,"dataGaLocation":464},{"text":326,"config":599},{"href":328,"dataGaName":329,"dataGaLocation":464},{"text":331,"config":601},{"href":333,"dataGaName":334,"dataGaLocation":464},{"text":336,"config":603},{"href":338,"dataGaName":339,"dataGaLocation":464},{"text":605,"config":606},"Sustainability",{"href":607,"dataGaName":605,"dataGaLocation":464},"/sustainability/",{"text":609,"config":610},"Diversité, inclusion et appartenance (DIB)",{"href":611,"dataGaName":612,"dataGaLocation":464},"/fr-fr/diversity-inclusion-belonging/","Diversity, inclusion and belonging",{"text":341,"config":614},{"href":343,"dataGaName":344,"dataGaLocation":464},{"text":351,"config":616},{"href":353,"dataGaName":354,"dataGaLocation":464},{"text":356,"config":618},{"href":358,"dataGaName":359,"dataGaLocation":464},{"text":620,"config":621},"Déclaration de transparence sur l'esclavage moderne",{"href":622,"dataGaName":623,"dataGaLocation":464},"https://handbook.gitlab.com/handbook/legal/modern-slavery-act-transparency-statement/","modern slavery transparency statement",{"title":361,"links":625},[626,629,631,633,638,643,648],{"text":627,"config":628},"Échanger avec un expert",{"href":39,"dataGaName":40,"dataGaLocation":464},{"text":370,"config":630},{"href":372,"dataGaName":373,"dataGaLocation":464},{"text":375,"config":632},{"href":377,"dataGaName":378,"dataGaLocation":464},{"text":634,"config":635},"Statut",{"href":636,"dataGaName":637,"dataGaLocation":464},"https://status.gitlab.com/","status",{"text":639,"config":640},"Conditions d'utilisation",{"href":641,"dataGaName":642},"/terms/","terms of use",{"text":644,"config":645},"Déclaration de confidentialité",{"href":646,"dataGaName":647,"dataGaLocation":464},"/fr-fr/privacy/","privacy statement",{"text":649,"config":650},"Préférences en matière de cookies",{"dataGaName":651,"dataGaLocation":464,"id":652,"isOneTrustButton":92},"cookie preferences","ot-sdk-btn",{"items":654},[655,657,660],{"text":639,"config":656},{"href":641,"dataGaName":642,"dataGaLocation":464},{"text":658,"config":659},"Politique de confidentialité",{"href":646,"dataGaName":647,"dataGaLocation":464},{"text":649,"config":661},{"dataGaName":651,"dataGaLocation":464,"id":652,"isOneTrustButton":92},"content:shared:fr-fr:main-footer.yml","Main Footer","shared/fr-fr/main-footer.yml","shared/fr-fr/main-footer",{"featuredPost":667,"allPosts":690,"totalPages":1201,"initialPosts":1202},{"_path":668,"_dir":248,"_draft":6,"_partial":6,"_locale":7,"seo":669,"content":674,"config":683,"_id":686,"_type":16,"title":687,"_source":18,"_file":688,"_stem":689,"_extension":21},"/fr-fr/blog/gitlab-named-a-leader-in-the-2025-gartner-magic-quadrant-for-devops-platforms",{"config":670,"title":671,"ogTitle":671,"description":672,"ogDescription":672,"ogImage":673},{"noIndex":6},"Magic Quadrant 2025 : GitLab, Leader des plateformes DevOps","GitLab se classe en première position dans 4 des 6 cas d'utilisation selon le rapport Critical Capabilities 2025 de Gartner® qui accompagne le Magic Quadrant.","https://res.cloudinary.com/about-gitlab-com/image/upload/f_auto,q_auto,c_lfill/v1758812952/yxhgljkwljld0lyizmaz.png",{"heroImage":673,"date":675,"title":676,"description":672,"authors":677,"body":679,"category":14,"tags":680},"2025-09-29","GitLab nommée Leader dans le Magic Quadrant 2025 de Gartner dédié aux plateformes DevOps",[678],"Manav Khurana","Pour la troisième année consécutive, GitLab a été nommée **Leader dans le Magic Quadrant™ 2025 de Gartner® dédié aux plateformes [DevOps](https://about.gitlab.com/fr-fr/topics/devops/ \"Qu'est-ce que le DevOps ?\")**, pour sa capacité d'exécution et l'exhaustivité de sa vision. Plus important encore, GitLab se classe en première position dans 4 des 6 cas d'utilisation : la livraison agile de logiciels, la livraison d'applications cloud-native, l’ingénierie de plateforme et la livraison réglementée, d'après le rapport Critical Capabilities 2025 de Gartner® dédié aux plateformes DevOps qui l'accompagne.\n\nCette reconnaissance valide, selon nous, notre stratégie de plateforme complète à un moment crucial pour le développement logiciel. Les organisations s'empressent d'adopter les capacités alimentées par l'IA tout en maintenant la sécurité, la conformité et l'excellence opérationnelle. Le succès exige une approche de plateforme unifiée qui transforme la façon dont les équipes collaborent et créent de la valeur.\n\nQue nos clients livrent des logiciels agiles, développent des applications cloud-native ou conçoivent des plateformes, GitLab leur permet de collaborer étroitement avec des agents d’IA pour livrer des logiciels sécurisés et fiables, plus rapidement. \n\n![Magic Quadrant™ 2025 de Gartner® pour les plateformes DevOps](https://res.cloudinary.com/about-gitlab-com/image/upload/v1758812615/sfchvkvtczmzqlaalk7y.png)\n\n\u003Cp>\u003C/p>\n\n> [Téléchargez les rapports](https://about.gitlab.com/fr-fr/gartner-magic-quadrant/) pour en savoir plus.\n\n## Une durée de création de valeur accélérée\n\nNotre mission est de permettre à chacun de contribuer et de co-créer des logiciels qui font fonctionner notre monde. [Le rythme rapide de notre programme d'innovation](https://about.gitlab.com/fr-fr/blog/gitlab-18-4-ai-native-development-with-automation-and-insight/) démontre que nous sommes loin d'avoir terminé. Nous avons livré de nouvelles solutions à nos clients chaque mois pendant plus de 150 mois, et nous prévoyons de poursuivre cette tradition. \n\nEn tant que leader du secteur, nous restons déterminés à aider nos clients à transformer ces nouvelles capacités en valeur commerciale. \n\nNous sommes convaincus qu'à l'heure où l'innovation alimentée par l'IA s'accélère dans l'ensemble de l'écosystème technologique, il n'a jamais été aussi important qu'aujourd'hui d'adopter [une approche de plateforme unifiée](https://about.gitlab.com/fr-fr/blog/why-are-organizations-moving-to-a-unified-devsecops-platform/) pour relever les défis d'ingénierie les plus complexes de nos clients. Cette approche permet aux organisations de réduire les coûts d'intégration, de combler les failles de sécurité et d'adopter l'innovation sans perturber les workflows de livraison de logiciels existants. \n\nVoici quelques exemples : \n\n* **Accélérez les releases avec l'IA agentique :** les chaînes d'outils fragmentées ralentissent les revues de code et les tests. Les agents et les flows de [GitLab Duo](https://about.gitlab.com/fr-fr/gitlab-duo/ \"Qu'est-ce que GitLab Duo ?\") automatisent un certain nombre de tâches comme les revues de code, la génération de tests et le tri des vulnérabilités dans le contexte de la plateforme complète, aidant les équipes à réduire les temps de cycle et à améliorer la qualité des logiciels.  \n* **Construisez de manière sécurisée dès le départ :** de nombreuses organisations traitent la sécurité comme une réflexion après coup, ce qui entraîne des rectifications coûteuses et des lacunes en matière de conformité. GitLab intègre l'analyse, l'application des politiques et les contrôles de conformité dans les workflows quotidiens, détectant les risques le plus tôt possible sans ralentir les équipes de développement. \n* **Déployez avec flexibilité :** les équipes soumises à des contraintes réglementaires ou opérationnelles strictes ont besoin d'options de déploiement allant au-delà du SaaS multilocataire. GitLab prend en charge les environnements SaaS, self-managed et air-gapped, afin de garantir aux clients un contrôle que les concurrents ne peuvent offrir.\n* **Offrez une innovation constante :** la fragmentation des outils rend l'adoption de nouvelles fonctionnalités risquée et perturbatrice. Les releases mensuelles de GitLab offrent de nouvelles fonctionnalités, telles que [GitLab Duo Agent Platform](https://about.gitlab.com/fr-fr/gitlab-duo/agent-platform/), une gouvernance IA étendue et des intégrations cloud que les équipes peuvent adopter sans avoir à se rééquiper.\n\n## Les cas d'utilisation clients qui comptent le plus\n\nTout comme le Magic Quadrant, nous pensons que le rapport Critical Capabilities 2025 de Gartner dédié aux plateformes DevOps évalue la capacité des plateformes à répondre aux besoins réels des clients. GitLab s'est classée en première position dans 4 des 6 cas d'utilisation présentés dans ce rapport.\n\nGitLab prend en charge les domaines d'innovation suivants :\n\n* **[Ensemble d'outils intégrés](https://about.gitlab.com/fr-fr/platform/)** pour une livraison cloud-native et à l'échelle de l’entreprise  \n* **[Outils de planification avancés](https://about.gitlab.com/fr-fr/solutions/agile-delivery/)** et **[fonctionnalités de sécurité étendues](https://about.gitlab.com/solutions/application-security-testing/)**\n* **[Gestion des paquets](https://about.gitlab.com/stages-devops-lifecycle/package/)** et feature flags pour une livraison progressive  \n* **[Mesures de la chaîne de valeur](https://about.gitlab.com/fr-fr/solutions/analytics-and-insights/)** pour une visibilité et une amélioration tout au long du cycle de développement logiciel.   \n* **[Workflows avec l’IA native](https://about.gitlab.com/fr-fr/gitlab-duo/agent-platform/)**, intégrés directement dans les tâches quotidiennes\n\nCette polyvalence se traduit par une réelle valeur ajoutée pour les clients, comme l'explique Bal Kang, Engineering Platform Lead chez NatWest : \n\n*« L'intégration des agents d’IA de GitLab Duo dans notre système d'enregistrement pour le code, les tests, le [CI/CD](https://about.gitlab.com/fr-fr/topics/ci-cd/) et l'ensemble du cycle de développement logiciel stimule la productivité, la vélocité et l'efficacité. Les agents comprennent l'intention, décomposent les problèmes et agissent, devenant de véritables collaborateurs pour nos équipes. »*\n\nLe passage à des plateformes unifiées représente un changement fondamental dans la façon dont les organisations abordent le développement logiciel. C'est pourquoi, selon nous, Gartner® nous a également récemment nommé [Leader dans le Magic Quadrant™ 2025 dédié aux assistants IA pour le code](https://about.gitlab.com/fr-fr/blog/gitlab-named-a-leader-in-the-2025-gartner-magic-quadrant-for-ai-code-assistants/).\n\nAlors que les entreprises cherchent à maximiser la productivité des équipes de développement de manière sécurisée et à accélérer l'innovation, une approche de plateforme complète devient plus urgente que jamais.\n\n> [Téléchargez les rapports](https://about.gitlab.com/fr-fr/gartner-magic-quadrant/) pour en savoir plus.\n\n*Source : Gartner, Magic Quadrant for DevOps Platforms, Keith Mann, Thomas Murphy, Bill Holz, George Spafford, 22 septembre 2025*\n\n*Source : Gartner, Critical Capabilities for DevOps Platforms, Thomas Murphy, Keith Mann, George Spafford, Bill Holz, 22 septembre 2025*\n\n*GARTNER est une marque déposée et une marque de service de Gartner, Inc. et/ou de ses sociétés affiliées aux États-Unis et dans le monde, et MAGIC QUADRANT est une marque déposée de Gartner, Inc. et/ou de ses sociétés affiliées et sont utilisées ici avec autorisation. Tous droits réservés.*\n\n*Gartner ne cautionne aucun fournisseur, produit ou service décrit dans ses publications de recherche et ne conseille pas aux utilisateurs de la technologie de sélectionner uniquement les fournisseurs ayant les notes les plus élevées ou toute autre désignation. Les publications de recherche de Gartner reflètent les opinions de l'organisation de recherche de Gartner et ne doivent pas être interprétées comme des déclarations de fait. Gartner décline toute garantie, expresse ou implicite, concernant cette recherche, y compris toute garantie de qualité marchande ou d'adéquation à un usage particulier.*\n\n*Ce graphique a été publié par Gartner Inc. dans le cadre d'un rapport plus large et doit être évalué dans le contexte de l’ensemble du document. Le document Gartner est disponible sur demande auprès de Gartner B.V.*",[14,681,682],"news","DevOps platform",{"featured":6,"template":684,"slug":685},"BlogPost","gitlab-named-a-leader-in-the-2025-gartner-magic-quadrant-for-devops-platforms","content:fr-fr:blog:gitlab-named-a-leader-in-the-2025-gartner-magic-quadrant-for-devops-platforms.yml","Gitlab Named A Leader In The 2025 Gartner Magic Quadrant For Devops Platforms","fr-fr/blog/gitlab-named-a-leader-in-the-2025-gartner-magic-quadrant-for-devops-platforms.yml","fr-fr/blog/gitlab-named-a-leader-in-the-2025-gartner-magic-quadrant-for-devops-platforms",[691,712,736,756,775,793,815,838,861,883,903,925,945,965,987,1006,1028,1048,1069,1089,1109,1132,1155,1178],{"_path":692,"_dir":248,"_draft":6,"_partial":6,"_locale":7,"seo":693,"content":697,"config":706,"_id":708,"_type":16,"title":709,"_source":18,"_file":710,"_stem":711,"_extension":21},"/fr-fr/blog/migrating-by-direct-transfer-is-generally-available",{"config":694,"title":695,"description":696},{"noIndex":6},"La migration par transfert direct est désormais disponible","Découvrez comment migrer efficacement vos groupes et projets GitLab entre instances GitLab grâce à la migration par transfert direct, performante et sécurisée.",{"title":695,"description":696,"authors":698,"heroImage":700,"date":701,"body":702,"category":14,"tags":703},[699],"Magdalena Frankiewicz","https://res.cloudinary.com/about-gitlab-com/image/upload/v1753898687/nlxenzmbdk62dlylt3ey.png","2025-08-04","La migration des groupes et projets GitLab par transfert direct est désormais disponible dans la version GitLab 18.3. Il s'agit d'une méthode simple et automatisée pour migrer des ressources GitLab entre instances GitLab vers un public encore plus large.\n\nLe [transfert direct](https://docs.gitlab.com/user/group/import/) vous permet de créer facilement une copie des ressources GitLab de votre choix sur la même instance ou sur une autre instance GitLab. Vous pouvez utiliser l'interface utilisateur (intuitive et simple d'utilisation), ou [l'API](https://docs.gitlab.com/ee/api/bulk_imports.html) qui offre une flexibilité supplémentaire pour choisir les ressources à copier.\n\nLa migration par transfert direct représente une amélioration majeure par rapport à la [migration de groupes et de projets via l'exportation de fichiers](https://docs.gitlab.com/ee/user/project/settings/import_export.html#migrate-projects-by-uploading-an-export-file) pour les raisons suivantes :\n\n* Vous n'avez plus besoin d'exporter manuellement chaque groupe et projet individuel vers un fichier, puis d'importer tous ces fichiers vers un nouvel emplacement. Désormais, il vous suffit de migrer directement tout groupe de niveau supérieur dont vous avez le rôle de propriétaire avec tous ses sous-groupes et projets.\n* La migration par transfert direct permet le [mappage des contributions utilisateur après l'importation](https://about.gitlab.com/blog/streamline-migrations-with-user-contribution-and-membership-mapping/) (comme la paternité des tickets ou des commentaires), pour plus de flexibilité et de contrôle.\n* Elle fonctionne de manière fiable avec des projets volumineux. Grâce au traitement par lots des ressources et à l'exécution simultanée des processus d'importation et d'exportation, les risques d'interruption ou de délai d'attente dépassé sont considérablement réduits.\n* Elle offre une meilleure visibilité sur la migration pendant son exécution ainsi qu'après sa finalisation. Dans l'interface utilisateur, vous pouvez observer l'augmentation du nombre de fichiers à mesure que de nouveaux éléments sont importés. Ensuite, vous pouvez [vérifier les résultats de l'importation](https://docs.gitlab.com/user/group/import/direct_transfer_migrations/#review-results-of-the-import). Les éléments importés sont indiqués par le badge `Imported` dans l'interface utilisateur GitLab.\n\nNous avons parcouru un long chemin depuis GitLab 14.3, lorsque nous avons commencé à prendre en charge la migration directe des ressources de groupe. Dans GitLab 15.8, nous avons [étendu cette fonctionnalité aux projets en version bêta](https://about.gitlab.com/blog/2023/01/18/try-out-new-way-to-migrate-projects/). Depuis, nous avons travaillé à améliorer l'efficacité et la fiabilité de l'importation, en particulier pour les projets volumineux. Nous avons également minutieusement testé la sécurité et la stabilité des instances de cette nouvelle fonctionnalité.\n\nVoici deux exemples d'importations réussies qui illustrent la taille des groupes et des projets que nous avons testés, ainsi que leur durée d'importation :\n\n* 100 projets (19 900 tickets, 83 000 merge requests, plus de 100 000 pipelines) migrés en 8 heures\n* 1 926 projets (22 000 tickets, 160 000 merge requests, 1,1 million de pipelines) migrés en 34 heures\n\nSur GitLab.com, la migration par transfert direct est activée par défaut, tandis que sur GitLab Self-Managed et sur GitLab Dedicated, un administrateur doit [activer la fonctionnalité dans les paramètres de l'application](https://docs.gitlab.com/ee/administration/settings/import_and_export_settings.html#enable-migration-of-groups-and-projects-by-direct-transfer).\n\n## Quand utiliser la migration par transfert direct et comment obtenir les meilleurs résultats ?\n\nLa migration par transfert direct nécessite une connexion réseau entre les instances ou GitLab.com. Par conséquent, les clients qui utilisent des réseaux air-gapped sans connectivité entre leurs instances GitLab doivent toujours utiliser l'exportation de fichiers pour copier leurs données GitLab. Ils pourront utiliser la migration de groupes et de projets par transfert direct lorsque cette solution [prendra en charge les instances hors ligne](https://gitlab.com/groups/gitlab-org/-/epics/8985).\n\nAvant toute migration, consultez notre [documentation](https://docs.gitlab.com/user/group/import/), y compris les [prérequis](https://docs.gitlab.com/user/group/import/direct_transfer_migrations/#prerequisites), les [éléments de groupe](https://docs.gitlab.com/ee/user/group/import/#migrated-group-items) et les [éléments de projet](https://docs.gitlab.com/ee/user/group/import/#migrated-project-items) qui sont migrés. Certains éléments sont exclus de la migration ou ne sont pas encore pris en charge.\n\n### Migrez entre les versions les plus récentes possibles\n\nNous recommandons de migrer entre des versions aussi récentes que possible. Mettez à jour les instances source et destination pour profiter de toutes les améliorations et corrections de bogues que nous avons ajoutées au fil du temps.\n\n### Préparez-vous au mappage des contributions utilisateur après la migration\n\nFamiliarisez-vous avec le [processus de mappage des contributions et des appartenances utilisateur](https://docs.gitlab.com/user/project/import/#user-contribution-and-membership-mapping) afin de connaître les prochaines étapes à suivre une fois la migration terminée.\n\n### Examinez les options pour réduire la durée de migration\n\nSelon l'endroit où vous migrez (GitLab.com, une instance Self-Managed ou Dedicated) vous pouvez appliquer [diverses stratégies pour réduire la durée de migration](https://docs.gitlab.com/ee/user/group/import/#reducing-migration-duration).\n\n## Comment puis-je examiner les résultats ?\n\nVous pouvez consulter tous les groupes et projets que vous avez migrés par transfert direct sur la [page d'historique d'importation de groupe](https://docs.gitlab.com/user/group/import/direct_transfer_migrations/#group-import-history). Pour chaque groupe et projet, vous avez la possibilité d'afficher les statistiques des éléments importés et d'examiner plus en détails les éléments qui n'ont pas été importés. Vous pouvez également utiliser les [points de terminaison API](https://docs.gitlab.com/ee/api/bulk_imports.html#list-all-group-or-project-migrations-entities) pour faire de même.\n\nDans les cas où la plupart de vos projets se sont terminés avec succès, mais que certaines relations manquent encore dans un ou deux projets, comme des merge requests ou des tickets, nous vous recommandons d'essayer de réimporter ces projets [avec l'API](https://docs.gitlab.com/ee/api/bulk_imports.html#start-a-new-group-or-project-migration).\n\n![](https://res.cloudinary.com/about-gitlab-com/image/upload/v1753961409/ja8agmwarwxxlo9vmqbo.gif)\n\n## Quelle est la prochaine étape pour la migration par transfert direct ?\n\nNous sommes ravis de proposer la migration par transfert direct et espérons que cette amélioration vous plaira ! Nous souhaitons connaître votre avis. Quelle est la fonctionnalité qui, selon vous, manque encore ? Que pouvons-nous améliorer ? Faites-le nous savoir dans [ce ticket](https://gitlab.com/gitlab-org/gitlab/-/issues/284495) et nous continuerons à itérer !",[704,14,705],"DevSecOps","features",{"featured":92,"template":684,"slug":707},"migrating-by-direct-transfer-is-generally-available","content:fr-fr:blog:migrating-by-direct-transfer-is-generally-available.yml","Migrating By Direct Transfer Is Generally Available","fr-fr/blog/migrating-by-direct-transfer-is-generally-available.yml","fr-fr/blog/migrating-by-direct-transfer-is-generally-available",{"_path":713,"_dir":248,"_draft":6,"_partial":6,"_locale":7,"seo":714,"content":722,"config":730,"_id":732,"_type":16,"title":733,"_source":18,"_file":734,"_stem":735,"_extension":21},"/fr-fr/blog/4-ways-to-accelerate-embedded-development-with-gitlab",{"ogTitle":715,"schema":716,"ogImage":717,"ogDescription":718,"ogSiteName":719,"noIndex":6,"ogType":720,"ogUrl":721,"title":715,"canonicalUrls":721,"description":718},"Accélérez le développement de systèmes embarqués avec GitLab","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Accélérez le développement de systèmes embarqués avec GitLab\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Matt DeLaney\"},{\"@type\":\"Person\",\"name\":\"Darwin Sanoy\"}],\n        \"datePublished\": \"2025-07-29\",\n      }","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749659756/Blog/Hero%20Images/REFERENCE_-_display_preview_for_blog_images.png","Découvrez 4 façons d’accélérer le développement de systèmes embarqués avec GitLab.","https://about.gitlab.com","article","https://about.gitlab.com/fr-fr/blog/4-ways-to-accelerate-embedded-development-with-gitlab",{"title":715,"description":723,"authors":724,"heroImage":717,"date":727,"body":728,"category":14,"tags":729},"Découvrez comment les tests matériels automatisés, les compilations standardisées, les workflows collaboratifs, et la conformité intégrée éliminent les goulots d’étranglement dans le développement de micrologiciels.",[725,726],"Matt DeLaney","Darwin Sanoy","2025-07-29","Les logiciels présents dans les systèmes embarqués, autrefois perçus comme de simples composants techniques, constituent désormais un facteur de différenciation essentiel. Les micrologiciels qui optimisent le fonctionnement de nos véhicules, avions et équipements industriels atteignent aujourd’hui un niveau de complexité remarquable. D'ici fin 2025, chaque véhicule contiendra en moyenne [650 millions](https://www.statista.com/statistics/1370978/automotive-software-average-lines-of-codes-per-vehicle-globally/) de lignes de code, contre 200 millions il y a seulement cinq ans. Dans l’aérospatial, la complexité des logiciels embarqués a presque [doublé tous les quatre ans](https://www.mckinsey.com/industries/aerospace-and-defense/our-insights/debugging-the-software-talent-gap-in-aerospace-and-defense) au cours des dernières décennies. \n\nLes approches traditionnelles de développement de systèmes embarqués ralentissent le travail des ingénieurs, qui peinent à gérer efficacement la complexité croissante des composants logiciels des machines modernes, notamment : \n\n* [Les goulots d'étranglement lors des tests matériels](#challenge-1-hardware-testing-bottlenecks) \n* [Les environnements de compilation incohérents](#challenge-2-inconsistent-build-environments)\n* [Les pratiques de développement cloisonnées](#challenge-3-siloed-development-practices)\n* [Les processus manuels de conformité à la sécurité fonctionnelle](#challenge-4-manual-functional-safety-compliance-processes)\n\nLes équipes chargées de développer des systèmes embarqués doivent adopter une nouvelle approche pour faire face à l'augmentation rapide de la taille des dépôts de code. \n\nDécouvrez dans cet article quatre façons de tirer parti des capacités d'IA native de la plateforme DevSecOps de GitLab, afin de raccourcir les boucles de rétroaction, favoriser un travail collaboratif et itératif, et rationaliser la gestion de la conformité.\n\n## Défi 1 : les goulots d'étranglement lors des tests matériels\n\nContrairement aux logiciels d'entreprise qui peuvent s'exécuter sur pratiquement n'importe quel serveur cloud, les logiciels embarqués du secteur automobile doivent être testés sur du matériel spécialisé reproduisant fidèlement les environnements de production. Les processus de test HIL (Hardware-In-the-Loop) traditionnels suivent souvent ce workflow :\n\n1. Un développeur écrit le code d'un système embarqué (par exemple, une unité de commande électronique).  \n2. Il sollicite l'accès à des bancs d'essai matériels limités et onéreux (le prix peut varier entre 500 000 $ et 10 millions de dollars chacun).  \n3. Il patiente plusieurs jours, voire des semaines, avant d'obtenir cet accès.  \n4. Puis il déploie et teste manuellement le code directement sur son poste de travail.\n5. Enfin, il documente les résultats des tests, transmet le matériel à un autre membre de l'équipe de développement pour la suite du projet, et attend de pouvoir effectuer à nouveau d'autres tests matériels.\n\nCe processus s'avère particulièrement inefficace. Une fois leur code écrit, les développeurs de systèmes embarqués peuvent attendre plusieurs semaines avant de pouvoir le tester sur une cible matérielle. Entre temps, ils sont déjà passés à d'autres tâches, ce qui entraîne un changement de contexte préjudiciable à leur productivité. Pire encore, ils peuvent découvrir au bout de plusieurs semaines qu'une simple erreur de calcul s'est glissée dans leur code. \n\n### Solution : allocation automatisée du matériel et intégration continue\n\nVous pouvez rationaliser les tests matériels grâce à l'automatisation en utilisant le composant CI/CD [On-Premises Device Cloud](https://gitlab.com/guided-explorations/embedded/ci-components/device-cloud) de GitLab. Ce composant permet d'automatiser l'orchestration de ressources matérielles limitées en transformant un processus manuel et fastidieux en un workflow rationalisé et continu.\n\nLe composant On-Premises Device Cloud procède comme suit :\n\n1. Il crée des pools de ressources matérielles partagées.  \n2. Il alloue automatiquement (et exclusivement) du matériel aux tâches de test matériel du pipeline d'un développeur en fonction de la disponibilité.  \n3. Il déploie et exécute les tests sans intervention manuelle.  \n4. Il collecte les résultats des tests et les partage via des [pipelines CI/CD](https://about.gitlab.com/fr-fr/topics/ci-cd/cicd-pipeline/ \"Qu'est-ce qu'un pipeline CI/CD ?\") intégrés.  \n5. Il libère automatiquement le matériel dans le pool de ressources « disponibles ».\n\nUne fois que vous avez soumis le code, vous recevez les résultats en quelques heures, au lieu de plusieurs jours auparavant, souvent sans jamais toucher physiquement le matériel de test.\n\nDécouvrez dans cette vidéo comment le composant CI/CD On-Premises Device Cloud de GitLab permet d'orchestrer à distance l'allocation de matériel partagé pour les tests HIL :\n\n\u003C!-- blank line -->\n\n\u003Cfigure class=\"video_container\"> \u003Ciframe src=\"https://www.youtube.com/embed/ltr2CIM9Zag?si=NOij3t1YYz4zKajC\" frameborder=\"0\" allowfullscreen=\"true\"> \u003C/iframe> \u003C/figure>\n\u003C!-- blank line -->\n\nVous pouvez également adopter des stratégies de test multi-niveaux, qui offrent un compromis optimal entre rapidité d'exécution et qualité des résultats. Pour cela, intégrez les modèles et environnements de test de systèmes embarqués suivants dans vos pipelines automatisés GitLab CI :\n\n* **Software-in-the-Loop (SIL) :** tests effectués sur des simulateurs de matériel virtuels pour obtenir plus rapidement les tout premiers retours sur le code.  \n* **Processor-in-the-Loop (PIL) :** tests réalisés sur un processeur proche du contexte final pour obtenir des retours sur le code plus rapidement et à moindre coût.  \n* **Hardware-in-the-Loop (HIL) :** tests sur du matériel complet équivalent à celui de l'environnement de production, utilisés comme bancs d'essai pour vérification à un stade avancé.\n\nEn automatisant l'orchestration de ces différents tests dans vos pipelines CI, vous serez en mesure d'identifier les problèmes plus tôt, d'itérer plus rapidement et d'accélérer les délais de mise sur le marché.\n\n## Défi 2 : les environnements de compilation incohérents\n\nL'hétérogénéité des environnements de compilation constitue un problème majeur dans le développement de systèmes embarqués. Les équipes chargées de développer des systèmes embarqués exécutent souvent manuellement des compilations sur leurs machines locales avec des configurations, versions de compilateur et dépendances parfois très différentes. Elles intègrent ensuite les binaires issus de leurs compilations locales dans le code source partagé.\n\nCette approche entraîne plusieurs problèmes :\n\n* **Résultats incohérents :** basées sur le même code source, les compilations produisent des résultats différents selon les machines utilisées.  \n* **Syndrome du « Ça fonctionne sur ma machine » :** le code compilé localement échoue dans les environnements partagés.  \n* **Mauvaise traçabilité :** piste d'audit limitée pour connaître l'auteur, la date et le motif de la compilation.  \n* **Compartimentation des connaissances :** seuls quelques experts maîtrisent le processus de compilation.\n\nCette approche accroît le risque d'erreurs, crée des goulots d'étranglement et peut générer des retards coûteux. \n\n### Solution : automatisation standardisée des compilations\n\nVous pouvez relever ces défis en mettant en œuvre une automatisation standardisée de la compilation au sein de vos pipelines CI/CD dans GitLab. Cette approche garantit des environnements de compilation cohérents, reproductibles et basés sur des conteneurs, éliminant ainsi les variations spécifiques de configuration entre les différentes machines. En combinant cette standardisation avec des scripts de provisionnement Embedded Gateway Runner spécifiques, les conteneurs peuvent s'interfacer avec le matériel pour y déployer du code et surveiller les ports dans le cadre de tests automatisés.\n\nVoici les points clés de cette solution :\n\n* **Environnements gérés par le cycle de vie :** définissez vos environnements de simulation de systèmes embarqués complexes sous forme de code, déployez-les automatiquement pour les tests, puis détruisez-les une fois les tests terminés.  \n* **Conteneurisation :** utilisez des conteneurs Docker pour garantir des environnements de compilation homogènes et reproductibles.  \n* **Gestion automatisée des dépendances :** assurez un contrôle et un versionnage rigoureux de toutes les dépendances.  \n* **Compilations centralisée :** exécutez les compilations sur une infrastructure partagée, plutôt que sur des machines locales.\n\n> Suivez ce tutoriel et découvrez [comment automatiser les compilations de logiciels embarqués dans un pipeline GitLab CI](https://gitlab.com/guided-explorations/embedded/workshops/embedded-devops-workshop-refactoring-to-ci/-/blob/main/TUTORIAL2.md%20).\n\nEn standardisant et en automatisant le processus de compilation, vous vous assurez que chaque compilation suit les mêmes étapes avec des dépendances identiques, produisant ainsi des résultats cohérents, quelle que soit la personne qui l'a initiée. Cette approche améliore non seulement la qualité, mais rend aussi le processus accessible à toute l'équipe, même aux membres ne possédant pas une expertise approfondie dans ce domaine.\n\n## Défi 3 : les pratiques de développement cloisonnées\n\nAlors que les équipes de développement ont largement adopté des pratiques collaboratives telles que [DevOps](https://about.gitlab.com/fr-fr/topics/devops/ \"Qu'est-ce que l'approche DevOps ?\"), en s'appuyant sur la gestion partagée du code source (SCM) et les systèmes d'intégration et de livraison continues ([CI/CD](https://about.gitlab.com/fr-fr/topics/ci-cd/cicd-pipeline/ \"Qu'est-ce que le CI/CD ?\")), les développeurs de systèmes embarqués travaillent encore souvent seuls à leur bureau. Cette situation s'explique par plusieurs contraintes techniques légitimes. \n\nPar exemple, la virtualisation matérielle est un pilier de l'automatisation DevOps. Toutefois, le secteur a été plus lent à virtualiser la vaste gamme de processeurs et de cartes spécialisés utilisés dans les systèmes embarqués, en grande partie en raison des difficultés liées à la virtualisation des systèmes de production en temps réel et d'un manque d'incitations économiques. Nous pouvons comparer cela à la virtualisation cloud, qui s'est largement démocratisée et a profité au développement SaaS depuis plus d'une décennie.\n\nAujourd'hui, de nombreux fournisseurs adoptent désormais la virtualisation afin d'accélérer le développement des systèmes embarqués. Cependant, si les équipes ne parviennent pas à adopter des options de test virtuel, l'effet de silo persistera, avec des impacts négatifs sur l'entreprise, notamment les suivants : \n\n* **Une fragmentation des connaissances** : les informations critiques restent dispersées entre différents membres de l'équipe et entre différentes équipes.  \n* **Un développement redondant** : plusieurs équipes résolvent les mêmes problèmes, ce qui crée des incohérences.  \n* **Une découverte tardive lors des intégrations massives (big-bang)** : les problèmes ne sont détectés qu'aux dernières étapes du processus, lorsque plusieurs développeurs intègrent leur code en même temps, rendant la correction des erreurs plus coûteuses.  \n* **Un ralentissement de l'innovation** : les solutions développées dans un domaine ont peu d'impact sur les autres, ce qui entrave le développement de nouvelles idées de produits.\n\n### Solution : ingénierie collaborative via une plateforme unifiée\n\nUne étape importante pour briser ces silos consiste à standardiser le développement de systèmes embarqués sur la plateforme [DevSecOps](https://about.gitlab.com/fr-fr/topics/devsecops/ \"Qu'est-ce que le DevSecOps ?\") unifiée de GitLab. GitLab joue un rôle central dans l’évolution des systèmes embarqués vers des plateformes consolidées et partagées, adaptées aux contraintes des appareils embarqués. \n\nLa plateforme GitLab offre notamment les avantages suivants :\n\n* **Une visibilité partagée :** l'ensemble du code, des tickets et de la documentation sont accessibles à toutes les équipes.  \n* **Des workflows collaboratifs :** favorisez la revue par les pairs et le partage des connaissances par le biais de merge requests.  \n* **Des connaissances centralisées :** maintenez une source unique de vérité pour tous les artefacts de développement.  \n* **Une collaboration asynchrone :** les équipes sont en mesure de collaborer efficacement, quel que soit leur localisation ou leur fuseau horaire.\n\nLa collaboration entre les humains et les agents d'IA est un ingrédient fondamental pour stimuler les innovations orientées client, tant pour les générations nées à l'ère du numérique que pour les marques établies proposant des systèmes embarqués. GitLab facilite cette synergie en favorisant la transparence tout au long du cycle de développement, transformant ainsi le développement de systèmes embarqués en une pratique collaborative plutôt qu'une activité isolée. Les équipes de développement peuvent suivre le travail de leurs collègues, apprendre des expériences collectives et s'appuyer sur des solutions partagées.\n\nRegardez cette présentation d'Embedded World Germany 2025 et découvrez le potentiel des équipes chargées de développer des systèmes embarqués qui collaborent et partagent leur travail en cours en temps réel. La partie démonstration (de 24:42 à 36:51) illustre comment intégrer les tests HIL dans un pipeline GitLab CI afin de favoriser un développement collaboratif efficace.\n\n\u003C!-- blank line -->\n\n\u003Cfigure class=\"video_container\"> \u003Ciframe src=\"https://www.youtube.com/embed/F_rlOyq0hzc?si=eF4alDY6HK98uZPj\" frameborder=\"0\" allowfullscreen=\"true\"> \u003C/iframe> \u003C/figure>\n\u003C!-- blank line -->\n\nPlus important encore, en renforçant leur collaboration grâce à l'approche DevSecOps, les équipes parviennent à concevoir des systèmes embarqués totalement novateurs. En effet, la collaboration alimente l'innovation. Par exemple, [une étude](https://www.sciencedirect.com/science/article/abs/pii/S0749597800928887) a démontré que le brainstorming de groupe, lorsqu'il est correctement structuré, génère des idées plus innovantes et créatives que le travail individuel. Dans la course au développement de produits définis par logiciel, le développement collaboratif est donc un facteur clé de succès. \n\n## Défi 4 : les processus manuels de conformité à la sécurité fonctionnelle\n\nDans les secteurs de l'automobile et de l'aérospatiale, les systèmes embarqués doivent respecter des normes strictes de sécurité fonctionnelle, telles que les ISO 26262, MISRA C/C++, DO-178C et DO-254. Les approches traditionnelles de conformité impliquent des revues manuelles, une documentation volumineuse et plusieurs étapes de vérification tardives dans le cycle de développement. Elles créent souvent des goulots d'étranglement lors de la recherche de failles de sécurité. Par exemple, lorsque des scanners spécialisés dans la sécurité et la qualité du code des systèmes embarqués détectent des vulnérabilités, le ticket associé vient s'ajouter à la pile de tickets non résolus. Les développeurs ne peuvent pas intégrer leur code et les équipes de sécurité doivent traiter un important backlog de violations des exigences de conformité. Cette situation ralentit considérablement les délais de mise en conformité et freine l'avancement global du projet. \n\nVoici les principaux défis à relever : \n\n* **Détection tardive des problèmes de conformité** : les anomalies sont découvertes une fois le développement terminé.  \n* **Charge de travail liée à la documentation** : effort manuel important pour créer et maintenir des preuves de conformité.  \n* **Goulots d'étranglement relatifs aux processus** : étapes de conformité réalisées de manière séquentielle, qui bloquent la progression du développement.\n* **Dépendance à l'expertise** : un nombre limité de spécialistes sont sollicités pour les activités de contrôle de la conformité.\n\nEn conséquence, les équipes doivent souvent choisir entre vélocité et conformité, un compromis risqué lorsqu'il s'agit de systèmes critiques pour la sécurité.\n\n### Solution : un workflow automatisé de contrôle de la conformité en matière de sécurité fonctionnelle\n\nPlutôt que de traiter la sécurité et la conformité comme des étapes de vérification post-développement, vous pouvez codifier les exigences de conformité et les appliquer automatiquement via [des frameworks personnalisables dans GitLab](https://about.gitlab.com/blog/introducing-custom-compliance-frameworks-in-gitlab/). Pour ce faire, en particulier pour les normes de sécurité fonctionnelle, vous pouvez intégrer GitLab à des outils spécialisés, capables d’analyser en profondeur les micrologiciels conformément aux normes en vigueur dans ce domaine. Parallèlement, GitLab propose des contrôles de conformité automatisés, des pistes d'audit complètes et un contrôle rigoureux des merge requests : autant de fonctionnalités essentielles pour prendre en charge un programme de conformité logicielle continue robuste. \n\nVoici les composants de cette approche intégrée :\n\n* **Compliance-as-Code :** définissez les exigences de conformité sous forme de contrôles automatisés.  \n* **Intégration d'outils spécialisés :** connectez des outils tels que CodeSonar à la plateforme DevSecOps pour valider les exigences de conformité propres au secteur automobile.  \n* **Vérification continue de la conformité :** évaluez la conformité tout au long du cycle de développement.  \n* **Collecte automatisée des preuves :** rassemblez les artefacts de conformité comme un sous-produit du développement.\n\nDécouvrez dans cette vidéo comment tirer parti des frameworks de conformité personnalisés dans GitLab afin de créer vos propres politiques de conformité adaptées aux normes en vigueur (par exemple, ISO 26262) et comment les appliquer automatiquement à vos projets dans GitLab.\n\n\u003C!-- blank line -->\n\n\u003Cfigure class=\"video_container\"> \u003Ciframe src=\"https://www.youtube.com/embed/S-FQjzSyVJw?si=0UdtGNuugLPG0SLL\" frameborder=\"0\" allowfullscreen=\"true\"> \u003C/iframe> \u003C/figure>\n\u003C!-- blank line -->\n\nEn contrôlant la conformité en amont et en l'intégrant naturellement dans vos workflows de développement existants, vous pouvez maintenir les normes de sécurité sans compromettre la vélocité. Les contrôles automatisés détectent les problèmes à un stade précoce, lorsqu'ils sont plus faciles et moins coûteux à résoudre, tandis que la collecte continue de preuves réduit la charge de travail liée à la gestion de la documentation.\n\n## Accélérez la livraison de vos logiciels avec les systèmes embarqués \n\nLe développement de systèmes embarqués connaît une transformation rapide. Les équipes qui s'en tiennent à des processus manuels et des workflows isolés seront de plus en plus à la traîne, tandis que celles qui adoptent des pratiques automatisées et collaboratives dessineront l'avenir des systèmes intelligents définis par logiciel.\n\nPour vous lancer, explorez notre [atelier DevOps dédié aux systèmes embarqués](https://gitlab.com/guided-explorations/embedded/workshops/embedded-devops-workshop-refactoring-to-ci) et commencez à automatiser vos workflows de développement de systèmes embarqués avec GitLab. Vous pouvez également [regarder cette présentation par le Field Chief Cloud Architect de GitLab](https://content.gitlab.com/viewer/0a35252831bd130f879b0725738f70ed) pour découvrir comment les entreprises leader intègrent les tests matériels dans leurs workflows d'intégration continue afin d'accélérer la livraison de leurs systèmes embarqués.",[],{"slug":731,"featured":6,"template":684},"4-ways-to-accelerate-embedded-development-with-gitlab","content:fr-fr:blog:4-ways-to-accelerate-embedded-development-with-gitlab.yml","4 Ways To Accelerate Embedded Development With Gitlab","fr-fr/blog/4-ways-to-accelerate-embedded-development-with-gitlab.yml","fr-fr/blog/4-ways-to-accelerate-embedded-development-with-gitlab",{"_path":737,"_dir":248,"_draft":6,"_partial":6,"_locale":7,"seo":738,"content":741,"config":750,"_id":752,"_type":16,"title":753,"_source":18,"_file":754,"_stem":755,"_extension":21},"/fr-fr/blog/exact-code-search-find-code-faster-across-repositories",{"noIndex":6,"title":739,"description":740},"Trouvez rapidement du code dans vos dépôts GitLab","Découvrez comment trouver des correspondances exactes, utiliser des motifs regex et afficher des résultats contextuels dans des codes sources de plusieurs téraoctets. ",{"title":742,"description":740,"authors":743,"heroImage":745,"date":746,"body":747,"category":14,"tags":748},"Recherche exacte de code : trouvez rapidement du code dans vos dépôts",[744],"Dmitry Gruzd","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749675154/Blog/Hero%20Images/blog-image-template-1800x945__8_.png","2025-07-23","Imaginez pouvoir cibler n'importe quelle ligne de code parmi 48 To de dépôts\nen quelques millisecondes. Ceci est désormais possible avec la\nfonctionnalité de [recherche exacte de\ncode](https://docs.gitlab.com/ee/user/search/exact_code_search.html) de\nGitLab qui fournit une précision extrême, une prise en charge avancée des\nexpressions régulières (regex) et des résultats contextuels sur plusieurs\nlignes. En présence de dépôts de code volumineux, cette fonctionnalité\nfacilite considérablement le travail des équipes.\n\n\n## Pourquoi la recherche de code traditionnelle est-elle problématique ?\n\n\nToute personne travaillant avec du code connaît la frustration de devoir chercher du code dans plusieurs dépôts. Qu'il s'agisse de déboguer un problème, d'examiner des fichiers de configuration, de rechercher des vulnérabilités, de mettre à jour une documentation ou de vérifier la mise en œuvre d'un projet, vous savez exactement ce que vous cherchez, mais les outils de recherche traditionnels vous font régulièrement défaut.\n\n\nCes outils renvoient trop souvent des dizaines de faux positifs, manquent cruellement de contexte pour comprendre les résultats obtenus et sont de plus en plus lents à mesure que le code source s’étoffe. Par conséquent, vous perdez un temps précieux à chercher une aiguille dans une botte de foin au lieu de compiler, de sécuriser ou d'améliorer votre logiciel.\n\n\nLa fonctionnalité de recherche de code de GitLab était jusqu'ici prise en charge par Elasticsearch ou OpenSearch. Bien qu'excellents pour rechercher des tickets, des merge requests, des commentaires et d'autres données contenant du langage naturel, ces outils n'ont tout simplement pas été spécifiquement conçus pour le code. Après [avoir évalué de nombreuses options](https://gitlab.com/groups/gitlab-org/-/epics/7404), nous avons développé une meilleure solution.\n\n\n## Qu'est-ce que la recherche exacte de code ?\n\n\nLa **[recherche exacte de code](https://docs.gitlab.com/ee/user/search/exact_code_search.html)** de GitLab est actuellement en phase de test bêta et optimisée par [Zoekt](https://github.com/sourcegraph/zoekt) (prononcé « zookt », qui signifie « recherche » en néerlandais). Zoekt est un moteur de recherche de code open source initialement développé par Google et aujourd'hui maintenu par Sourcegraph. Conçu spécifiquement pour une recherche de code à la fois rapide et précise à grande échelle, nous l'avons enrichi avec des intégrations propres à GitLab, des améliorations avancées et une intégration facilitée du système d'autorisations.\n\n\nCette fonctionnalité révolutionne la manière dont vous recherchez et comprenez le code grâce aux trois éléments clés :\n\n\n**1. Un mode de recherche par correspondance exacte**\n\n\nLorsque vous basculez en **mode de recherche par correspondance exacte**, le moteur de recherche ne renvoie que les résultats qui correspondent exactement à votre requête, éliminant ainsi les faux positifs. Cette précision est inestimable dans les cas de figure suivants :\n\n\n* Vous recherchez des messages d'erreur spécifiques.\n\n* Vous recherchez des signatures de fonctions précises.\n\n* Vous recherchez des instances de noms de variables spécifiques.\n\n\n**2. Un mode de recherche par expression régulière**\n\n\nPour les recherches complexes, ce mode vous permet de créer des motifs de recherche sophistiqués :\n\n\n* Trouvez des fonctions selon des motifs de nommage spécifiques.\n\n* Déterminez l’emplacement des variables qui correspondent à certains critères précis.\n\n* Identifiez les failles de sécurité potentielles à l'aide de la correspondance de motifs.\n\n\n**3. Des correspondances sur plusieurs lignes**\n\n\n![Recherche exacte de code](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750704179/ttjuilkt3v7gtyywnchx.png)\n\n\nEn plus de la ligne contenant le code recherché, vous avez accès au contexte environnant qui est indispensable pour bien comprendre le code. Vous n'avez donc plus besoin d'accéder aux fichiers dans le seul but d'obtenir un contexte plus clair, ce qui accélère considérablement votre workflow.\n\n\n## Des fonctionnalités aux workflows : cas d'utilisation et impact associé \n\n\nExaminons maintenant comment ces nouvelles capacités se traduisent dans le quotidien des équipes de développement  :\n\n\n### Débogage en quelques secondes\n\n\nVoici un exemple de workflow tel qu'il pouvait être envisagé avant que la recherche exacte de code ne soit disponible : vous deviez copier un message d'erreur, lancer une recherche, parcourir une longue liste de correspondances partielles dans les commentaires, la documentation et les fragments de code, cliquer sur plusieurs fichiers... avant de trouver enfin la ligne de code que vous recherchiez.\n\n\nAvec la recherche exacte de code, le processus est le suivant : \n\n\n1. Vous copiez le message d'erreur exact. \n\n2. Vous le collez dans la fonctionnalité de recherche exacte de code en activant le mode de recherche par correspondance exacte.\n\n3. Vous trouvez instantanément l'emplacement précis où l'erreur est présente, avec le contexte environnant nécessaire à sa compréhension.\n\n\n**Impact :** vous réduisez ainsi le temps de débogage de plusieurs minutes à quelques secondes, sans frustration ni faux positifs.\n\n\n### Exploration rapide de codes sources inconnus\n\n\nVoici un exemple de workflow tel qu'il pouvait être envisagé avant que la recherche exacte de code ne soit disponible : vous deviez parcourir les répertoires, deviner l'emplacement probable des fichiers, ouvrir des dizaines de fichiers et élaborer peu à peu une compréhension globale du code source.\n\n\nAvec la recherche exacte de code, le processus est le suivant : \n\n\n* Vous recherchez directement les méthodes ou classes principales avec le mode de recherche par correspondance exacte.\n\n* Vous examinez plusieurs correspondances de lignes pour comprendre les détails de leur mise en œuvre.\n\n* Vous utilisez le mode de recherche par expression régulière pour identifier des motifs similaires dans l'ensemble du code source.\n\n\n**Impact :** vous bénéficiez d'une vision claire de l'architecture du code en quelques minutes plutôt qu'en quelques heures, ce qui accélère considérablement l'intégration de nouveaux membres au sein de l'équipe ainsi que la collaboration transversale.\n\n\n### Refactorisation sécurisée\n\n\nVoici un exemple de workflow tel qu'il pouvait être envisagé avant que la recherche exacte de code ne soit disponible : vous deviez localiser toutes les occurrences d'une méthode, mais certaines passaient inaperçues, et vous introduisiez des bogues en raison d'une refactorisation incomplète.\n\n\nAvec la recherche exacte de code, le processus est le suivant : \n\n\n* Vous utilisez le mode de recherche par correspondance exacte pour identifier toutes les occurrences de méthodes ou de variables.\n\n* Vous examinez le contexte pour comprendre les motifs d'utilisation.\n\n* Vous planifiez votre refactorisation avec des informations complètes sur son impact.\n\n  **Impact :** vous éliminez les bogues liés aux « occurrences manquées » qui entravent souvent les efforts de refactorisation, vous améliorez la qualité du code et vous réduisez les ajustements nécessaires.\n\n### Audit de sécurité optimisé\n\n\nLes équipes de sécurité peuvent :\n\n\n* Créer des motifs regex ciblant les portions de code présentant des vulnérabilités connues\n\n* Effectuer une recherche dans tous les dépôts d'un espace de nommage\n\n* Identifier rapidement les failles de sécurité potentielles avec un contexte facilitant l'évaluation des risques\n\n\n**Impact :** vous transformez vos audits de sécurité, souvent manuels et sujets aux erreurs, en revues systématiques et exhaustives.\n\n\n### Informations recoupées entre plusieurs dépôts\n\n\nVos équipes peuvent effectuer une recherche dans l'ensemble de votre espace de nommage ou de votre instance pour :\n\n\n* Identifier des implémentations similaires dans différents projets\n\n* Identifier des opportunités de création de bibliothèques partagées ou de standardisation du code\n\n\n**Impact :** vous éliminez les silos entre les projets et identifiez les opportunités de réutilisation et de standardisation du code.\n\n\n## Zoekt : rapidité et précision au service du code\n\n\nAvant de détailler nos réalisations à grande échelle, explorons ce qui distingue Zoekt des moteurs de recherche traditionnels, et pourquoi il peut trouver des correspondances exactes aussi rapidement.\n\n\n### Trigrammes positionnels : le secret d'une correspondance exacte ultra-rapide\n\n\nLa rapidité de Zoekt provient de son utilisation de **trigrammes positionnels**, une technique qui indexe chaque séquence de trois caractères en conservant leur position exacte dans les fichiers. Cette approche résout l'un des plus grands défis que les équipes de développement rencontrent avec la recherche de code basée sur Elasticsearch : les faux positifs.\n\n\nVoici le principe :\n\n\nLes **moteurs de recherche plein texte traditionnels** comme Elasticsearch segmentent le code en mots isolés et perdent ainsi les informations de position. Par exemple, lorsque vous recherchez `getUserId()`, ils peuvent renvoyer des résultats contenant les fragments **user**, **get** et **Id** dispersés dans un même fichier, ce qui génère des faux positifs, source de frustration pour les utilisateurs de GitLab.\n\n\nLes **trigrammes positionnels de Zoekt**, quant à eux, conservent les séquences de caractères exactes ainsi que leurs positions dans le code. Ainsi, lorsque vous recherchez `getUserId()`, Zoekt cible précisément les trigrammes exacts, comme **get**, **etU**, **tUs**, **Use**, **ser**, **erI**, **rId**, **Id(\", \"d()**, dans cette séquence précise et à ces positions exactes. Cette approche garantit que seules les correspondances exactes sont renvoyées.\n\n\nAinsi, des recherches qui renvoyaient auparavant des centaines de faux positifs ne renvoient désormais plus que les correspondances exactes souhaitées. Cette fonctionnalité était [l'une des plus demandées](https://gitlab.com/gitlab-org/gitlab/-/issues/325234) pour une bonne raison : les équipes de développement perdaient beaucoup trop de temps à passer au crible les faux positifs.\n\n\n### Performances des expressions régulières à grande échelle\n\n\nZoekt excelle dans la recherche de correspondances exactes, mais est également optimisé pour les recherches d'expressions régulières. Grâce à des algorithmes sophistiqués, il convertit les motifs regex en requêtes trigrammes efficaces lorsque cela est possible, garantissant ainsi une rapidité constante, même pour les recherches de motifs complexes portant sur plusieurs téraoctets de code.\n\n\n## Une fonctionnalité adaptée aux entreprises\n\n\nLa recherche exacte de code est puissante et conçue pour gérer de très grands volumes de code tout en offrant des temps de réponse remarquables. Il ne s'agit pas du simple ajout d'une nouvelle fonctionnalité à l'interface utilisateur, mais d'une architecture backend entièrement repensée.\n\n\n### Gestion de plusieurs téraoctets de code en toute simplicité\n\n\nRien que sur GitLab.com, notre infrastructure de recherche exacte de code indexe et interroge plus de **48 To** de données de code, tout en offrant des temps de réponse ultra-rapides. Cette volumétrie couvre des millions de dépôts répartis dans des milliers d'espaces de nommage, tous consultables en seulement quelques millisecondes, soit plus de code que l'ensemble des projets du noyau Linux, d'Android et de Chromium combinés. Et pourtant, la recherche exacte de code peut trouver une ligne spécifique dans l'ensemble du code source en quelques millisecondes seulement.\n\n\n### Architecture de nœuds à enregistrement automatique\n\n\nParmi nos améliorations techniques, voici quelques innovations clés : \n\n\n* **Enregistrement automatique des nœuds :** les nœuds Zoekt s'enregistrent automatiquement auprès de GitLab.\n\n* **Attribution dynamique des partitions :** le système attribue automatiquement les espaces de nommage entre les nœuds.\n\n* **Surveillance de l'état :** les nœuds qui ne s'enregistrent pas sont automatiquement signalés comme hors ligne.\n\n\nCette architecture à configuration automatique simplifie considérablement la montée en charge. Lorsque la capacité doit être augmentée, les administrateurs peuvent tout simplement ajouter de nouveaux nœuds, sans aucune reconfiguration complexe.\n\n\n### Système distribué avec répartition de charge intelligente\n\n\nEn arrière-plan, la recherche exacte de code repose sur un système distribué comprenant les composants clés suivants :\n\n\n* **Nœuds de recherche spécialisés :** serveurs dédiés pour gérer l'indexation et la recherche\n\n* **Partitionnement intelligent :** le code est réparti entre les nœuds en fonction des espaces de nommage\n\n* **Équilibrage automatique de la charge :** le système répartit intelligemment le travail en fonction des capacités disponibles\n\n* **Haute disponibilité :** plusieurs réplicas assurent la continuité du service même en cas de défaillance d'un nœud\n\n\n*Remarque : la haute disponibilité fait partie intégrante de l'architecture, mais n'est pas encore entièrement déployée. Consultez le [ticket 514736](https://gitlab.com/gitlab-org/gitlab/-/issues/514736) pour vous tenir au courant des futures mises à jour.*\n\n\n### Intégration sans accroc de la sécurité\n\n\nLa recherche exacte de code s'intègre automatiquement au système d'autorisation de GitLab :\n\n\n* Les résultats de recherche sont filtrés en fonction des droits d'accès de chaque utilisateur.\n\n* Seul le code des projets auxquels l'utilisateur a accès est affiché.\n\n* La sécurité est intégrée à l'architecture de base, et non ajoutée ultérieurement.\n\n\n### Performances optimisées\n\n\n* **Indexation performante :** les dépôts volumineux sont indexés en quelques dizaines de secondes.\n\n* **Exécution rapide des requêtes :** la plupart des recherches renvoient des résultats en moins d'une seconde.\n\n* **Résultats en streaming :** la nouvelle recherche fédérée basée sur gRPC diffuse les résultats au fur et à mesure de leur découverte.\n\n* **Arrêt anticipé :** dès qu'un nombre suffisant de résultats a été collecté, le système interrompt la recherche.\n\n\n## De la bibliothèque au système distribué : notre réponse aux défis d'ingénierie\n\n\nBien que Zoekt soit très performant pour indexer et rechercher du code localement, son architecture de base était conçue à l'origine comme une bibliothèque minimale, destinée à la gestion des fichiers d'index `.zoekt`, et non comme une base de données distribuée ou un service capable de fonctionner à l'échelle d'une entreprise. \n\n\nVoici les principaux défis techniques que nous avons dû surmonter pour l'adapter pleinement à l'écosystème GitLab.\n\n\n### Défi 1 : création d'une couche d'orchestration\n\n\n**Le problème :** Zoekt a été conçu pour fonctionner avec des fichiers d'index locaux, et non pour être distribué sur plusieurs nœuds desservant de nombreux utilisateurs simultanés.\n\n\n**Notre solution :** nous avons développé une couche d'orchestration complète qui :\n\n\n* crée et gère des modèles de base de données pour suivre les nœuds, les index, les dépôts et les tâches.\n\n* met en œuvre une architecture de nœuds à enregistrement automatique (inspirée du fonctionnement de GitLab Runner).\n\n* gère l'attribution automatique des partitions et l'équilibrage de la charge entre les nœuds.\n\n* fournit une communication bidirectionnelle de l'API entre les nœuds GitLab Rails et Zoekt.\n\n\n### Défi 2 : mise à l'échelle du stockage et de l'indexation\n\n\n**Le problème :** comment gérer efficacement des téraoctets de données d'indexation répartis sur plusieurs nœuds tout en garantissant des mises à jour rapides ?\n\n\n**Notre solution :** nous avons déployé les fonctionnalités suivantes  :\n\n\n* Partitionnement intelligent : les espaces de nommage sont répartis entre les nœuds en tenant compte de leur capacité et de leur charge.\n\n* Réplication indépendante : chaque nœud est indexé indépendamment à partir de [Gitaly](https://gitlab.com/gitlab-org/gitaly) (notre service de stockage Git), évitant ainsi toute synchronisation complexe.\n\n* Gestion avancée des filigranes : un système sophistiqué d'allocation de stockage empêche les nœuds de manquer d'espace.\n\n* Architecture binaire unifiée : un seul binaire `gitlab-zoekt` peut fonctionner à la fois en mode indexeur et en mode serveur web.\n\n\n### Défi 3 : intégration des autorisations\n\n\n**Le problème :** Zoekt n'avait aucune notion du système d'autorisation complexe de GitLab. Les utilisateurs ne doivent voir que les résultats des projets auxquels ils ont accès.\n\n\n**Notre solution :** nous avons intégré un filtrage des autorisations natif directement dans le flux de recherche :\n\n\n* Les requêtes de recherche incluent le contexte des autorisations de l'utilisateur.\n\n* Les résultats sont filtrés pour n’inclure que les éléments auxquels l'utilisateur peut accéder, même dans le cas où les autorisations évoluent avant la fin de l'indexation.\n\n\n### Défi 4 : simplification opérationnelle\n\n\n**Le problème :** gérer un système de recherche distribué ne devrait pas nécessiter une équipe dédiée.\n\n\n**Notre solution :**\n\n\n* Mise à l'échelle automatique : l'ajout de capacité est aussi simple que le déploiement de nœuds supplémentaires. Ces derniers s'enregistrent automatiquement et gèrent immédiatement la charge de travail.\n\n* Auto-réparation : les nœuds qui ne s'enregistrent pas sont automatiquement signalés comme hors ligne, avec redistribution automatique de leurs tâches.\n\n* Partitionnement sans configuration : le système détermine automatiquement les affectations de partitions optimales.\n\n\n## Déploiement progressif : réduire les risques à grande échelle\n\n\nLe déploiement d'un tout nouveau backend de recherche auprès de millions d'utilisateurs a nécessité une planification minutieuse. Voici comment nous avons limité l'impact sur les clients tout en garantissant la fiabilité :\n\n\n### Phase 1 : tests contrôlés (groupe gitlab-org)\n\n\nNous avons commencé par activer la recherche exacte de code uniquement pour le groupe `gitlab-org`, constitué de nos propres dépôts internes. \n\n\nCette étape nous a permis de :\n\n\n* Tester le système avec des charges de travail réelles en production\n\n* Identifier et corriger les goulots d'étranglement liés aux performances\n\n* Rationaliser le processus de déploiement\n\n* Tirer des enseignements concrets sur les workflows grâce aux retours d'utilisateurs\n\n\n### Phase 2 : validation et optimisation des performances\n\n\nAvant d'étendre la fonctionnalité, nous nous sommes assurés que le système pouvait gérer la charge à l'échelle de GitLab.com. Pour cela, nous avons dû :\n\n\n* Mettre en œuvre une surveillance et une gestion des alertes complètes\n\n* Valider la gestion du stockage basée sur la croissance réelle des données en production\n\n\n### Phase 3 : expansion progressive auprès des clients\n\n\nNous avons progressivement ouvert l'accès à la recherche exacte de code aux clients désireux de l'essayer, afin de :\n\n\n* Collecter leurs retours sur les performances et l'expérience utilisateur\n\n* Affiner l'interface utilisateur de recherche en fonction des workflows réels des utilisateurs\n\n* Optimiser les performances d'indexation (par exemple, les grands dépôts comme `gitlab-org/gitlab` sont désormais indexés en environ 10 secondes)\n\n* Ajuster l'architecture en fonction des leçons tirées des premiers essais\n\n* Augmenter massivement le débit d'indexation et améliorer le cycle de vie des transitions d'état\n\n\n### Phase 4 : déploiement à grande échelle\n\n\nAujourd'hui, plus de 99 % des groupes disposant des licences Premium et Ultimate sur GitLab.com ont accès à la recherche exacte de code. \n\n\nLes utilisateurs peuvent :\n\n\n* Basculer facilement entre les modes de recherche par expression régulière et par correspondance exacte\n\n* Tirer parti des avantages sans modifier la configuration\n\n* Revenir à l'ancienne méthode de recherche si nécessaire (bien que peu d'entre eux optent pour cette possibilité)\n\n\nCe déploiement progressif a permis d'éviter toute interruption de service, baisse de performances ou perte de fonctionnalités pendant la transition. Les premiers retours sont très positifs, car les utilisateurs constatent que leurs résultats de recherche sont plus pertinents et qu'ils les obtiennent beaucoup plus rapidement.\n\n\n> Vous souhaitez en savoir plus sur l'architecture et la mise en œuvre de la recherche exacte de code ? Consultez notre [document de conception](https://handbook.gitlab.com/handbook/engineering/architecture/design-documents/code_search_with_zoekt/) complet, qui offre une description technique détaillée de ce système de recherche distribué.\n\n\n## Premiers pas : comment lancer une recherche exacte de code ? \n\n\nLa prise en main de la recherche exacte de code est simple, car cette fonctionnalité est déjà activée par défaut pour les groupes Premium et Ultimate sur GitLab.com (accessibles aujourd'hui à plus de 99 % des groupes éligibles).\n\n\n### Guide de démarrage rapide\n\n\n1. Accédez à la recherche avancée depuis votre projet ou groupe GitLab.\n\n2. Saisissez votre terme de recherche dans l'onglet Code.\n\n3. Basculez entre les modes de recherche par correspondance exacte et par expression régulière.\n\n4. Utilisez des filtres pour affiner votre recherche.\n\n\n### Syntaxe de recherche de base\n\n\nQue vous utilisiez le mode de recherche par correspondance exacte ou par expression régulière, vous pouvez affiner votre recherche avec divers modificateurs :\n\n\n| Exemple de requête | Fonction                                                               |\n\n| ------------------ | ---------------------------------------------------------------------- |\n\n| `file:js`          | Recherche uniquement dans les fichiers dont le nom contient « js »     |\n\n| `foo -bar`         | Recherche « foo », mais exclut les résultats contenant « bar »         |\n\n| `lang:ruby`        | Recherche uniquement dans les fichiers Ruby                            |\n\n| `sym:process`      | Recherche « process » dans les symboles (méthodes, classes, variables) |\n\n\n> **Conseil :** pour optimiser votre recherche, commencez par une requête précise, puis élargissez-la si besoin. L'utilisation des filtres `file:` et `lang:` augmente considérablement la pertinence des résultats.\n\n\n### Techniques de recherche avancées\n\n\nCombinez plusieurs filtres pour gagner en précision :\n\n\n```\n\nis_expected file:rb -file:spec\n\n```\n\n\nCette requête recherche « is_expected » dans les fichiers Ruby dont le nom ne contient pas « spec ».\n\n\nTirez parti des expressions régulières pour obtenir des motifs puissants :\n\n\n```\n\ntoken.*=.*[\\\"']\n\n```\n\n\n[Consultez cette recherche effectuée dans le dépôt GitLab Zoekt.](https://gitlab.com/search?search=token.*%3D.*%5B%5C%22'%5D&nav_source=navbar&project_id=46649240&group_id=9970&search_code=true&repository_ref=main&regex=true)\n\n\nElle permet de trouver des mots de passe codés en dur qui, s'ils ne sont pas détectés, peuvent constituer un risque de sécurité.\n\n\nPour approfondir la syntaxe, consultez la [documentation dédiée à la recherche exacte de code](https://docs.gitlab.com/user/search/exact_code_search/#syntax).\n\n\n## Disponibilité et déploiement\n\n\n### Disponibilité actuelle\n\n\nLa recherche exacte de code est actuellement disponible en version bêta pour les utilisateurs de GitLab.com disposant de licences Premium et Ultimate :\n\n\n* Elle est accessible à plus de 99 % des groupes éligibles sous licence.\n\n* La recherche dans l'interface utilisateur utilise automatiquement Zoekt lorsqu'il est disponible ; la recherche exacte de code via l'API de recherche est activée par le biais d'un feature flag.\n\n\n### Options de déploiement pour les instances Self-Managed\n\n\nPour les instances Self-Managed, nous proposons plusieurs méthodes de déploiement :\n\n\n* Kubernetes/Helm : notre méthode la mieux prise en charge, basée sur notre [Helm Chart `gitlab-zoekt`](https://gitlab.com/gitlab-org/cloud-native/charts/gitlab-zoekt).\n\n* Autres méthodes : nous travaillons actuellement sur la simplification du déploiement via Omnibus et d'autres options d'installation.\n\n\nLes exigences en configuration système varient selon la taille de votre code source, mais l'architecture est conçue pour s'adapter horizontalement et/ou verticalement à mesure que vos besoins évoluent.\n\n\n## Prochaines étapes\n\n\nBien que la recherche exacte de code soit déjà performante, nous l'améliorons continuellement avec :\n\n\n* **Des optimisations à grande échelle** pour gérer des instances comptant des centaines de milliers de dépôts\n\n* **Des options de déploiement renforcées pour les instances Self-Managed**, y compris la prise en charge simplifiée d'Omnibus\n\n* **Une prise en charge complète de la haute disponibilité** avec basculement automatique et équilibrage de la charge\n\n\nRestez à l'écoute pour suivre les prochaines mises à jour lorsque nous passerons de la version bêta à la disponibilité générale.\n\n\n## Transformez votre façon de rechercher des lignes de code\n\n\nAvec la recherche exacte de code, GitLab repense en profondeur la manière dont le code est exploré, en fournissant des correspondances exactes, une prise en charge avancée des expressions régulières et des résultats contextuels. \n\n\nCette nouvelle fonctionnalité résout les aspects les plus frustrants de la recherche de code :\n\n\n* Ne perdez plus votre temps avec des résultats non pertinents.\n\n* Ne ratez plus aucune correspondance importante.\n\n* N'ouvrez plus plusieurs fichiers juste pour comprendre le contexte de base.\n\n* Ne subissez plus de problèmes de performances à mesure que la taille de vos dépôts de code augmente.\n\n\nL'impact s'étend même bien au-delà, à la productivité globale des équipes :\n\n\n* **Vos équipes collaborent plus efficacement** avec un référencement clair du code.\n\n* **Le partage des connaissances s'accélère** avec la détection facile des motifs.\n\n* **L'intégration des nouveaux membres d'équipe s'accélère** avec une compréhension rapide du code source.\n\n* **La sécurité est renforcée** avec un audit efficace des motifs.\n\n* **Une réduction de la dette technique** devient réellement envisageable.\n\n\nLa recherche exacte de code est plus qu'une simple fonctionnalité : elle vous permet de mieux comprendre et de gérer le code. Alors, arrêtez de chercher et commencez à trouver ! \n\n\n**Nous serions ravis de connaître votre avis.** Partagez vos expériences, vos questions ou vos commentaires sur la recherche exacte de code dans notre [ticket dédié aux retours d'expérience](https://gitlab.com/gitlab-org/gitlab/-/issues/420920). Vos retours nous aident à hiérarchiser nos priorités d'améliorations et à enrichir nos futures fonctionnalités.\n\n\n#### Vous souhaitez tirer parti d'une recherche de code plus intelligente ? Pour en savoir plus, consultez notre [documentation](https://docs.gitlab.com/ee/user/search/exact_code_search.html) et essayez dès aujourd'hui notre nouvelle fonctionnalité en effectuant une recherche dans vos espaces de nommage ou vos projets disposant d'une licence Premium ou Ultimate. Vous n'utilisez pas encore GitLab ? Inscrivez-vous pour un [essai gratuit de GitLab Ultimate enrichi des capacités de GitLab Duo](https://about.gitlab.com/fr-fr/free-trial/?hosted=saas) !\n",[749],"open source",{"featured":6,"template":684,"slug":751},"exact-code-search-find-code-faster-across-repositories","content:fr-fr:blog:exact-code-search-find-code-faster-across-repositories.yml","Exact Code Search Find Code Faster Across Repositories","fr-fr/blog/exact-code-search-find-code-faster-across-repositories.yml","fr-fr/blog/exact-code-search-find-code-faster-across-repositories",{"_path":757,"_dir":248,"_draft":6,"_partial":6,"_locale":7,"seo":758,"content":762,"config":769,"_id":771,"_type":16,"title":772,"_source":18,"_file":773,"_stem":774,"_extension":21},"/fr-fr/blog/ai-native-gitlab-premium-transform-higher-education-software-development",{"noIndex":6,"title":759,"ogTitle":759,"description":760,"ogDescription":760,"ogImage":761},"GitLab Premium et l’IA : au cœur de l'enseignement supérieur","La plateforme DevSecOps facilite les workflows, la protection des données, le support, la collaboration, la sécurité et la productivité au niveau universitaire.\n","https://res.cloudinary.com/about-gitlab-com/image/upload/f_auto,q_auto,w_820,h_500,c_lfill/v1749659537/Blog/Hero%20Images/display-article-image-0679-1800x945-fy26.png",{"title":759,"description":760,"authors":763,"heroImage":761,"date":766,"category":14,"tags":767,"body":768},[764,765],"Jessica Hurwitz","Elisabeth Burrows","2025-07-07",[552,14,705,188],"Les établissements d'enseignement supérieur s'appuient de plus en plus sur des pratiques modernes de développement logiciel dans leurs missions pédagogiques, leurs activités de recherche et la gestion de leurs infrastructures. Face à des besoins en développement logiciel de plus en plus complexes, GitLab Premium avec [GitLab Duo](https://about.gitlab.com/gitlab-duo/ \"Qu'est-ce que GitLab Duo ?\") fournit des fonctionnalités essentielles qui répondent aux défis spécifiques du secteur universitaire, notamment en matière de développement [open source](https://about.gitlab.com/fr-fr/blog/what-is-open-source/ \"Qu'est-ce que l'open source ?\"), de collaboration à distance et de sécurité globale.\n\nLa plateforme DevSecOps complète alimentée par l'IA de GitLab offre des fonctionnalités qui vont bien au-delà du simple [contrôle de version](https://about.gitlab.com/fr-fr/topics/version-control/ \"Qu'est-ce que le contrôle de version ?\"). Basée sur une architecture open source et dotée de fonctionnalités avancées, GitLab Premium permet de prévenir les incidents de sécurité coûteux impliquant des données sensibles d'étudiants, propose des environnements de développement cloud accessibles aux équipes situées à différents emplacements géographiques et offre une assistance professionnelle adaptée aux systèmes critiques des établissements d'enseignement. [GitLab Premium inclut à présent le chat et les suggestions de code, des fonctionnalités d'IA clés de GitLab Duo](https://about.gitlab.com/fr-fr/blog/gitlab-premium-with-duo/), et ce sans frais supplémentaires.\n\n## Les particularités du développement logiciel dans l'enseignement supérieur\n\nLes universités et les établissements d'enseignement supérieur opèrent dans un environnement technique particulièrement complexe. Les équipes de développement doivent faciliter une collaboration multidisciplinaire entre les services techniques et non techniques, tout en gérant de grandes quantités de données sensibles (dossiers des étudiants, informations financières, résultats de recherche, évaluations des professeurs).\n\nLa plupart des établissements doivent travailler avec des ressources informatiques limitées et prendre en charge simultanément des milliers d'utilisateurs participant à un grand nombre de projets et d'initiatives de recherche. L'intégrité exigée dans le cadre de la recherche ajoute un niveau supplémentaire de complexité, car le travail de développement doit souvent adhérer à des normes de traçabilité et de reproductibilité.\n\n## Les fonctionnalités de GitLab Premium pour l'éducation\n\nGitLab Premium avec GitLab Duo offre les fonctionnalités dont l'enseignement supérieur a besoin.\n\n### Amélioration de la collaboration et capacités de workflow\n\nLes projets qui impliquent différents services sont courants dans le secteur universitaire, qu'il s'agisse d'initiatives de recherche interdisciplinaire ou du développement de modules personnalisés pour des systèmes d'ERP. Ces projets complexes nécessitent une gestion sophistiquée des workflows qui ne se limite pas uniquement au simple contrôle de version.\n\nGitLab Premium répond à ces défis en offrant des fonctionnalités de collaboration et de visualisation de projet, notamment des epics, des roadmaps et des tableaux Kanban avancés pour les workflows de développement Agile. En attribuant plusieurs approbateurs à certaines merge requests et branches protégées, vous garantissez une meilleure qualité du code et une plus grande responsabilisation des équipes. Ces outils permettent aux établissements de coordonner les travaux entre les différents services, tout en s'assurant que ces efforts sont alignés sur les objectifs globaux de l'institution. Il s'agit d'une condition essentielle pour gérer efficacement des initiatives technologiques qui se déroulent en plusieurs étapes à l'échelle du campus.\n\nEn Australie, l'équipe Digital Enablement de l'Université Deakin utilise GitLab pour créer des processus standardisés et des templates réutilisables (templates de merge request personnalisés, pipelines de compilation basés sur un template, framework de sécurité et de conformité) qu'elle partage avec la communauté universitaire et les développeurs citoyens. Cette approche favorise l'innovation et renforce la collaboration à la fois au sein de l'université et avec ses partenaires stratégiques. « Nous voulions depuis longtemps créer une communauté et l'aider à se développer, mais sans succès, jusqu'à l'adoption de cet outil », confie Aaron Whitehand, Director of Digital Enablement à l'Université Deakin.\n\n**Découvrez comment l'[Université Deakin](https://about.gitlab.com/customers/deakin-university/) utilise GitLab pour renforcer la collaboration et la productivité, notamment grâce à une réduction de 60 % des tâches manuelles.**\n\n### Protection et gouvernance avancées des données\n\nLes établissements d'enseignement génèrent et gèrent des quantités considérables de données (dossiers des étudiants, informations financières, résultats de recherche, évaluations des professeurs, et bien plus encore). La sécurité de ces informations est un enjeu majeur. La [faille de sécurité MOVEit](https://universitybusiness.com/in-just-3-months-this-data-breach-has-compromised-nearly-900-institutions/) de 2023, qui a duré trois mois et compromis environ 900 établissements d'enseignement, a exposé les informations sensibles de plus de 62 millions de personnes. Cet exemple illustre l'importance cruciale d'intégrer des mesures de sécurité proactives directement dans les workflows de développement dans ce secteur.\n\nLe scanning des vulnérabilités bloque les sorties de nouvelles versions de code qui contiennent des risques de sécurité afin de permettre aux établissements de mettre en place et de faire respecter des protocoles de gouvernance qui protègent ces données sensibles. Cette fonctionnalité aide les universités à mettre en œuvre des contrôles d'accès et des structures d'autorisation adaptés aux bases de données de recherche. Ce framework sécurisé garantit que seuls les chercheurs autorisés disposent des droits d'accès nécessaires et assure une protection stricte sans entraver la collaboration entre les différentes équipes.\n\nLa plateforme de GitLab est conçue dès le départ pour garantir la sécurité de votre code source. Les dépôts [Git](https://about.gitlab.com/fr-fr/blog/what-is-git/ \"Qu'est-ce que Git ?\") évolutifs, des contrôles d'accès granulaires et des fonctionnalités de conformité intégrées éliminent les goulots d'étranglement dans votre workflow tout en répondant aux exigences de sécurité. GitLab Premium fournit des fonctionnalités de suivi des audits et de conformité essentielles, particulièrement adaptés aux environnements éducatifs. Les pistes d'audit complètes consignent sous forme de logs l'ensemble des modifications apportées au code, les tentatives d'accès et les modifications du système, en incluant les horodatages ainsi que les utilisateurs concernés. La documentation exhaustive sur la gestion des modifications garantit une traçabilité optimale (auteur, date et motif), essentielle pour garantir l'intégrité de la recherche. Quant à l'audit du contrôle d'accès, il permet de surveiller l'accès au dépôt et les changements d'autorisations.\n\n### Développement cloud et collaboration à distance\n\nLes établissements d'enseignement modernes requièrent des environnements de développement flexibles, adaptés aux besoins des équipes situées à différents emplacements géographiques, aux scénarios d'apprentissage à distance et aux diverses exigences techniques. \n\nGitLab Premium offre donc les avantages suivants :\n\n* [Workspaces GitLab](https://docs.gitlab.com/user/workspace/) : environnements de développement cloud accessibles depuis n'importe quel appareil\n* [Intégration au Web IDE](https://docs.gitlab.com/user/project/web_ide/) : codage basé sur le navigateur avec une intégration complète des fonctionnalités de GitLab\n* [Développement conteneurisé](https://about.gitlab.com/blog/build-and-run-containers-in-remote-development-workspaces/) : environnements de développement cohérents et reproductibles, quelle que soit la nature du projet ou le groupe d'utilisateurs\n\nCes fonctionnalités sont particulièrement utiles pour prendre en charge les modèles d'apprentissage à distance et hybrides. Elles permettent aux étudiants et aux chercheurs d'accéder à des environnements de développement standardisés, indépendamment de leur emplacement physique ou des contraintes matérielles locales.\n\n### Assistance professionnelle pour les systèmes critiques\n\nLes petites équipes informatiques des établissements d'enseignement prennent souvent en charge des infrastructures importantes et complexes avec des ressources minimales. Elles doivent parfois s'appuyer sur des forums communautaires, mais la fiabilité des réponses n'est pas toujours garantie. Par ailleurs, cette approche n'est pas efficace pour les structures de grande envergure. C'est pourquoi GitLab Premium inclut une assistance professionnelle dédiée, qui permet de résoudre les problèmes plus rapidement et d'obtenir de l'aide pour les mises à niveau pendant les périodes critiques, telles que les inscriptions aux cours ou les échéances de recherche.\n\nCette assistance réduit au maximum les temps d'arrêt des services critiques et garantit la continuité des opérations pendant les périodes de pointe, ce qui donne aux services informatiques surchargés la fiabilité dont ils ont besoin pour les systèmes essentiels.\n\n### Architecture open source, performances d'entreprise\n\nLes logiciels open source sont développés de manière collaborative et publique, le code source pouvant être librement consulté, modifié et distribué par tous. Ce modèle de développement favorise l'innovation grâce aux contributions de la communauté et garantit un fonctionnement homogène des logiciels. La base open source de GitLab est en parfaite adéquation avec les valeurs fondamentales des établissements d'enseignement en matière de collaboration, de transparence et de contribution communautaire. Les fonctionnalités de GitLab Premium enrichissent cette base avec des capacités de niveau entreprise et offrent parallèlement la possibilité de contribuer à l'écosystème open source.\n\nVoici les principaux avantages de l'open source :\n\n* **Une transparence totale** : visibilité complète sur les fonctionnalités de la plateforme et les mesures de sécurité. Vous savez précisément comment le logiciel fonctionne.\n* **Une contribution de la communauté** : possibilité de contribuer à améliorer l'outil au bénéfice de la communauté au sens large et de profiter de l'expertise d'une communauté mondiale de développeurs et développeuses. \n* **Une indépendance vis-à-vis des fournisseurs** : réduction du risque de blocage avec des alternatives open source et liberté de modifier le code au besoin.\n* **Des opportunités de co-création** : développement collaboratif avec la communauté, y compris d'autres établissements universitaires, pour concevoir des solutions partagées.\n\n### Assistant d’IA dédié au développement logiciel\n\nGitLab Premium avec GitLab Duo intègre de puissantes capacités d'IA directement dans le workflow de développement, avec notamment :\n\n* Les [suggestions de code](https://docs.gitlab.com/user/project/repository/code_suggestions/ \"suggestions de code GitLab\"), qui fournissent une complétion et des suggestions de code en temps réel, pour aider les équipes de développement à écrire du code plus rapidement et plus efficacement.\n* Le [chat](https://docs.gitlab.com/user/gitlab_duo_chat/ \"GitLab Duo Chat\"), qui permet d'obtenir des réponses instantanées aux questions posées, de résoudre les problèmes et d'accéder à la documentation directement dans l'environnement GitLab.\n\nCes outils d'IA améliorent considérablement la productivité, réduisent les erreurs et renforcent la collaboration. C'est précisément la raison pour laquelle GitLab Premium est un atout encore plus précieux pour les équipes de développement logiciel dans l'enseignement supérieur.\n\n### La transparence comme principe fondateur\n\nLes établissements d'enseignement supérieur traitent des données particulièrement sensibles, qu’il s’agisse de dossiers étudiants, de résultats de recherche, de travaux universitaires confidentiels ou d'informations liées à des financements publics.\n\nLe [Centre pour la transparence de l'IA de GitLab](https://about.gitlab.com/fr-fr/ai-transparency-center/ \"Centre de transparence de l'IA de GitLab\") démontre notre engagement en faveur de la transparence, de la responsabilisation, de la protection des données et de la propriété intellectuelle des clients et fournit les garanties de confidentialité dont les établissements d'enseignement ont besoin.\n\nNous avons lancé ce centre afin d'aider nos clients, notre communauté et nos équipes à mieux comprendre comment GitLab applique les principes d'éthique et de transparence dans ses fonctionnalités alimentées par l'IA.\n\nNotre documentation publique détaille l'ensemble des mesures mises en place pour protéger les données et la propriété intellectuelle de votre établissement. Les [principes d'éthique IA pour le développement de produits de GitLab](https://handbook.gitlab.com/handbook/legal/ethics-compliance-program/ai-ethics-principles/) nous guident dans la création et l'amélioration de nos fonctionnalités d'IA, afin d'aider les établissements d'enseignement supérieur à tirer parti des promesses de l'IA, tout en conservant un contrôle total et une surveillance complète de leurs actifs les plus précieux.\n\n## Découvrez GitLab Premium dès aujourd'hui\n\nPour les établissements d'enseignement, GitLab Premium avec GitLab Duo représente un investissement technologique stratégique, qui combine les avantages du développement open source avec des fonctionnalités d'IA native de niveau entreprise. En fournissant des outils de qualité professionnelle prêts à relever les défis propres à l'environnement technique complexe de l'enseignement supérieur, GitLab Premium avec GitLab Duo aide les établissements à corriger les failles de sécurité, à rationaliser les workflows de développement et à maintenir une infrastructure fiable dont dépendent les opérations universitaires et de recherche.\n\nDécouvrez [GitLab pour le secteur public](https://about.gitlab.com/fr-fr/solutions/public-sector/ \"GitLab pour le secteur public\") ou [contactez notre équipe commerciale](https://about.gitlab.com/fr-fr/sales/ \"Contacter les équipes de GitLab\") dès aujourd'hui.",{"featured":6,"template":684,"slug":770},"ai-native-gitlab-premium-transform-higher-education-software-development","content:fr-fr:blog:ai-native-gitlab-premium-transform-higher-education-software-development.yml","Ai Native Gitlab Premium Transform Higher Education Software Development","fr-fr/blog/ai-native-gitlab-premium-transform-higher-education-software-development.yml","fr-fr/blog/ai-native-gitlab-premium-transform-higher-education-software-development",{"_path":776,"_dir":248,"_draft":6,"_partial":6,"_locale":7,"seo":777,"content":780,"config":787,"_id":789,"_type":16,"title":790,"_source":18,"_file":791,"_stem":792,"_extension":21},"/fr-fr/blog/ci-cd-inputs-secure-and-preferred-method-to-pass-parameters-to-a-pipeline",{"noIndex":6,"title":778,"description":779},"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":781,"body":782,"authors":783,"updatedDate":785,"date":766,"title":778,"tags":786,"description":779,"category":14},"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",[784],"Dov Hershkovitch","2025-08-07",[110],{"featured":6,"template":684,"slug":788},"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":794,"_dir":248,"_draft":6,"_partial":6,"_locale":7,"seo":795,"content":798,"config":809,"_id":811,"_type":16,"title":812,"_source":18,"_file":813,"_stem":814,"_extension":21},"/fr-fr/blog/gitlab-ultimate-for-ibm-z-modern-devsecops-for-mainframes",{"noIndex":6,"description":796,"title":797},"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":799,"body":800,"authors":801,"updatedDate":804,"date":805,"title":806,"tags":807,"description":808,"category":14},"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/).",[802,803],"Mike Flouton","Andy Bradfield","2025-06-30","2025-06-20","GitLab Ultimate pour IBM Z : le DevSecOps moderne sur mainframe",[286,14,110,704],"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":92,"template":684,"slug":810},"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":816,"_dir":248,"_draft":6,"_partial":6,"_locale":7,"seo":817,"content":823,"config":832,"_id":834,"_type":16,"title":835,"_source":18,"_file":836,"_stem":837,"_extension":21},"/fr-fr/blog/gitlab-named-a-leader-in-the-forrester-wave-devops-platforms-q2-2025",{"title":818,"description":819,"ogTitle":818,"ogDescription":819,"noIndex":6,"ogImage":820,"ogUrl":821,"ogSiteName":719,"ogType":720,"canonicalUrls":821,"schema":822},"GitLab nommée Leader dans le rapport The Forrester Wave™: DevOps Platforms (T2 2025)","Téléchargez le rapport The Forrester Wave™: DevOps Platforms (T2 2025) et découvrez pourquoi la plateforme GitLab a été nommée Leader.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749658898/Blog/Hero%20Images/blog-post-image-forrester-wave-1800x945px-fy26.png","https://about.gitlab.com/blog/gitlab-named-a-leader-in-the-forrester-wave-devops-platforms-q2-2025","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"GitLab nommée Leader dans le rapport The Forrester Wave™: DevOps Platforms (T2 2025)\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Dave Steer\"}],\n        \"datePublished\": \"2025-06-02\",\n      }\n                  ",{"title":818,"description":819,"authors":824,"heroImage":820,"date":826,"body":827,"category":14,"tags":828,"updatedDate":831},[825],"Dave Steer","2025-06-02","Le choix d'une plateforme [DevSecOps](https://about.gitlab.com/fr-fr/topics/devsecops/ \"Qu'est-ce que l'approche DevSecOps ? \") est l'une des décisions technologiques les plus stratégiques pour une entreprise. C'est pourquoi nous sommes particulièrement fiers d'annoncer que GitLab a été nommée [**Leader dans le rapport The Forrester Wave™: DevOps Platforms, T2 2025**](https://about.gitlab.com/forrester-wave-devops-platform/). Notre plateforme a obtenu les meilleurs scores pour les critères qui comptent le plus aux yeux de nos clients, notamment l'expérience zero-day, les outils de développement, l'automatisation de la compilation, l'intégration continue, l'automatisation du déploiement, ainsi que l'atténuation des risques liés à l'IA, l'injection d'IA, les outils de sécurité directement intégrés et la cohésion au sein de la plateforme.\n\n***« GitLab est la solution tout-en-un la plus complète. Elle s'adresse aux entreprises qui cherchent à standardiser leurs processus avec un seul achat. » -*** Rapport The Forrester Wave™ dédié aux plateformes DevOps, T2 2025\n\nCette reconnaissance vient renforcer notre conviction : les équipes de développement logiciel doivent livrer des logiciels sécurisés, plus rapidement, sans sacrifier ni la rapidité, ni la sécurité, ni la simplicité, alors que d'autres plateformes imposent ce compromis. GitLab unifie les enjeux de rapidité, de fiabilité et de gouvernance. Avec la [version 18.0 de GitLab](https://about.gitlab.com/releases/2025/05/15/gitlab-18-0-released/) sortie en mai, nous franchissons une nouvelle étape en intégrant les [fonctionnalités basées sur l'IA native de GitLab Duo](https://about.gitlab.com/fr-fr/blog/gitlab-premium-with-duo/), sans frais supplémentaires. Avec GitLab Duo, nos clients bénéficient de fonctionnalités avancées, telles que la génération de tests, les suggestions de code et la refactorisation du code, directement dans GitLab Premium et GitLab Ultimate. \n\n> [Consultez le rapport Forrester dès aujourd'hui !](https://about.gitlab.com/forrester-wave-devops-platform/)\n\n![ Graphique issu du rapport The Forrester Wave™ dédié aux plateformes DevOps, T2 2025](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749673518/Blog/Content%20Images/Image_DevOps-Platforms-Q2-2025.png)\n\n## Une IA de pointe, sans compromis sur la sécurité\n\nLes principes de l'approche DevSecOps évoluent rapidement, et l'IA est au cœur de cette transformation. Malheureusement, de nombreux outils alimentés par l'IA imposent de choisir entre des fonctionnalités de pointe et la sécurité à l'échelle de l'entreprise. \n\nForrester a attribué à GitLab la note maximale de 5 pour 2 critères clés : l'**injection d'IA** et l'**atténuation des risques liés à l'IA**. Nous sommes fiers que notre engagement à créer des fonctionnalités d'IA innovantes qui renforcent la sécurité soit remarqué non seulement par nos clients, mais également par d'autres parties prenantes.\n\nCes deux critères se reflètent dans nos offres d'IA GitLab Duo, notamment :\n\n* **Duo Workflow (bêta privée)** : des agents d'IA autonomes capables de gérer des tâches DevSecOps complexes, avec l'implémentation de garde-fous adaptés au secteur d'activité concerné et de pistes d'audit.  \n* **Agentic Chat** : une IA contextuelle et conversationnelle adaptée à toutes les étapes du cycle de développement, des explications de code à la création de tests, avec une protection de la propriété intellectuelle et des contrôles de confidentialité intégrés.  \n* **Suggestions de code** : génération prédictive de blocs de code, définition d'une logique fonctionnelle, génération de tests et suggestion d'un code commun comme des motifs regex.  \n* **Résolution de vulnérabilités intégrant l'IA native** : détection, explication et correction automatiques des vulnérabilités, avec des merge requests générées automatiquement, qui simplifient le processus de développement.\n\n## En finir avec la multiplication des outils \n\nLes équipes DevSecOps ne veulent plus jongler entre plusieurs outils disparates et des intégrations qui les aident seulement pour une partie de leur cycle de développement logiciel. Elles ont besoin d'une expérience de développement fluide, intégrée et cohérente de bout en bout.\n\nLes scores de GitLab dans les critères suivants valident notre stratégie centrée sur le client :\n\n* **Expérience zero-day :** Forrester a cité notre « forte expérience zero-day », en notant que « la plateforme est opérationnelle immédiatement », grâce notamment aux nombreux outils de migration et tutoriels complets mis à disposition. \n* **Outils de développement :** Forrester a cité [GitLab Duo combiné à Amazon Q](https://about.gitlab.com/fr-fr/blog/gitlab-duo-with-amazon-q-agentic-ai-optimized-for-aws/), notre offre d'IA agentique destinée aux clients AWS, ainsi que notre environnement de développement cloud, notre plateforme de développement intégrée et nos wikis de documentation.  \n* **Planification et alignement des projets :** Forrester a noté la « robustesse de notre centre de conformité » et le fait que nous disposons d'outils pour favoriser une approche à la fois descendante et ascendante.  \n* **Sécurité des pipelines :** Forrester nous a attribué la note maximale pour ce critère.  \n* **Automatisation des compilations et intégration continue (CI) :** Forrester a cité notre automatisation des compilations et nos fonctionnalités d'intégration continue avec des pipelines de compilation en plusieurs étapes et une solide prise en charge des modèles auto-hébergés.\n\n## Téléchargez notre rapport\n\nLe fait que GitLab soit nommée Leader dans le rapport The Forrester Wave™: DevOps Platforms (T2 2025) témoigne de l'étendue et de la profondeur des fonctionnalités de notre plateforme, qui fournit une source unique de vérité pour l'ensemble du cycle de développement logiciel. Plus besoin de jongler avec plusieurs outils et multiples intégrations : GitLab offre une expérience fluide et intégrée qui augmente la productivité et réduit les points de friction. Cette distinction reflète le travail assidu de nos équipes, les nombreuses contributions de notre communauté [open source](https://about.gitlab.com/fr-fr/blog/what-is-open-source/ \"Qu'est-ce que l'open source ? \"), les précieux retours de nos clients et notre engagement constant à façonner l'avenir du développement logiciel.\n\n> #### [Téléchargez le rapport dès aujourd'hui !](https://about.gitlab.com/forrester-wave-devops-platform/)\n\n*Forrester ne cautionne aucune entreprise, aucun produit, aucune marque ou aucun service inclus dans ses publications de recherche et ne conseille à quiconque de sélectionner les produits ou services d'une entreprise ou d'une marque en fonction des notes attribuées. Les informations se fondent sur les meilleures ressources disponibles. Les opinions reflètent notre jugement du moment et peuvent évoluer. Pour en savoir plus, découvrez les [critères d'objectivité de Forrester](https://www.forrester.com/about-us/objectivity/).*",[829,14,681,830],"research","DevSecOps platform","2025-06-10",{"slug":833,"featured":92,"template":684},"gitlab-named-a-leader-in-the-forrester-wave-devops-platforms-q2-2025","content:fr-fr:blog:gitlab-named-a-leader-in-the-forrester-wave-devops-platforms-q2-2025.yml","Gitlab Named A Leader In The Forrester Wave Devops Platforms Q2 2025","fr-fr/blog/gitlab-named-a-leader-in-the-forrester-wave-devops-platforms-q2-2025.yml","fr-fr/blog/gitlab-named-a-leader-in-the-forrester-wave-devops-platforms-q2-2025",{"_path":839,"_dir":248,"_draft":6,"_partial":6,"_locale":7,"seo":840,"content":846,"config":855,"_id":857,"_type":16,"title":858,"_source":18,"_file":859,"_stem":860,"_extension":21},"/fr-fr/blog/getting-started-with-gitlab-working-with-ci-cd-variables",{"ogTitle":841,"schema":842,"ogImage":843,"ogDescription":844,"ogSiteName":719,"noIndex":6,"ogType":720,"ogUrl":845,"title":841,"canonicalUrls":845,"description":844},"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","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749659525/Blog/Hero%20Images/blog-getting-started-with-gitlab-banner-0497-option4-fy25.png","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":843,"body":847,"authors":848,"date":850,"title":841,"tags":851,"description":844,"category":14,"updatedDate":831},"*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/)",[849],"GitLab Team","2025-05-27",[14,852,853,854,110,705],"tutorial","CI","CD",{"slug":856,"featured":92,"template":684},"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":862,"_dir":248,"_draft":6,"_partial":6,"_locale":7,"seo":863,"content":869,"config":877,"_id":879,"_type":16,"title":880,"_source":18,"_file":881,"_stem":882,"_extension":21},"/fr-fr/blog/gitlab-premium-with-duo",{"title":864,"description":865,"ogTitle":864,"ogDescription":865,"noIndex":6,"ogImage":866,"ogUrl":867,"ogSiteName":719,"ogType":720,"canonicalUrls":867,"schema":868},"L'IA à la portée de tous les clients GitLab Premium et Ultimate","GitLab Premium et GitLab Ultimate incluent désormais, sans surcoût, les fonctionnalités essentielles de GitLab Duo.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749660188/Blog/Hero%20Images/blog-premium-with-duo-cover-0756-fy26-v2-1800x945.png","https://about.gitlab.com/blog/gitlab-premium-with-duo","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"L'IA à la portée de tous les clients GitLab Premium et Ultimate\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"David DeSanto, Chief Product Officer, GitLab\"}],\n        \"datePublished\": \"2025-05-15\",\n      }",{"title":864,"description":865,"authors":870,"heroImage":866,"date":872,"body":873,"category":14,"tags":874,"updatedDate":876},[871],"David DeSanto, Chief Product Officer, GitLab","2025-05-15","À l’occasion du lancement de GitLab 18.0, nous présentons nos dernières innovations en matière de workflows [DevSecOps](https://about.gitlab.com/fr-fr/topics/devsecops/ \"Qu'est-ce que l'approche DevSecOps ? \"), de sécurité et de conformité, ainsi que d'IA. __Cette nouvelle version marque une étape importante : GitLab Premium et GitLab Ultimate intègrent désormais, sans frais supplémentaires, les capacités d'IA essentielles de GitLab Duo.__ Tous les utilisateurs des éditions Premium et Ultimate bénéficient d'un accès immédiat aux fonctionnalités de chat et de suggestions de code de GitLab Duo, directement dans leurs éditeurs de code source et IDE préférés.\n\n## L'IA au service des équipes de développement\n\nL'intelligence artificielle occupe désormais une place centrale dans le quotidien des équipes de développement. Elle optimise l'écriture de code en analysant le code base en temps réel, en proposant des suggestions au fil de la saisie, en générant des fonctions et méthodes adaptées au contexte du projet, en automatisant les tâches répétitives et en simplifiant les revues de code.\n\nDepuis plusieurs années, nous développons [GitLab Duo](https://about.gitlab.com/fr-fr/gitlab-duo/) pour intégrer ces capacités d'IA générative et agentique à notre plateforme, car l'écriture du code ne représente qu'une partie du cycle de développement logiciel : notre [Rapport Global DevSecOps](https://about.gitlab.com/fr-fr/developer-survey/) révèle en effet que les développeurs consacrent 79 % de leur temps à des tâches autres que la création de code. Nous avons donc fait le choix d'intégrer l'IA à chaque étape du cycle de développement logiciel. \n\nNous franchissons aujourd'hui un nouveau cap en incluant les fonctionnalités clés de GitLab Duo dans nos éditions GitLab Premium et GitLab Ultimate, afin que chaque développeur et développeuse puisse bénéficier des avantages de l'IA, sans frais supplémentaires.\n\nEn effet, en intégrant les fonctionnalités de chat et de suggestions de code de GitLab Duo aux éditions GitLab Premium et Ultimate, les ingénieurs logiciels peuvent accélérer leur workflow au sein même de l'IDE, sans devoir installer d'autres outils, gérer des licences distinctes ou se soucier de la gouvernance. Il suffit aux clients Premium et Ultimate existants de passer à GitLab 18.0 pour bénéficier d'un accès instantané à ces fonctionnalités. Elles seront également disponibles pour tous les nouveaux clients.\n\n> **« GitLab a déjà joué un rôle déterminant en nous aidant à nous affranchir d'une chaîne d'outils fragmentée, ce qui a permis de réduire les coûts liés à des solutions disparates et de rationaliser notre workflow. L'ajout de GitLab Duo à GitLab Premium nous permettra d'optimiser notre productivité et de réaliser encore plus d'économies, car nos développeurs consacreront moins de temps aux tâches de codage répétitives et plus de temps à la résolution de défis complexes qui génèrent une valeur métier réelle. »**\n>\n>- Andrei Nita, Chief Technology Officer chez McKenzie Intelligence Services\n\n\u003Cdiv style=\"padding:56.25% 0 0 0;position:relative;\">\u003Ciframe src=\"https://player.vimeo.com/video/1083723619?badge=0&autopause=0&player_id=0&app_id=58479\" frameborder=\"0\" allow=\"autoplay; fullscreen; picture-in-picture; clipboard-write; encrypted-media\" style=\"position:absolute;top:0;left:0;width:100%;height:100%;\" title=\"GitLab Premium with Duo Core\">\u003C/iframe>\u003C/div>\u003Cscript src=\"https://player.vimeo.com/api/player.js\">\u003C/script>\n\n\u003Cbr>\u003C/br>\nLes clients Premium et Ultimate bénéficient désormais des capacités d'IA natives suivantes :\n\n#### Suggestions de code de GitLab Duo\n\n* Génération de fonctions complètes et de blocs de code à partir de commentaires  \n* Complétion de code intelligente au fil de la saisie  \n* Prise en charge de plus de 20 langages de programmation  \n* Intégration aux IDE les plus populaires\n\nDécouvrez la fonctionnalité de suggestions de code de GitLab Duo dans cette présentation interactive (cliquez sur l'image pour démarrer la présentation).\n\n\u003Ca href=\"https://gitlab.navattic.com/code-suggestions\">\u003Cimg src=\"https://res.cloudinary.com/about-gitlab-com/image/upload/v1752175911/Blog/b5gdnls7jdyrpeyjby5j.png\" alt=\"GitLab Duo Code Suggestions cover image\">\u003C/a>\n\nConsultez notre [documentation sur les suggestions de code de GitLab Duo]( https://docs.gitlab.com/user/project/repository/code_suggestions/ ) pour en savoir plus.\n\n#### GitLab Duo Chat\n\n* Explication de code pour faciliter la compréhension des fonctions complexes  \n* Refactorisation du code existant pour améliorer sa qualité et sa maintenabilité  \n* Génération de scénarios de test complets pour vous aider à détecter les bugs dès les premières étapes du développement  \n* Correction des anomalies directement dans votre workflow\n\n![GitLab Duo Chat : explication du point de terminaison de l'API](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749673912/Blog/Content%20Images/Duo_Chat_-_gif_-_API_endpoint_explanation__3_.gif)\n\nPour en savoir plus, consultez notre [documentation sur GitLab Duo Chat](https://docs.gitlab.com/user/gitlab_duo_chat/).\n\n> **« Pour nous, en tant qu'utilisateurs de GitLab, les suggestions de code intelligentes de GitLab Duo sont devenues un atout quotidien pour nos développeurs. Combinées à la fonctionnalité de chat, elles permettent d'effectuer des itérations rapides, avec un retour immédiat, pour des cycles de développement plus fluides et un code plus sécurisé. Elles constituent une intégration à la fois fluide et puissante à nos workflows. »**\n>\n>- Felix Kortmann, Chief Technology Officer, Ignite by FORVIA HELLA\n\n## GitLab Duo Enterprise disponible pour les clients GitLab Premium\n\nFace à une forte demande, nous avons le plaisir d'annoncer que les clients [GitLab Premium](https://about.gitlab.com/fr-fr/pricing/premium/) peuvent désormais acheter une licence GitLab Duo Enterprise, notre suite complète de solutions d'IA, sans avoir à passer à GitLab Ultimate. Ils bénéficient ainsi d'une expérience d'IA exceptionnelle, avec des fonctionnalités avancées parfaitement intégrées à chaque étape du développement logiciel :\n\n* [L'analyse des causes profondes](https://docs.gitlab.com/user/gitlab_duo/use_cases/#root-cause-analysis-use-cases) pour diagnostiquer et résoudre rapidement les [échecs de pipelines CI/CD](https://about.gitlab.com/fr-fr/blog/quickly-resolve-broken-ci-cd-pipelines-with-ai/ \"Échecs de pipelines CI/CD\") et veiller à leur bon fonctionnement. \n\n* [La revue de code](https://docs.gitlab.com/user/project/merge_requests/duo_in_merge_requests/#have-gitlab-duo-review-your-code) qui utilise GitLab Duo comme relecteur pour accélérer la révision des modifications proposées dans une merge request.\n\n* [Le chat avancé](https://docs.gitlab.com/user/gitlab_duo_chat/) pour résumer les conversations. Il aide à comprendre les modifications apportées au code et fournit une assistance avancée pour la configuration.  \n\n* [GitLab Duo Self-Hosted](https://docs.gitlab.com/administration/gitlab_duo_self_hosted/) pour déployer GitLab Duo dans des environnements air-gapped et hors ligne en hébergeant des modèles d'IA approuvés.\n\nAu-delà de la disponibilité de GitLab Duo Enterprise, nous renforçons en continu notre engagement auprès des clients GitLab Premium. Depuis le lancement de GitLab 17, [nous avons déployé plus d'une centaine de nouvelles fonctionnalités et d'améliorations](https://gitlab.com/gitlab-org/gitlab/-/releases), dont voici quelques exemples notables : \n\n* Le [**catalogue CI/CD**](https://about.gitlab.com/blog/ci-cd-catalog-goes-ga-no-more-building-pipelines-from-scratch/) permet aux équipes de développement de partager, découvrir et réutiliser   \ndes configurations et des composants CI/CD préexistants.  \n* [**Le registre des artefacts**](https://docs.gitlab.com/user/packages/virtual_registry/) offre aux équipes de développement un accès sécurisé aux artefacts et une intégration homogène aux [pipelines CI/CD](https://about.gitlab.com/fr-fr/topics/ci-cd/cicd-pipeline/ \"Qu'est-ce qu'un pipeline CI/CD ? \").  \n* [**Le développement à distance**](https://docs.gitlab.com/user/project/remote_development/) permet aux équipes de développement de travailler dans des environnements de développement à la demande, hébergés dans le cloud.\n\n> [Découvrez les fonctionnalités de GitLab Premium.](https://about.gitlab.com/fr-fr/pricing/premium/#wp-premium-features)\n\n## GitLab Duo : une IA qui s'adapte aux besoins des entreprises\n\nGitLab propose une gamme complète de fonctionnalités GitLab Duo dans ses offres Pro et Enterprise, pour accompagner ses clients à chaque étape de leur cycle d'adoption de l'IA. Plus vos équipes progressent dans ce cycle, et plus vous pouvez utiliser de fonctionnalités pour créer, tester et déployer plus rapidement des logiciels sécurisés.\n\n![Principales fonctionnalités des forfaits GitLab Duo](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749673912/Blog/Content%20Images/Screenshot_2025-05-14_at_8.50.34_AM.png)\n\n## Comment les clients GitLab Ultimate et Premium peuvent-ils activer GitLab Duo ?\n\nÀ partir de GitLab 18.0, pour les clients Ultimate et Premium existants, les fonctionnalités de suggestions de code et de chat de GitLab Duo sont désactivées par défaut, mais peuvent facilement être activées.\n\nVous trouverez la procédure à suivre ci-dessous : \n\n1. Vérifiez avant tout que vous disposez de GitLab Premium ou Ultimate. Dans le cas contraire, vous pouvez démarrer un essai gratuit. \n\n2. Activez GitLab Duo dans vos paramètres.\n\n3. Si vous utilisez un IDE local, installez l'[extension d'éditeur de code](https://docs.gitlab.com/editor_extensions/#available-extensions) GitLab de votre choix. \n\n4. Commencez à utiliser les suggestions de code et le chat dans l'IDE local de votre choix, s'il est pris en charge, ou dans le Web IDE de GitLab.\n\n**Remarque :** les fonctionnalités d'IA de GitLab seront activées automatiquement pour les nouveaux clients et les versions d'essai.\n\n## Le développement IA native avec une plateforme DevSecOps\n\nL'IA redéfinit l'expérience de développement. Les entreprises ne vont pas seulement recruter davantage de talents pour créer leurs logiciels. Elles vont également disposer de davantage de code généré par l'IA et prêt à être déployé en production, **ce qui rend GitLab plus essentiel que jamais.** \n\nNous avons conçu GitLab Premium et Ultimate avec GitLab Duo spécifiquement dans cet état d'esprit, afin d'offrir aux équipes une base sécurisée pour l'ensemble de leur code. À mesure que l'IA génère du code à l'échelle de votre entreprise, GitLab devient votre plateforme de contrôle, éliminant ainsi le recours à des outils distincts pour le scanning de sécurité, les contrôles de conformité ou la gestion des pipelines. Vous pouvez entièrement vous appuyer sur notre plateforme unique et unifiée, qui évolue avec votre entreprise. Elle vous garantit la qualité, la sécurité et la conformité de votre code jusqu’à sa mise en production. \n\n> Pour en savoir plus sur GitLab Duo et tous ses avantages pour votre équipe, [consultez notre page GitLab Premium](https://about.gitlab.com/fr-fr/pricing/premium/) ou, si vous êtes un client GitLab, contactez votre représentant GitLab pour organiser une démonstration. Enfin, nous vous invitons à participer au [lancement virtuel de GitLab 18](https://about.gitlab.com/eighteen/) le 24 juin 2025, afin de découvrir l'avenir du développement logiciel basé sur l'IA native.\n",[875,830,681,705,14],"AI/ML","2025-05-20",{"slug":878,"featured":92,"template":684},"gitlab-premium-with-duo","content:fr-fr:blog:gitlab-premium-with-duo.yml","Gitlab Premium With Duo","fr-fr/blog/gitlab-premium-with-duo.yml","fr-fr/blog/gitlab-premium-with-duo",{"_path":884,"_dir":248,"_draft":6,"_partial":6,"_locale":7,"seo":885,"content":890,"config":897,"_id":899,"_type":16,"title":900,"_source":18,"_file":901,"_stem":902,"_extension":21},"/fr-fr/blog/getting-started-with-gitlab-understanding-ci-cd",{"title":886,"description":887,"ogTitle":886,"ogDescription":887,"noIndex":6,"ogImage":843,"ogUrl":888,"ogSiteName":719,"ogType":720,"canonicalUrls":888,"schema":889},"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://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":886,"description":887,"authors":891,"heroImage":843,"date":893,"body":894,"category":14,"tags":895,"updatedDate":896},[892],"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",[110,853,854,830,14,852],"2025-05-26",{"slug":898,"featured":92,"template":684},"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":904,"_dir":248,"_draft":6,"_partial":6,"_locale":7,"seo":905,"content":911,"config":919,"_id":921,"_type":16,"title":922,"_source":18,"_file":923,"_stem":924,"_extension":21},"/fr-fr/blog/a-guide-to-the-breaking-changes-in-gitlab-18-0",{"title":906,"description":907,"ogTitle":906,"ogDescription":907,"noIndex":6,"ogImage":908,"ogUrl":909,"ogSiteName":719,"ogType":720,"canonicalUrls":909,"schema":910},"Guide des changements cassants et suppressions de GitLab 18.0","Anticipez dès maintenant les suppressions prévues dans notre prochaine version majeure. Évaluez les conséquences pour votre projet, puis consultez les mesures d'atténuation décrites dans la documentation afin de garantir une transition fluide vers GitLab 18.0.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749659437/Blog/Hero%20Images/AdobeStock_398929148.jpg","https://about.gitlab.com/blog/a-guide-to-the-breaking-changes-in-gitlab-18-0","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Guide des changements cassants et suppressions de GitLab 18.0\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Martin Brümmer\"},{\"@type\":\"Person\",\"name\":\"Fabian Zimmer\"},{\"@type\":\"Person\",\"name\":\"Sam Wiskow\"}],\n        \"datePublished\": \"2025-04-18\",\n      }\n                  ",{"title":906,"description":907,"authors":912,"heroImage":908,"date":916,"body":917,"category":14,"tags":918},[913,914,915],"Martin Brümmer","Fabian Zimmer","Sam Wiskow","2025-04-18","GitLab 18.0, notre prochaine version majeure, inclut de nouvelles fonctionnalités qui repoussent les limites de l'innovation DevSecOps, tandis que certaines options obsolètes sont supprimées. Découvrez dans cet article un récapitulatif complet des évolutions majeures à venir, ainsi que des pistes concrètes pour en limiter l’impact sur vos projets.\n\n## Fenêtres de déploiement GitLab 18.0\n\n### GitLab.com  \n\nLes changements cassants sur GitLab.com sont concentrés sur ces trois périodes clés : \n\n- Du 21 au 23 avril 2025  \n- Du 28 au 30 avril 2025  \n- Du 5 au 7 mai 2025\n\nDe nombreux autres évolutions continuent d'être déployés au fil des mois. Pour en savoir plus sur les modifications les plus sensibles apportées prévues à ces dates, consultez notre [documentation dédie aux changements cassants](https://docs.gitlab.com/update/breaking_windows/).\n\n***Remarque :** exceptionnellement, certaines mises à jour importantes peuvent intervenir légèrement en dehors de ces périodes.*\n\n### GitLab Self-Managed\n\nGitLab 18.0 est disponible depuis le 15 mai. Consultez le calendrier complet des sorties de nouvelles versions sur [cette page](https://about.gitlab.com/releases/).\n\n### GitLab Dedicated\n\nLa mise à niveau vers GitLab 18.0 aura lieu pendant votre fenêtre de maintenance, entre le 24 et le 29 juin 2025. Pour en savoir plus et connaître votre fenêtre de maintenance, consultez [cette page](https://docs.gitlab.com/administration/dedicated/maintenance/#release-rollout-schedule).\n\nNous mettons également à votre disposition des outils et ressources adaptés pour vous aider à mesurer l'impact de ces changements sur votre environnement et préparer votre passage à la version 18.0. N'hésitez pas à consulter [toutes les informations sur ces outils, ressources et les mesures d'atténuation](#tools-and-resources-to-manage-your-impact).\n\nEn outre, la [page des obsolescences](https://docs.gitlab.com/ee/update/deprecations?removal_milestone=18.0) répertorie l'ensemble des suppressions prévues dans la version 18.0. Découvrez ci-dessous les nouveautés de cette année et comment vous y préparer selon la configuration de votre déploiement.\n\n## Changements cassants\n\n### Impact élevé\n\n**1. Token pour job CI/CD : suppression du paramètre « Limiter l'accès depuis votre projet »**\n\nGitLab.com | GiitLab Self-Managed | GitLab Dedicated\n\nDans GitLab 14.4, nous avions mis en place le paramètre **Limiter l'accès à CI_JOB_TOKEN** pour améliorer la sécurité en **[restreignant l'accès *depuis* les tokens de job CI/CD de votre projet (CI_JOB_TOKEN)](https://docs.gitlab.com/ci/jobs/ci_job_token/#limit-your-projects-job-token-access)** Dans la version 16.3 de GitLab, ce paramètre a été renommé **Limiter l'accès *à partir* de ce projet** pour plus de clarté.\nDans la version 15.9 de GitLab, nous avions introduit une solution alternative : le paramètre **[Groupes et projets autorisés](https://docs.gitlab.com/ci/jobs/ci_job_token/#add-a-group-or-project-to-the-job-token-allowlist)**. Celui-ci contrôle l'accès au token pour job CI/CD de votre projet à l'aide d'une liste d'autorisations et constitue une amélioration significative par rapport à l'original. La première itération a été rendue obsolète dans GitLab 16.0 et sa suppression est prévue dans GitLab 18.0.\n\nLe paramètre **Limiter l'accès *à partir* de ce projet** est désactivé par défaut pour tous les nouveaux projets. Depuis GitLab 16.0, une fois ce paramètre désactivé dans un projet, il n’est plus possible de le réactiver, mais vous pouvez utiliser le paramètre **Groupes et projets autorisés** pour contrôler l'accès au token pour job de vos projets.\n\n- [Avis d'obsolescence](https://docs.gitlab.com/update/deprecations/#cicd-job-token---limit-access-from-your-project-setting-removal)\n- [Vérification GitLab Detective disponible](https://gitlab.com/gitlab-com/support/toolbox/gitlab-detective/-/blob/main/README.md)\n\n**2. Token pour job CI/CD : application de la liste d'autorisation « Groupes et projets autorisés »**\n\nGitLab.com | GitLab Self-Managed | GitLab Dedicated\n\nIntroduit dans GitLab 15.9, le **[paramètre « Groupes et projets autorisés »](https://docs.gitlab.com/ee/ci/jobs/ci_job_token.html#add-a-group-or-project-to-the-job-token-allowlist)** (renommé **Limiter l'accès à ce projet** dans la version 16.3 de GitLab), vous permet de gérer l'accès au token pour job CI/CD de votre projet. Lorsque le paramètre est défini sur **Uniquement ce projet et tous les groupes et projets de la liste d'autorisation**, seuls les groupes ou projets explicitement ajoutés à cette liste peuvent accéder à votre projet par le biais d'un token de job.\n\n* **Avant GitLab 15.9**, le token de job était accessible depuis n'importe quel projet, car la liste d'autorisation était désactivée par défaut et définie sur [**« Tous les groupes et projets »**](https://docs.gitlab.com/ee/ci/jobs/ci_job_token.html#allow-any-project-to-access-your-project), sans restriction d'accès.\n* **Depuis GitLab 17.6**, les administrateurs des instances GitLab Self-Managed ou GitLab Dedicated peuvent désormais [**imposer des règles de sécurité plus strictes pour tous les projets**](https://docs.gitlab.com/ee/administration/settings/continuous_integration.html#job-token-permissions) et empêcher les chargés de maintenance des projets de sélectionner **Tous les groupes et projets**. Cette modification garantit un niveau de sécurité plus élevé entre les projets.   \n* Dans GitLab 18.0, ce paramètre sera activé par défaut. Sur GitLab.com, nous remplirons automatiquement les listes d'autorisations de vos projets en fonction des logs d'authentification de votre projet.   \n* Pour anticiper ce changement sur **GitLab.com**, les chargés de maintenance du projet qui utilisent le token de job pour l'authentification inter-projets doivent remplir les listes d'autorisations **Groupes et projets autorisés**, puis définir le paramètre sur **Uniquement** **ce projet et tous les groupes et projets de la liste d'autorisation**. Nous vous encourageons à utiliser les [outils de migration](https://docs.gitlab.com/ci/jobs/ci_job_token/#auto-populate-a-projects-allowlist) disponibles pour ***automatiser*** la création de la liste d'autorisation en fonction des [logs d'authentification](https://docs.gitlab.com/ci/jobs/ci_job_token/#job-token-authentication-log) du projet avant le passage à la version GitLab 18.0.   \n* Les **utilisateurs de GitLab Self-Managed** doivent remplir les listes d'autorisations avant d'effectuer la mise à niveau vers la version 18.0.   \n* Les **utilisateurs de GitLab Dedicated** doivent élaborer, en collaboration avec l'équipe chargée de leur compte GitLab, une approche adaptée à leur instance.\n\n- [Avis d'obsolescence](https://docs.gitlab.com/update/deprecations/#cicd-job-token---authorized-groups-and-projects-allowlist-enforcement)\n- [Documentation](https://docs.gitlab.com/ci/jobs/ci_job_token/#add-a-gr)\n- [Vérification GitLab Detective disponible](https://gitlab.com/gitlab-com/support/toolbox/gitlab-detective/-/blob/main/README.md)\n\n**3. Renforcement de la portée des tokens pour le proxy de dépendances**\n\nGitLab.com | GitLab Self-Managed | GitLab Dedicated\n\nActuellement, le proxy de dépendances pour les conteneurs accepte les commandes **`docker login`** et **`docker pull`** en utilisant des tokens **d'accès personnels, de projet** ou **de groupe**, sans vérifier leurs portées. \n\nÀ partir de GitLab 18.0, il exigera la présence des portées **`read_registry`** et **`write_registry`** pour valider toute authentification. Après cette modification, les tentatives d'authentification avec des tokens ne disposant pas de ces portées seront **rejetées**.\n\nAvant de procéder à la mise à niveau, vous devez générer de nouveaux tokens avec les [**portées requises**](https://docs.gitlab.com/ee/user/packages/dependency_proxy/#authenticate-with-the-dependency-proxy-for-container-images), puis mettre à jour les variables et scripts de vos workflows avec ces nouveaux jetons.\n\nVous avez également la possibilité d'utiliser [**Dependency Token Checker**](https://gitlab.com/gitlab-com/cs-tools/gitlab-cs-tools/dependancy-token-checker/), un script développé par la communauté, qui vous permet de visualiser les tokens et de procéder à leur rotation automatique.\n\n- [Avis d'obsolescence](https://docs.gitlab.com/update/deprecations/#dependency-proxy-token-scope-enforcement)\n\n### Impact modéré\n\n**1. Nouvelles limites de conservation des données relatives aux vulnérabilités sur GitLab.com**\n\nGitLab.com - **Réservé aux clients Ultimate**\n\nÀ partir de GitLab 18.1, nous mettrons en place progressivement, sur une période de six mois, une **nouvelle limite de conservation des données** pour les clients de l'édition **GitLab Ultimate** sur GitLab.com, afin d'améliorer les performances et la fiabilité du système. Celle-ci aura une incidence sur la durée de conservation des données relatives aux vulnérabilité.\n\nLes vulnérabilités datant de plus de 12 mois qui n'ont pas été mises à jour seront automatiquement déplacées vers des archives de stockage à froid qui  :\n\n* restent accessibles et téléchargeables via l'interface utilisateur (UI) de GitLab  \n* sont conservées pendant 3 ans  \n* sont définitivement supprimées après 3 ans \n\n- [Avis d'obsolescence](https://docs.gitlab.com/update/deprecations/#new-data-retention-limits-for-vulnerabilities-on-gitlabcom)\n- [Documentation](https://handbook.gitlab.com/handbook/security/records-retention-deletion/)\n\n**2. Rejet des stratégies de pull d'image de conteneur qui ne figurent pas dans `allowed_pull_policies`**\n\nGitLab.com | GitLab Self-Managed | GitLab Dedicated  \n\nToutes les stratégies de pull configurées doivent être présentes dans la [**configuration allowed_pull_policies**](https://docs.gitlab.com/runner/executors/docker/#allow-docker-pull-policies) spécifiée dans le fichier **`config.toml`** du runner. Si ce n'est pas le cas, le job devrait échouer avec une erreur de type**`incompatible pull policy`**.\n\nActuellement, les jobs ne sont pas rejetés tant qu'au moins une stratégie de pull figure dans **`allowed-pull-policies`**, même si d'autres sont exclues.\n\nDans GitLab 18.0, un job ne sera en échec que si aucune stratégie de pull définie ne figure dans **`allowed-pull-policies`**. Toutefois, maintenant, seules les stratégies autorisées dans **`allowed-pull-policies`** seront effectivement appliquées. Avec GitLab 18.0, cette distinction risque de provoquer l'échec de jobs qui s'exécutent actuellement avec succès.\n\n- [Avis d'obsolescence](https://docs.gitlab.com/update/deprecations/#reject-container-image-pull-policies-not-in-allowed_pull_policies)\n- [Documentation](https://docs.gitlab.com/runner/executors/docker/#allow-docker-pull-policies)\n\n**3. Fin de la prise en charge de PostgreSQL 14 et 15**\n\nGitLab Self-Managed \n\nGitLab suit une [**cadence de mise à niveau annuelle pour PostgreSQL**](https://handbook.gitlab.com/handbook/engineering/infrastructure-platforms/data-access/database-framework/postgresql-upgrade-cadence/).\n\nLa prise en charge de PostgreSQL 14 et 15 sera supprimée dans GitLab 18.0 et PostgreSQL 16 deviendra la version minimale requise.\n\nPostgreSQL 14 et 15 seront pris en charge pendant l'ensemble du cycle de sortie de nouvelles versions de GitLab 17. PostgreSQL 16 sera également pris en charge pour les instances qui souhaitent effectuer une mise à niveau avant la sortie de GitLab 18.0.\n\nPour anticiper ce changement, les instances qui n'utilisent pas [**PostgreSQL Cluster**](https://docs.gitlab.com/administration/postgresql/replication_and_failover/) (comme celles installées avec un paquet Omnibus sur une seule instance PostgreSQL), bénéficieront d'une mise à niveau automatique vers PostgreSQL 16 à partir de GitLab 17.11. Si vous utilisez [**PostgreSQL Cluster**](https://docs.gitlab.com/administration/postgresql/replication_and_failover/) ou si vous [**désactivez cette mise à niveau automatique**](https://docs.gitlab.com/omnibus/settings/database/#opt-out-of-automatic-postgresql-upgrades), vous devrez [**effectuer une mise à niveau manuelle vers PostgreSQL 16**](https://docs.gitlab.com/omnibus/settings/database/#upgrade-packaged-postgresql-server) pour passer à GitLab 18.0. Assurez-vous de disposer de suffisamment d'espace disque pour effectuer la mise à niveau.\n\n- [Avis d'obsolescence](https://docs.gitlab.com/update/deprecations/#postgresql-14-and-15-no-longer-supported)\n- [Documentation](https://docs.gitlab.com/omnibus/settings/database/#upgrade-packaged-postgresql-server)\n- [Instructions pour la migration](https://docs.gitlab.com/omnibus/development/managing-postgresql-versions/)\n\n**4. Obsolescence des templates CI/CD Terraform**\n\nGitLab Self-Managed\n\nLes templates CI/CD Terraform sont déclarés obsolètes et sont supprimés dans GitLab 18.0. Les templates concernés sont les suivants  :\n\n* `Terraform.gitlab-ci.yml`  \n* `Terraform.latest.gitlab-ci.yml`  \n* `Terraform/Base.gitlab-ci.yml`  \n* `Terraform/Base.latest.gitlab-ci.yml`\n\nGitLab ne pourra pas mettre à jour le binaire **`terraform`** dans les images de job vers une version sous licence Business Source License (BSL).\n\nPour continuer à utiliser Terraform, clonez les templates et l'[**image Terraform**](https://gitlab.com/gitlab-org/terraform-images), et maintenez-les à jour si nécessaire. GitLab fournit des [**instructions détaillées**](https://gitlab.com/gitlab-org/terraform-images) pour migrer vers une image personnalisée.\n\n**À la place, nous vous recommandons d'utiliser le nouveau composant CI/CD OpenTofu sur GitLab.com ou le nouveau template CI/CD OpenTofu sur GitLab Self-Managed.** Les composants CI/CD ne sont pas encore disponibles sur GitLab Self-Managed. Toutefois, le [**ticket n° 415638**](https://gitlab.com/gitlab-org/gitlab/-/issues/415638) propose d'ajouter cette fonctionnalité. Si les composants CI/CD deviennent disponibles sur GitLab Self-Managed, le template CI/CD OpenTofu sera supprimé.\n\nEn savoir plus sur le nouveau [composant CI/CD OpenTofu](https://gitlab.com/components/opentofu).\n\n- [Avis d'obsolescence](https://docs.gitlab.com/update/deprecations/#deprecate-terraform-cicd-templates)\n\n**5. Mise à jour majeure du sous-chart Prometheus**\n\nGitLab Self-Managed\n\nAvec GitLab 18.0 et le chart GitLab 9.0, le sous-chart Prometheus sera mis à jour de la version 15.3 à la version 27.3.\n\nAvec cette mise à jour, Prometheus 3 sera livré par défaut.\n\nVous devrez effectuer certaines étapes manuelles pour effectuer la mise à niveau. Si Alertmanager, Node Exporter ou Pushgateway sont activés, vous devrez également mettre à jour vos valeurs Helm.\n\nVeuillez vous référer au [**guide sur la migration**](https://docs.gitlab.com/charts/releases/9_0/#prometheus-upgrade) pour plus d'informations.\n\n- [Avis d'obsolescence](https://docs.gitlab.com/update/deprecations/#major-update-of-the-prometheus-subchart)\n\n### Impact faible\n\n**1. Arrêt de la compilation des paquets SUSE Linux Enterprise Server 15 SP2**\n\nGitLab Self-Managed\n\nLe version avec service et support à long terme (LTSS) pour SUSE Linux Enterprise Server (SLES) 15 SP2 a pris fin en décembre 2024.\n\nPar conséquent, nous ne prendrons plus en charge la distribution de SLES SP2 pour les installations de paquets Linux. Veuillez effectuer une mise à niveau vers SLES 15 SP6 pour bénéficier d'une prise en charge continue.\n\n- [Avis d'obsolescence](https://docs.gitlab.com/update/deprecations/#support-for-suse-linux-enterprise-server-15-sp2)\n\n**2. Suppression du limiteur de débit Gitaly**\n\nGitLab Self-Managed\n\nAuparavant, Gitaly prenait en charge la [**limitation de débit basée sur RPC**](https://gitlab.com/gitlab-org/gitaly/-/blob/4b7ea24f6172a03e7989879200b47b6fd0e2d059/doc/backpressure.md#L55-55). Nous rendons aujourd'hui cette fonctionnalité obsolète, car elle ne donne pas les résultats escomptés. Veuillez consulter le ticket relatif à l'obsolescence pour plus de détails.\n\nSi vous avez procédé à la configuration du limiteur de débit (bientôt obsolète), aucune erreur ne sera renvoyée et celle-ci sera simplement ignorée.\n\nÀ la place, vous devez utiliser le [**limiteur de simultanéité**](https://docs.gitlab.com/administration/gitaly/concurrency_limiting/).\n\n- [Avis d'obsolescence](https://docs.gitlab.com/update/deprecations/#gitaly-rate-limiting)\n\n**3. Obsolescence de la prise en charge de l'image du contrôleur NGINX 1.3.1**\n\nGitLab Self-Managed\n\nNous passons à la version 1.11.2 du contrôleur NGINX par défaut, laquelle impose de nouvelles règles de contrôle d'accès basé sur les rôles (RBAC). Les utilisateurs qui utilisent **nginx-ingress.rbac.create: false** pour gérer leurs propres règles RBAC\n\ndevront les mettre à jour avant de migrer vers la version 1.11.2 ou une version ultérieure. Un mécanisme alternatif permet désormais de déployer la version 1.3.1 uniquement si la valeur Helm est définie comme indiqué ci-dessus. Par ailleurs, nous avons ajouté la valeur **nginx-ingress.controller.image.disableFallback**, qui est définie par défaut sur « false ». Si vous gérez vos propres règles RBAC, vous pouvez définir cette valeur sur « true » une fois les nouvelles règles en place, afin de permettre le déploiement de la version 1.11.2.\n\nLa version 17.5 marquera la fin de la prise en charge de l'image 1.3.1 et du mécanisme alternatif, afin de généraliser l'utilisation de la version 1.11.2, plus sécurisée.\n\n[Avis d'obsolescence](https://docs.gitlab.com/update/deprecations/#fallback-support-for-gitlab-nginx-chart-controller-image-v131)\n\n**4. Mise à jour de la version majeure des analyseurs de tests de sécurité des applications**\n\nGitLab.com | GitLab Self-Managed | GitLab Dedicated\n\nAvec GitLab 18.0, les analyseurs utilisés pour les tests de sécurité des applications passeront à de nouvelles versions majeures.\n\nSi vous n'utilisez pas les templates inclus par défaut ou si vous avez épinglé vos versions d'analyseur, pensez à mettre à jour votre job CI/CD en retirant la version épinglée ou en passant à la dernière version majeure.\n\nJusqu'à GitLab 18.0, les analyseurs seront toujours mis à jour sur les versions 17.0 à 17.11. Ensuite, seuls les analyseurs de la nouvelle version majeure bénéficieront des correctifs et des nouvelles fonctionnalités.\n\nConformément à notre politique de maintenance, nous ne rétroportons pas les bogues ni les nouvelles fonctionnalités vers les versions obsolètes. Seuls les correctifs de sécurité peuvent être appliqués aux trois dernières versions mineures.\n\n- [Avis d'obsolescence](https://docs.gitlab.com/update/deprecations/#application-security-testing-analyzers-major-version-update)\n\n**5. API Discovery utilisera les pipelines de branche par défaut**\n\nGitLab.com | GitLab Self-Managed | GitLab Dedicated\n\nDans GitLab 18.0, nous mettrons à jour le comportement par défaut du template CI/CD pour API Discovery (**API-Discovery.gitlab-ci.yml**).\n\nJusqu'à GitLab 18.0, il configurait par défaut les jobs pour qu'ils s'exécutent dans des [**pipelines de merge requests (MR)**](https://docs.gitlab.com/ci/pipelines/merge_request_pipelines/) dès l'ouverture d'une MR.\n\nDès GitLab 18.0, ce template adoptera le même comportement que les [**éditions stables de templates**](https://docs.gitlab.com/user/application_security/detect/roll_out_security_scanning/#template-editions) des autres scanners d'arbre de syntaxe abstraite (AST) :\n\n* Par défaut, le template exécutera des jobs de scan dans les pipelines de branche.  \n* Vous pourrez définir la variable CI/CD **AST_ENABLE_MR_PIPELINES: true** pour utiliser les pipelines MR lors de l'ouverture d'une MR. Le suivi de la mise en œuvre de cette variable est disponible via le [**ticket n° 410880**](https://gitlab.com/gitlab-org/gitlab/-/issues/410880).\n\n- [Avis d'obsolescence](https://docs.gitlab.com/update/deprecations/#api-discovery-will-use-branch-pipelines-by-default)\n\n**6. Réduction par défaut de la valeur du DAST DAST_DEVTOOLS_API_TIMEOUT**\n\nGitLab.com | GitLab Self-Managed | GitLab Dedicated\n\nLa variable d'environnement **DAST_DEVTOOLS_API_TIMEOUT** détermine la durée pendant laquelle un test dynamique de sécurité des applications (DAST) attend une réponse du navigateur. Avant GitLab 18.0, la variable avait une valeur statique de 45 secondes. Dès GitLab 18.0, la variable d'environnement **DAST_DEVTOOLS_API_TIMEOUT** aura une valeur dynamique, calculée en fonction d'autres configurations de délai d'attente dépassé.\n\nDans la plupart des cas, la valeur de 45 secondes était supérieure à la valeur du délai d'attente dépassé de nombreuses fonctions du scanner. Le passage à un calcul dynamique permet d'adapter la variable __DAST_DEVTOOLS_API_TIMEOUT__ à un plus grand nombre de situations.\n\n- [Avis d'obsolescence](https://docs.gitlab.com/update/deprecations/#dast-dast_devtools_api_timeout-will-have-a-lower-default-value) \n\n## Outils et ressources pour gérer l'impact sur votre environnement\n\nNous avons développé des outils spécifiques pour aider nos clients à comprendre l'impact de ces changements planifiés sur leur(s) instance(s) GitLab. Après avoir évalué l'impact sur votre projet, consultez les mesures d'atténuation décrites dans la documentation pour assurer une transition fluide vers GitLab 18.0.\n\n* [Obsolescence de la recherche avancée](https://gitlab.com/gitlab-com/cs-tools/gitlab-cs-tools/deprecation-migration-tools/advanced-search-deprecations) : cet outil s'appuie sur l'API de recherche avancée de GitLab pour repérer les chaînes liées aux obsolescences dans vos groupes et projets, et signale aussi les fichiers nécessitant une vérification manuelle. *__Remarque :__ peut comporter des faux positifs.*   \n* [Assistant de détection de prise en charge de la compilation pour l'analyse des dépendances](https://gitlab.com/security-products/tooling/build-support-detection-helper) : cet outil détecte les projets concernés par trois obsolescences liées à l'analyse des dépendances ([1](https://docs.gitlab.com/update/deprecations/#dependency-scanning-for-javascript-vendored-libraries), [2](https://docs.gitlab.com/update/deprecations/#dependency-scanning-upgrades-to-the-gitlab-sbom-vulnerability-scanner), [3](https://docs.gitlab.com/update/deprecations/#resolve-a-vulnerability-for-dependency-scanning-on-yarn-projects) ; toutes reportées à la version 19.0) et s'appuie sur l'API pour analyser les fichiers et les nom de jobs CI.\n* [GitLab Detective](https://gitlab.com/gitlab-com/support/toolbox/gitlab-detective/-/blob/main/README.md) (GitLab Auto-géré uniquement) : cet outil expérimental analyse automatiquement votre installation GitLab pour détecter les problèmes connus, en s'appuyant sur des vérifications poussées des fichiers de configuration et valeurs issues de la base de données. **Remarque :** l’outil doit s'exécuter directement sur vos nœuds GitLab.\n\nPour vous accompagner dans cette transition, nous avons lancé sur GitLab University des micro-cours pratiques (de 15 minutes maximum) dédiés à la préparation et à la mise en œuvre des actions d'atténuation nécessaires. [Commencez votre parcours d'apprentissage ici](https://university.gitlab.com/catalog?query=18.0). \n\nSi vous disposez d'un forfait payant et que vous avez des questions ou besoin d'aide concernant ces changements, veuillez [créer un ticket d'assistance](https://about.gitlab.com/support/portal/) sur le portail d'assistance GitLab. \n\nSi vous utilisez la [version gratuite de Gitlab.com](https://about.gitlab.com/support/statement-of-support/#free-users), vous pouvez obtenir de l'aide via les ressources communautaires : [documentation GitLab](https://docs.gitlab.com/), [forum de la communauté GitLab](https://forum.gitlab.com/) et [Stack Overflow](http://stackoverflow.com/questions/tagged/gitlab).\n",[14,830],{"slug":920,"featured":6,"template":684},"a-guide-to-the-breaking-changes-in-gitlab-18-0","content:fr-fr:blog:a-guide-to-the-breaking-changes-in-gitlab-18-0.yml","A Guide To The Breaking Changes In Gitlab 18 0","fr-fr/blog/a-guide-to-the-breaking-changes-in-gitlab-18-0.yml","fr-fr/blog/a-guide-to-the-breaking-changes-in-gitlab-18-0",{"_path":926,"_dir":248,"_draft":6,"_partial":6,"_locale":7,"seo":927,"content":932,"config":939,"_id":941,"_type":16,"title":942,"_source":18,"_file":943,"_stem":944,"_extension":21},"/fr-fr/blog/automating-agile-workflows-with-the-gitlab-triage-gem",{"title":928,"description":929,"ogTitle":928,"ogDescription":929,"noIndex":6,"ogImage":843,"ogUrl":930,"ogSiteName":719,"ogType":720,"canonicalUrls":930,"schema":931},"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":928,"description":929,"authors":933,"heroImage":843,"date":934,"body":935,"category":14,"tags":936,"updatedDate":938},[892],"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",[830,852,14,937,110],"agile","2025-04-15",{"slug":940,"featured":6,"template":684},"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",{"_path":946,"_dir":248,"_draft":6,"_partial":6,"_locale":7,"seo":947,"content":953,"config":959,"_id":961,"_type":16,"title":962,"_source":18,"_file":963,"_stem":964,"_extension":21},"/fr-fr/blog/build-a-new-website-in-a-few-easy-steps-with-gitlab-pages",{"title":948,"description":949,"ogTitle":948,"ogDescription":949,"noIndex":6,"ogImage":950,"ogUrl":951,"ogSiteName":719,"ogType":720,"canonicalUrls":951,"schema":952},"GitLab Pages : comment créer un site web en quelques étapes simples ","Découvrez dans ce tutoriel comment créer et héberger votre site web à l'aide de GitLab Pages à partir d'un template prêt à l'emploi et personnalisable. ","https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097716/Blog/Hero%20Images/Blog/Hero%20Images/blog-image-template-1800x945%20%281%29_7c3TDgNgct9xQbmTJSw0de_1750097716096.png","https://about.gitlab.com/blog/build-a-new-website-in-a-few-easy-steps-with-gitlab-pages","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"GitLab Pages : comment créer un site web en quelques étapes simples \",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Alex Fracazo\"}],\n        \"datePublished\": \"2025-03-03\",\n      }\n                  ",{"title":948,"description":949,"authors":954,"heroImage":950,"date":956,"body":957,"category":14,"tags":958,"updatedDate":934},[955],"Alex Fracazo","2025-03-03","Un site web personnel est bien plus qu'un simple outil pour les créateurs de contenus numériques et les professionnels de la tech. C'est une représentation de votre marque. Pourtant, créer entièrement un site web peut s'avérer chronophage et onéreux.\n\nAvec [GitLab Pages](https://docs.gitlab.com/user/project/pages/), vous pouvez héberger votre site web directement depuis un dépôt GitLab. Il inclut des fonctionnalités intégrées, notamment des certificats SSL ainsi qu'un domaine fourni par GitLab. GitLab Pages est accessible avec la version gratuite de GitLab, ce qui en fait une solution idéale pour héberger votre site en ligne.\n\nDécouvrez dans cet article comment créer un site web à l'aide de GitLab Pages à partir d’un template facilement personnalisable. \n\n## Prérequis\n\nVous avez besoin des prérequis suivants avant de commencer :\n\n* Un compte GitLab (la [version gratuite](https://about.gitlab.com/fr-fr/pricing/) est suffisante)  \n* Une connaissance de base en HTML/CSS  \n* Le contenu et les images que vous souhaitez ajouter à votre site web (facultatif)\n\nUne fois que vous avez configuré votre compte GitLab et que votre contenu est prêt, vous pouvez passer aux étapes suivantes.\n\n## Étape 1 : créer un nouveau projet\n\n1. Connectez-vous à votre compte GitLab et créez un projet.\n\n![Tutoriel GitLab Pages - écran d'accueil](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097724/Blog/Content%20Images/Blog/Content%20Images/Capture-2025-02-27-183716_aHR0cHM6_1750097724662.png)\n\n2. Cliquez sur **Créer un projet vide**.\n\n![Tutoriel GitLab Pages - écran de création d'un projet](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097725/Blog/Content%20Images/Blog/Content%20Images/Capture-2025-02-27-183814_aHR0cHM6_1750097724663.png)\n\n3. Renseignez les détails de votre projet :\n    * Nommez votre projet `votrenomutilisateur.gitlab.io`. Remplacez `votrenomutilisateur` par votre nom d'utilisateur GitLab. **Astuce :** le nom du projet détermine l'URL de votre site web. Si vous nommez votre projet `votrenomutilisateur.gitlab.io`, votre site web sera disponible à l'adresse `https://votrenomutilisateur.gitlab.io` sans chemin d'accès supplémentaire. Cependant, si vous utilisez un autre nom de projet, votre site sera disponible à l'adresse `https://votrenomutilisateur.gitlab.io/nom-du-projet`.\n    * Rendez le projet public.\n4. Cliquez sur **Créer le projet**.\n\n![Tutoriel GitLab Pages - écran Créer un projet vide](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097725/Blog/Content%20Images/Blog/Content%20Images/image5_aHR0cHM6_1750097724666.png)\n\n![Tutoriel GitLab Pages - page de démarrage personnalisée](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097725/Blog/Content%20Images/Blog/Content%20Images/image2_aHR0cHM6_1750097724668.png)\n\n## Étape 2 : ajouter les fichiers du template\n\nCommencez par créer deux nouveaux fichiers dans votre dépôt :\n\n![Tutoriel GitLab Pages - ajout de nouveaux fichiers à la page personnelle](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097725/Blog/Content%20Images/Blog/Content%20Images/image13_aHR0cHM6_1750097724669.png)\n\n1. Tout d'abord, créez un fichier `index.html` :\n    * Dans votre projet, cliquez sur le bouton **+** et sélectionnez **Nouveau fichier**.\n    * Nommez le fichier `index.html`.\n![Tutoriel GitLab Pages - page nouveau fichier](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097725/Blog/Content%20Images/Blog/Content%20Images/image14_aHR0cHM6_1750097724671.png)\n    * Ajoutez votre contenu HTML.\n        * Utilisez l'exemple de code HTML fourni ci-dessous. (Conseil : vous pouvez demander à GitLab Duo Chat de générer du code HTML personnalisé si vous avez besoin de fonctionnalités plus avancées.)\n\n```    \n\u003C!DOCTYPE html>\n\u003Chtml>\n\u003Chead>\n    \u003Cmeta charset=\"utf-8\"/>\n    \u003Ctitle>[Your Name] - [Your Title]\u003C/title>\n    \u003Cmeta name=\"description\" content=\"[Your Name] is a [Your Title].\"/>\n    \u003Cmeta name=\"author\" content=\"[Your Name]\"/>\n    \u003Cmeta property=\"og:title\" content=\"[Your Name]\" />\n    \u003Cmeta property=\"og:description\" content=\"[Your Title]\" />\n    \u003Cmeta property=\"og:image\" content=\"og.png\" />\n    \u003Cmeta name=\"viewport\" content=\"width=device-width,initial-scale=1\"/>\n    \u003Clink href=\"https://unpkg.com/basscss@8.0.2/css/basscss.min.css\" rel=\"stylesheet\">\n    \u003Clink href=\"style.css\" rel=\"stylesheet\">\n    \u003Clink rel=\"shortcut icon\" type=\"image/png\" href=\"favicon.png\"/>\n\u003C/head>\n\u003Cbody>\n\u003Cdiv class=\"content\" id=\"content\">\n  \u003Cdiv class=\"p2 sm-p4 mt2 sm-mt4 mb2 sm-mb4\">  \n  \u003Cdiv class=\"fade mt3\">\n    \u003Ca target=\"_new\" href=\"[Your Linkedin URL]\">\n      \u003Cimg class=\"photo\" src=\"profile.png\" width=\"64\" height=\"64\">\n    \u003C/a>\n  \u003C/div>\n  \u003Ch2 class=\"mb0 mt4 fade\">\n    Hello, I'm [Your Name] \n    \u003Cspan class=\"smallcaps\">(\u003C/span>\n    \u003Ca target=\"_new\" href=\"[Your Linkedin URL]\">@[Your Handle]\u003C/a>\n    \u003Cspan class=\"smallcaps\">)\u003C/span>\n  \u003C/h2>\n  \u003Ch2 class=\"mt0 mb4 fade gray\">\n    I'm a [Your Title]\n  \u003C/h2>\n  \u003Cp class=\"mb4 fade\">\n    I'm a [Your Role] at [Your Company], [Brief company description].\n  \u003C/p>\n  \u003Cdiv class=\"fade\">\n    \u003Cp class=\"fade mb4\">\n      Your personal statement about what you do and what you're interested in. Add your contact preferences here.\n    \u003C/p>\n  \u003C/div>\n  \u003Cp class=\"fade mb4\">\n    \u003Cspan class=\"gray\">—\u003C/span> \n    [Your Name] \n    \u003Cspan class=\"smallcaps>(\u003C/span>\n    \u003Ca target=\"_new\" href=\"[Your Linkedin URL]\">@[Your Handle]\u003C/a>\n    \u003Cspan class=\"smallcaps\">)\u003C/span>\n  \u003C/p>\n  \u003C/div>\n\u003C/div>\n\u003C/body>\n\u003C/html> \n```\n\n* Ajoutez un message de validation (par exemple, « Ajout du fichier index.html »).\n  * Cliquez sur **Valider les modifications**.\n\n2. Créez le fichier `style.css` (et suivez les mêmes étapes que ci-dessus).\n\n```\nbody {\n  margin: 0;\n  padding: 0;\n  background: #000;\n  color: #f4f4f4;\n  font-family: \"Graphik Web\", system-ui, -apple-system, BlinkMacSystemFont, \"Helvetica Neue\", \"Helvetica\", \"Segoe UI\", Roboto, Ubuntu, sans-serif;\n  font-weight: 400;\n  font-smooth: antialiased;\n  -webkit-font-smoothing: antialiased;\n  -moz-osx-font-smoothing: grayscale;\n}\n\na {\n  color: #ff310a;\n  text-decoration: none;\n}\n\na:hover {\n  color: #CFEF54\n}\n\n.content {\n  max-width: 40rem;\n  margin: 0 auto;\n}\n\nimg.photo {\n  border-radius: 50%;\n}\n\np {\n  font-size: 1.5rem;\n  line-height: 1.4;\n  margin: 0;\n  letter-spacing: -0.05rem;\n}\n\nh2 {\n  font-weight: 400;\n  line-height: 1.3;\n  letter-spacing: -0.05rem;\n}\n\n.smallcaps {\n  font-variant: small-caps;\n  color:#333;\n}\n\n.gray{\n  color: #999;\n}\n\n.preloader {\n  display: flex;\n  justify-content: center;\n  align-items: center;\n  height: 100vh;\n  height: -moz-available;\n  height: -webkit-fill-available;\n  height: fill-available;\n  width: 100%;\n  background: #000;\n  position: fixed;\n  top: 0;\n  left: 0;\n  z-index: 9999;\n  transition: opacity 0.3s linear;\n  transform: translate3d(0, 0, 0);\n}\n\nbody.loaded .preloader {\n  opacity: 0;\n}\n\n.fade {\n  animation: fadeIn 1s ease-in-out both;\n}\n\n.fade:nth-child(2) {\n\tanimation-delay: 1s;\n}\n\n.fade:nth-child(3) {\n\tanimation-delay: 2s;\n}\n\n.fade:nth-child(4) {\n\tanimation-delay: 3s;\n}\n\n.fade:nth-child(5) {\n\tanimation-delay: 4s;\n}\n\n.fade:nth-child(6) {\n\tanimation-delay: 5s;\n}\n\n.fade:nth-child(7) {\n\tanimation-delay: 6s;\n}\n\n.fade:nth-child(8) {\n\tanimation-delay: 7s;\n}\n\n.fade:nth-child(9) {\n\tanimation-delay: 8s;\n}\n\n.fade:nth-child(10) {\n\tanimation-delay: 9s;\n}\n\n.fade:nth-child(11) {\n\tanimation-delay: 10s;\n}\n\n.fade:nth-child(12) {\n\tanimation-delay: 11s;\n}\n\n.fade:nth-child(13) {\n\tanimation-delay: 12s;\n}\n\n@keyframes fadeIn {\n\tfrom {\n\t\topacity: 0;\n\t\ttransform: translate3d(0, 0%, 0);\n\t}\n\tto {\n\t\topacity: 1;\n\t\ttransform: translate3d(0, 0, 0);\n\t}\n} \n\n```\n\n## Étape 3 : configurer le fichier GitLab CI\n\nVous disposez de deux méthodes pour créer le fichier de configuration GitLab CI qui indique à GitLab comment créer et déployer votre site web :\n\n![Tutoriel GitLab Pages - écran Optimiser votre workflow avec les pipelines CI/CD](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097725/Blog/Content%20Images/Blog/Content%20Images/image3_aHR0cHM6_1750097724672.png)\n\n**Option 1 : utiliser l'éditeur de pipeline (recommandé)**\n\n1. Accédez à **Compilation > Pipelines** dans votre projet.\n\n![Tutoriel GitLab Pages - éditeur de pipeline/branche principale](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097725/Blog/Content%20Images/Blog/Content%20Images/image12_aHR0cHM6_1750097724673.png)\n\n2. Le fichier `.gitlab-ci.yml` est automatiquement créé. \n3. Copiez et collez la configuration suivante : \n\n```\npages:\n  stage: deploy\n  script:\n    - mkdir .public\n    - cp -r * .public\n    - mv .public public\n  artifacts:\n    paths:\n      - public\n  only:\n    - main\n```\n\n![Tutoriel GitLab Pages - Nouveau fichier dans la fenêtre](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097725/Blog/Content%20Images/Blog/Content%20Images/image4_aHR0cHM6_1750097724674.png)\n\n**Option 2 : effectuer une création manuelle**\n\nSi vous préférez créer le fichier manuellement : \n1. Créez un fichier nommé `.gitlab-ci.yml`. \n2. Ajoutez la configuration suivante :\n\n```\npages:\n  stage: deploy\n  script:\n    - mkdir .public\n    - cp -r * .public\n    - mv .public public\n  artifacts:\n    paths:\n      - public\n  only:\n    - main\n```\n\nLe fichier de configuration GitLab CI est indispensable au bon fonctionnement de votre site web. Il indique à GitLab comment créer et déployer votre site.\n\nAnalysons le rôle de chaque partie :\n\n**La partie script**\n\n```\nscript:\n  - mkdir .public\n  - cp -r * .public\n  - mv .public public\n```\n\nCe code crée un dossier appelé `public` et y copie tous les fichiers de votre site web. GitLab Pages utilise ce dossier pour gérer votre site web par défaut, mais vous pouvez [personnaliser le dossier de publication](https://docs.gitlab.com/user/project/pages/introduction/#customize-the-default-folder) si vous le souhaitez.\n\n**La partie only**\n\n```\nonly:\n  - main\n\n```\n\nCe code indique à GitLab de mettre à jour votre site web uniquement lorsque des modifications sont apportées à la branche principale. Cela permet d'éviter les mises à jour accidentelles dues à des modifications expérimentales.\n\n## Étape 4 : finaliser votre site web\n1. Validez toutes vos modifications.\n2. Accédez au menu **Compilation > Pipelines** pour visualiser votre déploiement.\n3. Attendez que le pipeline se termine correctement (une coche verte s'affiche).\n\n![Tutoriel GitLab Pages - pipeline en cours d'exécution pour la création de la page](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097725/Blog/Content%20Images/Blog/Content%20Images/image6_aHR0cHM6_1750097724676.png)\n\n![Tutoriel GitLab Pages - pipeline réussi pour la création de la page](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097725/Blog/Content%20Images/Blog/Content%20Images/image1_aHR0cHM6_1750097724677.png)\n\n## Étape 5 : accéder à votre site web\n\nUne fois le pipeline terminé avec succès, votre site web est disponible à l'adresse suivante : **https://[votrenomutilisateur].gitlab.io/** .\n\nLa section **Déploiement > Pages** de votre projet affiche une vue d'ensemble de votre site web déployé et des paramètres supplémentaires. Vous y trouverez des informations utiles, notamment : \n\n* Les URL d'accès à votre site web   \n* Les paramètres du domaine  \n  * Par défaut, GitLab active un **domaine unique**. Assurez-vous de le désactiver si vous souhaitez utiliser le domaine fourni par GitLab. Pour en savoir plus, consultez la [documentation sur le domaine unique](https://docs.gitlab.com/ee/user/project/pages#unique-domains).  \n* Statut des certificats HTTPS   \n* Déploiements récents   \n* Options de configuration supplémentaires\n* Domaines personnalisés\n\nCette section est particulièrement utile lors de la configuration de domaines personnalisés ou de la résolution de problèmes de déploiement.\n\n**Personnaliser votre site**\n\n![Tutoriel GitLab Pages - personnaliser le site](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097725/Blog/Content%20Images/Blog/Content%20Images/image8_aHR0cHM6_1750097724678.png)\n\n1. Remplacez tous les espaces réservés « Your ... » dans le fichier `index.html` par vos propres informations.\n\n![Tutoriel GitLab Pages - importer un fichier pour personnaliser la page](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097725/Blog/Content%20Images/Blog/Content%20Images/image11_aHR0cHM6_1750097724679.png)\n\n2. Ajoutez vos images :\n    - profile.png : votre photo de profil (64 x 64px)\n    - favicon.png : favicon de votre site (32 x 32px)\n    - Og.png : image OpenGraph pour l'aperçu des médias sociaux (1200 x 630px)\n\n**Consulter le site en ligne**\n\nSi vous avez l'habitude d'utiliser GitLab, n'hésitez pas à [dupliquer mon dépôt](https://gitlab.com/fracazo/fracazo.gitlab.io) pour commencer rapidement à créer votre propre site web. \n\nVoici le résultat final :\n[https://fracazo.gitlab.io/](https://fracazo.gitlab.io/)\n\n**Problèmes courants et solutions**\n- Par défaut, GitLab active un « Domaine unique » pour les projets GitLab Pages. Pour utiliser le domaine plus simple fourni par GitLab (comme `nomutilisateur.gitlab.io`), accédez au menu **Déploiement > Pages** et désactivez l'option « Utiliser un domaine unique ». Bien que les domaines uniques présentent certains avantages techniques, comme une meilleure gestion des chemins d'accès aux fichiers et autres actifs, vous pouvez choisir une structure d'URL plus courte et plus facile à retenir pour votre site web personnel.\n- Si votre pipeline échoue, vérifiez que vous utilisez `main` à la place de `master` dans votre fichier `.gitlab-ci.yml`.\n- Assurez-vous que votre groupe et votre projet sont publics pour que GitLab Pages fonctionne.\n- Si un job de votre pipeline échoue, vous pouvez consulter le job log pour récupérer les messages d'erreur détaillés afin de faciliter le dépannage.\n\nAvec GitLab Pages et ce template, vous pouvez créer un site web professionnel ou personnel opérationnel en quelques minutes. Le template est épuré, il est bien organisé, il s'adapte automatiquement aux différents types d'écran et vous pouvez le personnaliser selon vos besoins et préférences. À mesure que votre activité évolue, vous pouvez facilement mettre à jour votre site web, directement via GitLab. \n\nVous pouvez automatiser le processus de déploiement en tirant parti des capacités CI/CD de GitLab et en vous concentrant sur la création d'un contenu de qualité.\n\nLa bonne nouvelle, c'est que tous ces avantages sont disponibles dans la version gratuite de GitLab, ce qui en fait une option idéale pour héberger gratuitement vos projets personnels, des sites de documentation ou même des sites web de PME. Pour des fonctionnalités et des configurations plus avancées, consultez notre [documentation sur GitLab Pages](https://docs.gitlab.com/ee/user/project/pages/).\n\n## Prochaines nouveautés de GitLab Pages\nNous nous efforçons constamment d'améliorer GitLab Pages pour faciliter le travail des créateurs et développeurs. Voici quelques améliorations intéressantes à venir : \n\n### Gestion de domaine simplifiée\nNous prévoyons d'implémenter des mises à jour pour GitLab Pages qui rendront la gestion de vos domaines sera encore plus facile et amusante ! Nous vous proposerons un tableau de bord simplifié qui rassemble tous les paramètres de votre domaine dans un seul espace, où tout est facilement accessible. \n\nVous recevrez des mises à jour en temps réel du statut de votre DNS et de votre certificat SSL, afin de sécuriser vos domaines et d'en assurer le bon fonctionnement. \n\n### Configuration d'un domaine personnalisé\nLa configuration de domaines personnalisés sera un jeu d'enfant grâce à notre processus intuitif, conçu pour vous guider à chaque étape. De plus, vous pourrez configurer votre domaine personnalisé afin de rediriger automatiquement les visiteurs de l'ancienne adresse de votre site web vers la nouvelle. Ainsi, l'ensemble de votre trafic sera centralisé sur un site web principal unique. Pour en savoir plus, consultez notre [documentation sur les domaines personnalisés](https://docs.gitlab.com/ee/user/project/pages/custom_domains_ssl_tls_certification/index.html#set-up-a-custom-domain).\n\n> Essayez GitLab Pages dès aujourd'hui avec [la version gratuite de GitLab](https://about.gitlab.com/fr-fr/pricing/) ! \n\n## En savoir plus\n- [GitLab Pages : versions temporaires d'applications et déploiement simultané de plusieurs sites web](https://about.gitlab.com/blog/gitlab-pages-features-review-apps-and-multiple-website-deployment/)\n- [GitLab Pages : documentation sur le déploiement simultané de plusieurs sites web](https://docs.gitlab.com/user/project/pages/#parallel-deployments)\n- [Exemples GitLab Pages](https://gitlab.com/pages)",[852,830],{"slug":960,"featured":6,"template":684},"build-a-new-website-in-a-few-easy-steps-with-gitlab-pages","content:fr-fr:blog:build-a-new-website-in-a-few-easy-steps-with-gitlab-pages.yml","Build A New Website In A Few Easy Steps With Gitlab Pages","fr-fr/blog/build-a-new-website-in-a-few-easy-steps-with-gitlab-pages.yml","fr-fr/blog/build-a-new-website-in-a-few-easy-steps-with-gitlab-pages",{"_path":966,"_dir":248,"_draft":6,"_partial":6,"_locale":7,"seo":967,"content":973,"config":981,"_id":983,"_type":16,"title":984,"_source":18,"_file":985,"_stem":986,"_extension":21},"/fr-fr/blog/structuring-the-gitlab-package-registry-for-enterprise-scale",{"title":968,"description":969,"ogTitle":968,"ogDescription":969,"noIndex":6,"ogImage":970,"ogUrl":971,"ogSiteName":719,"ogType":720,"canonicalUrls":971,"schema":972},"Comment structurer le registre de paquets de GitLab à l'échelle de l'entreprise","Découvrez comment tirer parti du modèle unique de publication des paquets par projet de GitLab, combiné à une utilisation centralisée au niveau du groupe racine.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749662332/Blog/Hero%20Images/blog-image-template-1800x945__23_.png","https://about.gitlab.com/blog/structuring-the-gitlab-package-registry-for-enterprise-scale","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Comment structurer le registre de paquets de GitLab à l'échelle de l'entreprise\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Tim Rizzi\"}],\n        \"datePublished\": \"2025-02-19\",\n      }",{"title":968,"description":969,"authors":974,"heroImage":970,"date":976,"body":977,"category":14,"tags":978,"updatedDate":980},[975],"Tim Rizzi","2025-02-19","À mesure que les entreprises gagnent en taille et en complexité, la gestion des paquets développés en interne devient de plus en plus complexe. Alors que les gestionnaires de paquets traditionnels, comme JFrog Artifactory et Sonatype Nexus, utilisent un dépôt centralisé, GitLab adopte une approche résolument différente, adaptée aux pratiques des équipes de développement modernes. \n\nDécouvrez dans cet article comment structurer efficacement le registre de paquets de GitLab à l'échelle de votre entreprise, en prenant comme exemples les paquets Maven et npm.\n\n## Comprendre le modèle de registre de paquets de GitLab\n\nSi vous utilisez un gestionnaire de paquets traditionnel, l'approche de GitLab peut sembler différente au premier abord. Au lieu d'utiliser un dépôt centralisé unique, GitLab intègre la gestion des paquets directement dans la structure de vos projets et de vos groupes, et concrètement, cela implique que :\n\n- Vos équipes publient leurs paquets dans les projets spécifiques où réside le code source.\n- Vos équipes utilisent les paquets provenant des registres de groupe racine, qui regroupent tous les paquets des sous-projets.\n- Le contrôle d'accès hérite des autorisations que vous avez définies dans GitLab actuellement.\n\nCe modèle offre plusieurs avantages :\n\n- Une propriété claire des paquets, étroitement liée à leur code source.\n- Un contrôle d'accès granulaire, sans configuration supplémentaire.\n- Une intégration fluide et simplifiée aux pipelines CI/CD.\n- Un alignement naturel sur la structure des équipes.\n- Une URL unique permettant d'accéder à tous les paquets de l'entreprise via le groupe racine.\n\n ### La puissance du registre de paquets au niveau du groupe racine\n\nBien que GitLab prenne en charge l'utilisation de paquets à différents niveaux de groupe, l'utilisation au niveau du groupe racine est une bonne pratique adoptée par nos utilisateurs. Voici pourquoi :\n\n- **Point d'accès unique :** une seule URL permet d'accéder à l'ensemble des paquets privés de votre entreprise.\n- **Nommage cohérent des paquets :** les points de terminaison au niveau des groupes permettent aux équipes de conserver leurs conventions de nommage préférées, sans risque de conflits.\n- **Configuration simplifiée :** tous les développeurs peuvent utiliser la même configuration pour accéder aux paquets.\n- **Gestion sécurisée des accès :** associée aux tokens de déploiement, elle facilite la rotation et renforce le contrôle d'accès.\n- **Organisation hiérarchique :** elle reflète naturellement la structure de votre entreprise tout en garantissant un accès unifié.\n\n## Exemple concret : structure d'entreprise\n\nVoyons comment cela fonctionne dans la pratique avec une grande entreprise :\n\n```\ncompany/ (root group)\n├── retail-division/\n│   ├── shared-libraries/     # Division-specific shared code\n│   └── teams/\n│       ├── checkout/        # Team publishes packages here\n│       └── inventory/       # Team publishes packages here\n├── banking-division/\n│   ├── shared-libraries/    # Division-specific shared code\n│   └── teams/\n│       ├── payments/       # Team publishes packages here\n│       └── fraud/         # Team publishes packages here\n└── shared-platform/        # Enterprise-wide shared code\n    ├── java-commons/      # Shared Java libraries\n    └── ui-components/     # Shared UI components\n```\n\n### Configuration de la publication\n\nLes équipes publient leurs paquets dans les registres de leurs projets respectifs, assurant ainsi une propriété claire et bien définie :\n\n1. Exemple de paquets Maven\n\n```xml\n\u003C!-- checkout/pom.xml -->\n\u003CdistributionManagement>\n    \u003Crepository>\n        \u003Cid>gitlab-maven\u003C/id>\n        \u003Curl>${CI_API_V4_URL}/projects/${CI_PROJECT_ID}/packages/maven\u003C/url>\n    \u003C/repository>\n\u003C/distributionManagement>\n```\n\n2. Exemple de paquets npm\n\n```json\n// ui-components/package.json\n{\n  \"name\": \"@company/ui-components\",\n  \"publishConfig\": {\n    \"registry\": \"${CI_API_V4_URL}/projects/${CI_PROJECT_ID}/packages/npm/\"\n  }\n}\n```\n\n### Configuration d'utilisation des paquets\n\nC’est ici que la puissance de l'utilisation au niveau du groupe racine prend tout son sens. Toutes les équipes configurent un point de terminaison unique pour accéder aux paquets :\n\n1. Exemple de paquets Maven\n\n```xml\n\u003C!-- Any project's pom.xml -->\n\u003Crepositories>\n    \u003Crepository>\n        \u003Cid>gitlab-maven\u003C/id>\n        \u003Curl>https://gitlab.example.com/api/v4/groups/company/-/packages/maven\u003C/url>\n    \u003C/repository>\n\u003C/repositories>\n```\n\n2. Exemple de paquets npm\n\n```\n# Any project's .npmrc\n@company:registry=https://gitlab.example.com/api/v4/groups/company/-/packages/npm/\n```\n\nCette configuration fournit automatiquement un accès à l'ensemble des paquets de votre entreprise, tout en conservant les avantages d'une publication basée sur les projets.\n\n## Authentification et contrôle d'accès\n\nLe modèle de GitLab simplifie l'authentification grâce aux tokens de déploiement et à l'intégration avec les [pipelines CI/CD](https://about.gitlab.com/fr-fr/topics/ci-cd/cicd-pipeline/ \"Qu'est-ce qu'un pipeline CI/CD ? \").\n\n### Pour les pipelines CI/CD\n\nGitLab gère automatiquement l'authentification au sein des pipelines à l'aide du token `CI_JOB_TOKEN` :\n\n```yaml\n# .gitlab-ci.yml\npublish:\n  script:\n    - mvn deploy  # or npm publish\n  # CI_JOB_TOKEN provides automatic authentication\n```\n\n### Pour le développement\n\nUtilisez des tokens de déploiement définis au niveau du groupe pour accéder aux paquets, en suivant les étapes suivantes :\n\n- Créez des tokens de déploiement en lecture seule au niveau du groupe racine.\n- Effectuez régulièrement une rotation des tokens pour renforcer la sécurité. \n- Partagez une configuration unique entre tous les développeurs. \n\n## Les avantages du registre de paquets au niveau du groupe racine\n\n1. Configuration simplifiée\n   - Une seule URL pour accéder à tous les paquets.\n   - Une configuration cohérente entre toutes les équipes.\n   - Une rotation facile des tokens.\n2. Propriété claire\n   - Les paquets restent associés à leur code source.\n   - Les équipes conservent la maîtrise des publications.\n   - L'historique des versions est lié à l'activité du projet.\n3. Organisation naturelle\n   - Elle reflète fidèlement la structure de votre entreprise.\n   - Elle maintient l'autonomie de vos équipes.\n   - Elle facilite la collaboration transversale.\n\n## Étapes à suivre\n\n1. Configurez votre groupe racine\n   - Créez une structure de groupe claire.\n   - Configurez les contrôles d'accès appropriés.\n   - Créez des tokens de déploiement de groupe.\n2. Configurez les projets d'équipe\n   - Configurez la publication au niveau du projet.\n   - Intégrez les pipelines CI/CD.\n   - Documentez les conventions de nommage des paquets.\n3. Normalisez l'utilisation des paquets\n   - Configurez l'accès au registre du groupe racine.\n   - Partagez les tokens de déploiement en toute sécurité.\n   - Documentez le processus d'identification des paquets.\n\n## Résumé\n\nLe modèle de registre de paquets de GitLab, et en particulier l'utilisation au niveau du groupe racine, offre une puissante solution pour la gestion des paquets à l'échelle de l'entreprise. En combinant la publication par projet avec l'utilisation des paquets au niveau du groupe racine, les entreprises profitent des avantages de ces deux approches : une propriété claire et un accès simplifié. Cette approche évolue naturellement avec votre entreprise tout en garantissant la sécurité et la facilité d'utilisation.\n\nCommencez par mettre en œuvre ce modèle au sein d'une équipe ou d'une division pilote, puis étendez-le au reste de l'entreprise à mesure que vous constatez les avantages de cette approche intégrée. Bien que cet article se concentre sur Maven et npm, les principes évoqués ici s'appliquent à tous les types de paquets pris en charge par GitLab.\n\n> Lancez-vous avec les registres de paquets dès aujourd'hui ! Inscrivez-vous à un [essai gratuit de GitLab Ultimate](https://about.gitlab.com/fr-fr/free-trial/).\n",[704,852,979],"solutions architecture","2025-04-30",{"slug":982,"featured":92,"template":684},"structuring-the-gitlab-package-registry-for-enterprise-scale","content:fr-fr:blog:structuring-the-gitlab-package-registry-for-enterprise-scale.yml","Structuring The Gitlab Package Registry For Enterprise Scale","fr-fr/blog/structuring-the-gitlab-package-registry-for-enterprise-scale.yml","fr-fr/blog/structuring-the-gitlab-package-registry-for-enterprise-scale",{"_path":988,"_dir":248,"_draft":6,"_partial":6,"_locale":7,"seo":989,"content":995,"config":1000,"_id":1002,"_type":16,"title":1003,"_source":18,"_file":1004,"_stem":1005,"_extension":21},"/fr-fr/blog/getting-started-with-gitlab-mastering-project-management",{"title":990,"description":991,"ogTitle":990,"ogDescription":991,"noIndex":6,"ogImage":992,"ogUrl":993,"ogSiteName":719,"ogType":720,"canonicalUrls":993,"schema":994},"Premiers pas avec GitLab : comment maîtriser la gestion de projet","Découvrez les principales fonctionnalités de gestion de projet de GitLab et apprenez à les utiliser pour optimiser votre organisation et votre suivi.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097294/Blog/Hero%20Images/Blog/Hero%20Images/blog-getting-started-with-gitlab-banner-0497-option4-fy25_cFwd8DYFLekdnOLmbbChp_1750097293924.png","https://about.gitlab.com/blog/getting-started-with-gitlab-mastering-project-management","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Premiers pas avec GitLab : comment maîtriser la gestion de projet\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"GitLab\"}],\n        \"datePublished\": \"2025-02-11\",\n      }\n                  ",{"title":990,"description":991,"authors":996,"heroImage":992,"date":997,"body":998,"category":14,"tags":999,"updatedDate":976},[892],"2025-02-11","*Bienvenue dans notre nouvelle 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\nGitLab est bien plus qu'une simple plateforme de stockage de code. Il s'agit d'une plateforme DevSecOps alimentée par l'IA qui offre des outils pour vous aider à planifier, à organiser, à suivre et à livrer avec succès vos projets. Découvrez dans cet article les principales fonctionnalités de gestion de projet de GitLab et comment en tirer parti efficacement.\n\n## Pourquoi utiliser GitLab pour la gestion de projet ?\n\nImaginez que votre dépôt de code, votre gestionnaire de suivi des tickets et votre plateforme de communication soient intégrés au sein d'une seule et même plateforme. C'est la puissance de GitLab. En centralisant toutes les fonctionnalités, vous pouvez simplifier votre workflow, améliorer la collaboration et faire avancer vos projets. Vous n'avez plus besoin de passer d'un outil à l'autre et vous ne risquez plus de perdre la trace des informations. GitLab regroupe tout au même endroit, ce qui facilite la gestion de vos projets du début à la fin.\n\n## Quels sont les composants clés de la gestion de projet GitLab ? \n\nDécomposons les éléments essentiels :\n\n* [Epics](https://docs.gitlab.com/ee/user/group/epics/) : les epics vous offrent une vue d'ensemble de votre projet, regroupant les fonctionnalités majeures, ses objectifs globaux et ses initiatives à long terme. Par exemple, si vous prévoyez de refondre votre site web, vous pouvez créer un epic. Les epics vous aident à organiser votre travail en segments plus grands et gérables.  \n* [Tickets](https://docs.gitlab.com/ee/user/project/issues/) : les tickets sont les tâches ou éléments de travail individuels qui contribuent aux objectifs de votre projet. Chaque ticket représente une action spécifique, comme « concevoir la page d'accueil » ou « rédiger la page \"À propos\" ». Les tickets sont les éléments de base de votre projet. Ils fournissent un moyen clair de suivre chaque tâche.  \n* [Labels](https://docs.gitlab.com/ee/user/project/labels.html) : les labels sont comme des tags qui vous aident à catégoriser et à filtrer vos tâches. Vous pouvez utiliser des labels pour indiquer la priorité (par exemple, élevée, moyenne, faible), le statut (par exemple, « À traiter », « En cours », « Terminé ») ou attribuer des tickets à des équipes ou des membres d'équipe en particulier. Les labels offrent un moyen flexible d'organiser et de hiérarchiser vos tâches.  \n* Tableaux : les tableaux des tickets de GitLab constituent votre espace de travail visuel. Ils fournissent une vue de style Kanban de votre projet, ce qui vous permet de voir le statut de tous vos tickets en un coup d'œil. Glissez-déposez les tickets dans différentes listes (par exemple, « À traiter », « En cours », « Terminé ») pour visualiser votre workflow et suivre son avancement. Dans GitLab, vous pouvez créer des tableaux pour des [tickets](https://docs.gitlab.com/ee/user/project/issue_board.html) et des [epics](https://docs.gitlab.com/ee/user/group/epics/epic_boards.html).  \n* [Jalons](https://docs.gitlab.com/ee/user/project/milestones/) : les jalons marquent des points de contrôle importants ou des dates cibles au sein de votre projet. Ils vous aident à suivre votre progression vers les objectifs et les délais que vous vous êtes fixés. Par exemple, vous pouvez vous servir des jalons pour finaliser une fonctionnalité majeure, publier une version bêta ou lancer la version finale d'un produit.  \n* [Tâches](https://docs.gitlab.com/ee/user/tasks.html) : pour des étapes plus détaillées, décomposez vos tickets en tâches plus petites. Vous pouvez ainsi déléguer, clarifier les responsabilités individuelles et garantir que rien n'a été négligé. Les tâches permettent de créer des checklists dans les tickets, ce qui facilite le suivi des tâches complexes.\n\n## Présentation des fonctionnalités\n\n### 1. Epics : bénéficiez d'une vue d'ensemble\n\n* Création d'epics : accédez au menu « Epics » de votre groupe sous « Planification ». Cliquez sur **Nouvel epic**, puis attribuez-lui un titre descriptif et une description claire précisant son objectif. Vous pouvez également spécifier une date de début et de fin de l'epic, ce qui est particulièrement utile pour visualiser les [roadmaps](https://docs.gitlab.com/ee/user/group/roadmap/).\n\n![Page sur la création d'epics](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097301/Blog/Content%20Images/Blog/Content%20Images/image1_aHR0cHM6_1750097300817.png)\n\n* [Roadmaps](https://docs.gitlab.com/ee/user/group/roadmap/) : ajoutez vos epics à une roadmap pour visualiser le calendrier et les objectifs à long terme de votre projet. Les roadmaps fournissent une vue d'ensemble de votre projet, avec les échéances prévues et permet de suivre sa progression pour atteindre les principaux jalons.\n\n![Vue de la roadmap](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097301/Blog/Content%20Images/Blog/Content%20Images/image8_aHR0cHM6_1750097300818.png)\n\n### 2. Tickets : gagnez en productivité\n\n* Création de tickets : dans votre projet, accédez au menu « Tickets » sous « Planification » et cliquez sur **Nouveau ticket**. Fournissez un titre concis et descriptif comme « Conception des wireframes de la page d'accueil », attribuez le ticket à un membre de l'équipe, définissez une date d'échéance et ajoutez une description détaillée décrivant les exigences de la tâche.  \n* GitLab Duo : tirez parti de la puissance de [GitLab Duo, notre suite de fonctionnalités alimentée par l'IA pour générer des descriptions détaillées pour vos tickets](https://docs.gitlab.com/ee/user/project/issues/managing_issues.html#populate-an-issue-with-issue-description-generation) en indiquant en quelques mots ce que vous voulez réaliser.  \n* Pondération : estimez l'effort requis pour chaque ticket en lui assignant un poids. Cela facilite la planification et la priorisation. Par exemple, une tâche simple peut avoir un poids de **1**, tandis qu'une tâche plus complexe aura un poids de **5**.\n\n![Ticket auquel un poids de 4 a été attribué](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097301/Blog/Content%20Images/Blog/Content%20Images/image4_aHR0cHM6_1750097300819.png)\n\n### 3. Labels : organisez votre travail\n\n* Création de labels : accédez à l'onglet « Gestion » de votre projet et cliquez sur « Labels ». Créez des labels personnalisés avec des intitulés explicites pour catégoriser vos tickets. Par exemple, créez des labels **Priorité : Élevée**, **Statut : En cours** ou **Équipe : Design**. Appliquez ces labels à vos tickets pour les organiser et les filtrer facilement.\n\n![Écran Labels](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097301/Blog/Content%20Images/Blog/Content%20Images/image6_aHR0cHM6_1750097300820.png)\n\n### 4. Tableaux : visualisez votre workflow\n\n* Tableaux Kanban : les tableaux des tickets de GitLab offrent une vue de style Kanban pour visualiser l'avancement de votre projet. Créez des listes (« À faire », « En cours » et « Terminé ») pour représenter les étapes de votre workflow. Ensuite, glissez-déposez les tickets dans ces listes pour visualiser leur progression.\n* Personnalisation des tableaux : personnalisez vos tableaux en fonction de votre workflow. Ajoutez plus de colonnes, filtrez les tickets par labels ou personnes assignées, et configurez des swimlanes pour catégoriser les tickets par epics ou en fonction d'autres critères.\n\n![Visualiser le workflow avec les tableaux des tickets](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097301/Blog/Content%20Images/Blog/Content%20Images/image2_aHR0cHM6_1750097300820.png)\n\n### 5. Tâches : décomposez votre travail\n\n* Création de tâches : dans un ticket, utilisez la syntaxe Markdown pour créer une checklist afin de créer une liste de tâches. Chaque élément de la liste représente une sous-étape du ticket. Par exemple, dans le ticket « Conception des wireframes de la page d'accueil », vous pouvez avoir des tâches telles que « Esquisser les concepts initiaux », « Créer des wireframes numériques » et « Obtenir le retour des parties prenantes ». Pour créer une tâche, cliquez sur le bouton **Ajouter** dans la section « Éléments enfants » de la page d'un ticket, puis saisissez le titre de la tâche et cliquez sur **Créer une tâche**.\n\n![Ticket avec le bouton Créer une tâche](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097301/Blog/Content%20Images/Blog/Content%20Images/image7_aHR0cHM6_1750097300822.png)\n\n### 6. Jalons : suivez l'avancement de votre projet\n* Spécification des jalons : définissez des jalons pour marquer les étapes importantes de votre projet, comme l'achèvement d'une fonctionnalité spécifique ou l'atteinte d'une échéance clé. Attribuez à chaque jalon un titre précis ainsi que des dates d'échéance.\n* Ajout de relations aux tickets : reliez les tickets et les epics aux jalons pour suivre les progrès vers ces objectifs. Vous pouvez ainsi identifier comment chaque tâche contribue au projet global.\n* Création d'un jalon : dans le menu déroulant « Planification », cliquez sur **Jalons > Nouveau jalon**. Spécifiez le titre, la description et les dates de début et de fin du jalon.\n\n![Écran Nouveau jalon](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097301/Blog/Content%20Images/Blog/Content%20Images/image5_aHR0cHM6_1750097300823.png)\n\n\u003Cbr>\u003C/br>\n\n![Nouvelle page affichant un jalon](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097301/Blog/Content%20Images/Blog/Content%20Images/image3_aHR0cHM6_1750097300823.png)\n\n### 7. Itérations : utilisez les sprints\n\n* Planification d'[itérations](https://docs.gitlab.com/ee/user/group/iterations/) : si vous suivez l'approche Agile pour votre workflow, définissez des itérations (sprints) avec des dates de début et de fin spécifiques. Cette démarche vous permet de décomposer votre travail à intervalles de temps plus courts et plus faciles à gérer.  \n* Attribution des tickets : attribuez des tickets à ces itérations pour planifier votre travail en cycles plus courts et vous concentrer sur la création continue de valeur ajoutée.\n\n### 8. Suivi du temps : mesurez vos efforts\n\n* Consignation des heures : dans un ticket, utilisez l'action rapide « /spend » suivie du temps passé (par exemple, « /spend 2h 30m ») pour consigner votre travail. Vous pouvez ainsi [suivre le temps réel passé sur chaque tâche](https://docs.gitlab.com/ee/user/project/time_tracking.html).  \n* Analyse des données : générez des rapports de suivi du temps pour évaluer l'avancement du projet, mesurer l'efficacité de l'équipe et identifier d'éventuels goulots d'étranglement.\n\n![Rapport de suivi du temps](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097301/Blog/Content%20Images/Blog/Content%20Images/image9_aHR0cHM6_1750097300824.png)\n\n### 9. Dépendances : gérez votre workflow\n\n* [Liaison entre les tickets](https://docs.gitlab.com/ee/user/project/issues/related_issues.html) : créez des dépendances entre les tickets pour vous assurer que les tâches sont effectuées dans le bon ordre. Par exemple, si le ticket A doit être terminé avant que le ticket B ne puisse commencer, vous pouvez créer une dépendance entre les deux. De cette manière, vous visualisez votre workflow et évitez les blocages potentiels.\n\n### 10. Templates : optimisez la création de tickets\n\n* [Création de templates](https://docs.gitlab.com/ee/user/project/description_templates.html) : créez des templates de tickets pour standardiser les informations saisies lors de tâches courantes. Vous gagnez ainsi du temps et garantissez la cohérence. Par exemple, vous pouvez créer un template de rapport de bogue qui inclut des champs reprenant les étapes de reproduction du comportement attendu et du comportement réel.\n\n### La collaboration, la clé d'un projet réussi\n\nGitLab favorise la collaboration grâce aux fonctionnalités suivantes :\n\n* [Commentaires](https://docs.gitlab.com/ee/user/discussions/) : discutez des tickets et des epics directement dans GitLab. Utilisez les commentaires pour informer les équipes de l'avancement du projet, poser des questions et partager vos retours.  \n* [Mentions](https://docs.gitlab.com/ee/user/discussions/#mentions) : utilisez le signe **@** pour mentionner des membres spécifiques de l'équipe et les informer de l'avancement du projet ou demander leur contribution.  \n* Discussions : échangez directement dans le fil de discussion au sein des tickets et epics pour réfléchir à des idées ou pour résoudre des problèmes ensemble et tenir informés tous les participants impliqués.\n\n### Lancez-vous sur GitLab dès aujourd’hui !\n\nMaintenant que vous avez exploré la puissance des fonctionnalités de gestion de projet de GitLab, il est temps de les mettre en pratique ! Créez un exemple de projet, testez différentes fonctionnalités et découvrez comment GitLab peut transformer votre workflow. Consultez notre documentation de GitLab pour en savoir plus sur la mise en place d'un workflow basé sur les méthodes [Kanban](https://docs.gitlab.com/ee/tutorials/kanban/) et [Scrum](https://docs.gitlab.com/ee/tutorials/scrum_events/).\n\n>  #### Vous n'avez pas encore de compte GitLab ? Inscrivez-vous à un [essai gratuit de GitLab Ultimate et GitLab Duo](https://about.gitlab.com/fr-fr/free-trial/) dès aujourd'hui !\n\n## En savoir plus\n- [Premiers pas avec GitLab : comment gérer les utilisateurs](https://about.gitlab.com/fr-fr/blog/getting-started-with-gitlab-how-to-manage-users/)\n- [Premiers pas avec GitLab : 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",[852,14,830,937],{"slug":1001,"featured":6,"template":684},"getting-started-with-gitlab-mastering-project-management","content:fr-fr:blog:getting-started-with-gitlab-mastering-project-management.yml","Getting Started With Gitlab Mastering Project Management","fr-fr/blog/getting-started-with-gitlab-mastering-project-management.yml","fr-fr/blog/getting-started-with-gitlab-mastering-project-management",{"_path":1007,"_dir":248,"_draft":6,"_partial":6,"_locale":7,"seo":1008,"content":1014,"config":1022,"_id":1024,"_type":16,"title":1025,"_source":18,"_file":1026,"_stem":1027,"_extension":21},"/fr-fr/blog/from-code-to-production-a-guide-to-continuous-deployment-with-gitlab",{"title":1009,"description":1010,"ogTitle":1009,"ogDescription":1010,"noIndex":6,"ogImage":1011,"ogUrl":1012,"ogSiteName":719,"ogType":720,"canonicalUrls":1012,"schema":1013},"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":1009,"description":1010,"authors":1015,"heroImage":1011,"date":1018,"body":1019,"category":14,"tags":1020,"updatedDate":1021},[1016,1017],"Benjamin Skierlak","James Wormwell","2025-01-28","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.",[854,110,705,14,852],"2025-03-24",{"slug":1023,"featured":6,"template":684},"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":1029,"_dir":248,"_draft":6,"_partial":6,"_locale":7,"seo":1030,"content":1036,"config":1042,"_id":1044,"_type":16,"title":1045,"_source":18,"_file":1046,"_stem":1047,"_extension":21},"/fr-fr/blog/getting-started-with-gitlab-how-to-import-your-projects-to-gitlab",{"title":1031,"description":1032,"ogTitle":1031,"ogDescription":1032,"noIndex":6,"ogImage":1033,"ogUrl":1034,"ogSiteName":719,"ogType":720,"canonicalUrls":1034,"schema":1035},"Premiers pas avec GitLab : comment importer vos projets dans GitLab","Découvrez comment importer vos projets depuis diverses sources, notamment Bitbucket, Gitea, GitHub et GitLab Self-Managed.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097248/Blog/Hero%20Images/Blog/Hero%20Images/blog-getting-started-with-gitlab-banner-0497-option4-fy25_cFwd8DYFLekdnOLmbbChp_1750097247785.png","https://about.gitlab.com/blog/getting-started-with-gitlab-how-to-import-your-projects-to-gitlab","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Premiers pas avec GitLab : comment importer vos projets dans GitLab\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Abubakar Siddiq Ango\"}],\n        \"datePublished\": \"2025-01-28\",\n      }\n                  ",{"title":1031,"description":1032,"authors":1037,"heroImage":1033,"date":1018,"body":1039,"category":14,"tags":1040,"updatedDate":1041},[1038],"Abubakar Siddiq Ango","*Bienvenue dans notre nouvelle 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\nL'importation de projets est une compétence essentielle qui vous permet de tirer le meilleur parti de la plateforme DevSecOps de GitLab. Une fois que vous avez [configuré votre compte](https://university.gitlab.com/pages/getting-started) et invité des utilisateurs que vous avez [organisés](https://about.gitlab.com/fr-fr/blog/getting-started-with-gitlab-how-to-manage-users/) en fonction de votre cas d'utilisation ou de la structure de votre équipe, vous devez importer vos projets existants dans GitLab et commencer à travailler en équipe. Ces projets peuvent inclure des fichiers locaux situés sur votre ordinateur ou hébergés sur une autre plateforme de gestion de code source. Explorons ensemble les options se trouvant à votre disposition.\n\n## Importation de fichiers de projets locaux\n\nVous n'avez pas besoin de repartir de zéro chaque fois que vous importez un projet. Suivez les étapes ci-dessous pour accéder aux projets ou applications GitLab existants, qu'ils utilisent ou non le [contrôle de version](https://about.gitlab.com/fr-fr/topics/version-control/ \"Qu'est-ce que le contrôle de version ?\").\n\n### Projet Git\n\n1. Si Git est [déjà lancé](https://docs.gitlab.com/ee/topics/git/commands.html#git-init) dans votre projet local, créez un projet dans GitLab et obtenez l'URL SSH ou HTTPS en cliquant sur le bouton **Code** en haut à droite de la page de votre projet.\n\n![Créer un projet dans GitLab avec des URL SSH/HTTPS](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097254/Blog/Content%20Images/Blog/Content%20Images/image8_aHR0cHM6_1750097252717.png)\n\n2. Ouvrez votre terminal et assurez-vous d'être dans le dossier dans lequel se trouve votre projet :\n\n```bash  \ncd /project_folder\n```\n\n3. Sauvegardez votre [serveur origin Git](https://git-scm.com/book/fr/v2/Les-bases-de-Git-Travailler-avec-des-d%c3%a9p%c3%b4ts-distants) existant :\n\n```bash\n\ngit remote rename origin old-origin\n\n```\n\n4. Ajoutez l'URL du [dépôt distant GitLab](https://git-scm.com/book/fr/v2/Les-bases-de-Git-Travailler-avec-des-d%c3%a9p%c3%b4ts-distants) pour le nouveau serveur origin, lors de l'utilisation de SSH :\n\n```bash  \ngit remote add origin [git@gitlab.com](mailto:git@gitlab.com):gitlab-da/playground/abubakar/new-test-repo.git\n```\n\nEt pour HTTPS : \n\n```bash  \ngit remote add origin https://gitlab.com/gitlab-da/playground/abubakar/new-test-repo.git\n```\n\n5. Ensuite, effectuez un push de l'ensemble des [branches](https://docs.gitlab.com/ee/user/project/repository/branches/) et [tags](https://docs.gitlab.com/ee/user/project/repository/tags/) existants vers GitLab :\n\n```bash  \ngit push --set-uptream origin --all  \ngit push --set-uptream origin --tags\n```\n\nL'intégralité des fichiers, branches et tags de votre projet feront l'objet d'un push vers GitLab et vous pourrez commencer à travailler en équipe.\n\n### Projet autre que Git\n\nSi vous n'avez pas lancé Git dans votre projet, vous devez initialiser Git, valider les fichiers existants et effectuer un push vers GitLab comme suit :\n\n```bash  \ngit init --initial-branch=main  \ngit remote add origin git@gitlab.com:gitlab-da/playground/abubakar/new-test-repo.git  \ngit add .  \ngit commit -m \"Initial commit\"  \ngit push --set-upstream origin main  \n```\n\n## Importation à partir de sources en ligne\n\nSi votre projet est hébergé sur GitLab.com ou d'autres plateformes et que vous souhaitez le déplacer vers une autre instance GitLab (comme GitLab Self-Managed) ou d'une autre plateforme vers GitLab.com, GitLab met à votre disposition une fonctionnalité d'importation de projet lorsque vous souhaitez créer un projet.\n\n![Écran Créer un projet](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097253/Blog/Content%20Images/Blog/Content%20Images/image7_aHR0cHM6_1750097252718.png)\n\nL'importation d'un projet migre les fichiers associés et certains autres composants du projet en fonction de la source. Vous pouvez importer des projets à partir de différentes sources, notamment Bitbucket, GitHub, Gitea et une instance GitLab. Les sources d'importation sont activées par défaut sur GitLab.com, mais un administrateur doit les [activer pour GitLab Self-Managed](https://docs.gitlab.com/ee/administration/settings/import_and_export_settings.html#configure-allowed-import-sources). Nous examinerons quelques-unes de ces sources dans les sections suivantes.\n\n![Importer un projet à partir de sources tierces](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097253/Blog/Content%20Images/Blog/Content%20Images/image6_aHR0cHM6_1750097252719.png)\n\n## Sources GitLab\n\nVous pouvez exporter des projets issus des instances GitLab.com et GitLab Self-Managed à l'aide de la fonctionnalité __Exporter le projet__, disponible dans les paramètres du projet concerné. \n\n![Écran Exporter un projet](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097253/Blog/Content%20Images/Blog/Content%20Images/image9_aHR0cHM6_1750097252720.png)\n\nVoici comment procéder :\n\n- Accédez aux paramètres de votre projet et cliquez sur **Général**.\n- Faites défiler jusqu'à la section **Paramètres avancés** et développez-la.\n- Sélectionnez **Exporter le projet**.\n- La notification « L'exportation du projet a commencé. Un lien de téléchargement sera envoyé par e-mail et sera disponible sur cette page » s'affiche.\n- Une fois l'exportation générée, vous pouvez suivre le lien contenu dans l'e-mail ou actualiser la page des paramètres du projet pour afficher l'option « Télécharger l'export ».\n\n### Importation du projet\n\n![Importer un projet GitLab exporté](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097253/Blog/Content%20Images/Blog/Content%20Images/image10_aHR0cHM6_1750097252722.png)\n\n- Cliquez sur le bouton **Nouveau projet** dans votre instance GitLab cible.  \n- Sélectionnez **Importer un projet** et cliquez sur **Export GitLab** dans la liste des sources d'importation.  \n- Spécifiez le nom du projet et sélectionnez le fichier d'exportation, puis cliquez sur **Importer un projet**.  \n- Une page « Importation en cours » s'affiche, avant de vous rediriger vers le projet importé.\n\nLe délai nécessaire à l'importation dépend de la taille de votre projet. Vous ne pouvez pas exporter tous les composants d'un projet et certains éléments peuvent changer après l'importation. Pour comprendre les limitations, consultez notre [documentation](https://docs.gitlab.com/ee/user/project/settings/import_export.html#export-a-project-and-its-data). Si vous souhaitez migrer un groupe entier au lieu de projets individuels, la [méthode de transfert direct](https://docs.gitlab.com/ee/user/group/import/index.html) est recommandée, car elle permet de créer une copie d'un groupe entier.\n\n## Fournisseurs tiers\n\nGitLab prend en charge l'importation depuis Bitbucket Cloud, Bitbucket Server, FogBugz, Gitea et GitHub. Le processus d'importation est similaire pour tous les fournisseurs tiers pris en charge, sauf en ce qui concerne la méthode d'authentification. Voyons cela plus en détail.\n\n### GitHub\n\n![Écran Authentification avec GitHub](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097253/Blog/Content%20Images/Blog/Content%20Images/image3_aHR0cHM6_1750097252723.png)\n\nIl existe trois méthodes pour importer des projets GitHub dans GitLab :\n\n- [Utilisation du protocole d'autorisation OAuth de GitHub](https://docs.gitlab.com/ee/user/project/import/github.html#use-github-oauth)\n- [Utilisation d'un jeton d'accès personnel GitHub](https://docs.gitlab.com/ee/user/project/import/github.html#use-a-github-personal-access-token)\n- [Utilisation de l'API](https://docs.gitlab.com/ee/user/project/import/github.html#use-the-api)\n\nLes importations à l'aide du protocole OAuth de GitHub et du jeton d'accès personnel sont similaires. La différence réside dans la façon dont vous autorisez GitLab à accéder à vos dépôts. La méthode OAuth est plus facile : vous cliquez sur le bouton « Autoriser avec GitHub » qui vous redirige alors vers votre compte GitHub pour autoriser la connexion. Ensuite, la liste de vos projets est chargée et vous pouvez choisir ceux que vous souhaitez importer.\n\n![Écran Importer des dépôts depuis GitHub](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097253/Blog/Content%20Images/Blog/Content%20Images/image2_aHR0cHM6_1750097252725.png)\n\nVous pouvez également générer un jeton d'accès personnel GitHub, en sélectionnant les portées `repo` et `read:org`, puis le spécifier sur la page « Import ».  Pour les importations d'API, vous pouvez utiliser le même jeton d'accès personnel avec nos points de terminaison d'[API REST](https://about.gitlab.com/fr-fr/blog/what-is-rest-api/ \"API REST\") dédiés à l'importation dans votre script ou votre application. Pour en savoir plus, [consultez notre documentation](https://docs.gitlab.com/api/import/#import-repository-from-github). \n\nDans cette démonstration, Fernando Diaz, Senior Developer Advocate chez GitLab, explique comment importer un projet depuis GitHub à l'aide de la méthode OAuth :\n\n\u003C!-- blank line -->  \n\u003Cfigure class=\"video_container\"> \n  \u003Ciframe src=\"https://www.youtube.com/embed/0Id5oMl1Kqs?si=esF6wbz2j2JlhDVL\" frameborder=\"0\" allowfullscreen=\"true\"> \u003C/iframe>  \n\u003C/figure>\n\u003C!-- blank line -->\n\nPour en savoir plus, notamment sur les prérequis, les problèmes connus et l'importation depuis GitHub Enterprise, consultez notre [documentation sur l'importation](https://docs.gitlab.com/ee/user/project/import/github.html) de GitLab.\n\n### Bitbucket\n\nL'importation de projets depuis Bitbucket est similaire à l'importation de projets depuis GitHub. Bien que l'utilisation du protocole OAuth s'applique à [Bitbucket Cloud](https://docs.gitlab.com/ee/user/project/import/bitbucket.html), la version SaaS de Bitbucket, vous devez fournir une URL, un nom d'utilisateur et un jeton d'accès personnel pour [Bitbucket Server](https://docs.gitlab.com/ee/user/project/import/bitbucket_server.html), la version auto-hébergée pour les entreprises. En cliquant sur l'option Bitbucket Cloud sur l'écran « Import », vous accédez automatiquement à l'authentification Atlassian pour Bitbucket.\n\n![Importer un projet depuis BitBucket](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097253/Blog/Content%20Images/Blog/Content%20Images/image4_aHR0cHM6_1750097252726.png)\n\nVous pouvez également importer des projets Bitbucket à l'aide de l'[API d'importation GitLab](https://docs.gitlab.com/ee/api/import.html).\n\n### Gitea\n\n![Importer un projet depuis Gitea](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097253/Blog/Content%20Images/Blog/Content%20Images/image5_aHR0cHM6_1750097252727.png)\n\nL'importation de projets depuis [Gitea](https://docs.gitlab.com/ee/user/project/import/gitea.html) nécessite de créer un [jeton d'accès personnel](https://docs.gitea.com/next/development/api-usage#authentication-via-the-api) sur la plateforme Gitea, puis de l'indiquer avec l'URL du serveur Gitea sur la page d'importation GitLab. L'authentification OAuth n'est pas prise en charge. \n\n### Dépôt Git générique distant\n\n![Importer un projet à partir d'un dépôt Git distant](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097253/Blog/Content%20Images/Blog/Content%20Images/image1_aHR0cHM6_1750097252728.png)\n\nLorsque votre fournisseur Git n'est pas pris en charge ou que l'importation n'est pas possible à l'aide des méthodes disponibles, vous pouvez importer un dépôt à l'aide de son URL `https://` ou `git://` accessible.  Si l'URL n'est pas publique, fournissez l'URL du dépôt ainsi que le nom d'utilisateur et le mot de passe (ou le jeton d'accès, le cas échéant, dans le cas d'une authentification multifacteur).\n\nVous pouvez également utiliser cette méthode pour tenir à jour une copie d'un projet distant et la synchroniser, par exemple dans le cadre d'une [mise en miroir](https://docs.gitlab.com/ee/user/project/repository/mirror/). La mise en miroir vous permet de maintenir des dépôts sur différentes plateformes et de les synchroniser. Vous pouvez par exemple séparer l'accès privé et public au projet tout en veillant à ce que les deux versions restent identiques, ce notamment lors de la mise à disposition en open source de projets internes. La mise en miroir est également utilisée lorsque vous travaillez avec des sous-traitants sur des plateformes différentes qui nécessitent un accès partagé au code base. \n\n## Lancez-vous sur GitLab dès aujourd’hui !\n\nL'importation et la migration entre différentes instances GitLab, et à partir d'autres sources, sont des étapes importantes qui doivent faire l'objet d'une planification rigoureuse. Il est essentiel de définir clairement les attentes concernant les éléments importés et la méthode utilisée. Bien que la plupart des solutions tierces permettent d'importer divers éléments d'un projet, notamment des fichiers, des tickets et des merge requests, certaines approches présentent des problèmes et des limitations connus. Notre [documentation GitLab dédiée à l'Importation de projets](https://docs.gitlab.com/ee/user/project/import/) fournit des informations détaillées sur toutes les méthodes prises en charge qui peuvent vous aider à planifier votre migration.   \n\n> #### Vous souhaitez approfondir vos connaissances ? [Inscrivez-vous à GitLab University](https://university.gitlab.com/). Vous pouvez également vous lancer immédiatement avec [un essai gratuit de GitLab Ultimate](https://about.gitlab.com/fr-fr/free-trial/devsecops/).\n",[14,852,830],"2025-02-13",{"slug":1043,"featured":6,"template":684},"getting-started-with-gitlab-how-to-import-your-projects-to-gitlab","content:fr-fr:blog:getting-started-with-gitlab-how-to-import-your-projects-to-gitlab.yml","Getting Started With Gitlab How To Import Your Projects To Gitlab","fr-fr/blog/getting-started-with-gitlab-how-to-import-your-projects-to-gitlab.yml","fr-fr/blog/getting-started-with-gitlab-how-to-import-your-projects-to-gitlab",{"_path":1049,"_dir":248,"_draft":6,"_partial":6,"_locale":7,"seo":1050,"content":1056,"config":1063,"_id":1065,"_type":16,"title":1066,"_source":18,"_file":1067,"_stem":1068,"_extension":21},"/fr-fr/blog/how-to-install-gitlab-beginners-guide",{"ogTitle":1051,"schema":1052,"ogImage":1053,"ogDescription":1054,"ogSiteName":719,"noIndex":6,"ogType":720,"ogUrl":1055,"title":1051,"canonicalUrls":1055,"description":1054},"Installation de GitLab : guide pour faire vos premiers pas","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Installation de GitLab : guide pratique pour faire vos premiers pas sur la plateforme DevSecOps\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"GitLab France Team\"}],\n        \"datePublished\": \"2025-01-15\",\n      }","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749665010/Blog/Hero%20Images/installation-gitlab.jpg","Découvrez dans ce guide pratique tout ce que vous devez savoir sur la plateforme DevSecOps de GitLab, ainsi qu’un tutoriel pour installer GitLab Self-Managed.","https://about.gitlab.com/blog/how-to-install-gitlab-beginners-guide",{"title":1057,"description":1054,"authors":1058,"heroImage":1053,"date":1060,"body":1061,"category":14,"tags":1062},"Installation de GitLab : guide pratique pour faire vos premiers pas sur la plateforme DevSecOps",[1059],"GitLab France Team","2025-01-15","Si vous travaillez sur des projets de développement logiciel, la plateforme\nDevSecOps de GitLab doit certainement susciter votre intérêt. GitLab, c'est\nun ensemble de fonctionnalités intégrées au sein d'une même plateforme, vous\npermettant d'accélérer votre [livraison de\nlogiciels](https://about.gitlab.com/fr-fr/platform/ \"Livraison de\nlogiciels\"), de façon sécurisée et indépendante des fournisseurs de services\ncloud.\n\n\nPour faire vos premiers pas, ce tutoriel GitLab vous présente le fonctionnement global de la plateforme, ainsi que les principales méthodes pour [installer GitLab Self-Managed](https://about.gitlab.com/fr-fr/install/ \"Installer GitLab Self-Managed\").\n\n\n## Comment fonctionne GitLab ?\n\n\nGitLab est bien plus qu'un gestionnaire de dépôt [Git](https://about.gitlab.com/fr-fr/blog/what-is-git/ \"Qu'est-ce que Git ? \"). C'est une plateforme collaborative qui réunit les différentes équipes chargées du développement, de la sécurité et des opérations d'une entreprise. Elles peuvent collaborer efficacement grâce à une suite de fonctionnalités complètes et facilement intégrables à d'autres solutions et environnements technologiques.\n\n\nGitLab permet aux entreprises de livrer des logiciels de qualité toujours plus rapidement en intégrant au sein de sa plateforme DevSecOps toutes les [étapes essentielles du cycle du développement logiciel](https://about.gitlab.com/fr-fr/stages-devops-lifecycle/ \"Etapes du cycle du développement logiciel\") :\n\n\n- __La planification :__ organisation, planification, coordination et suivi de l'ensemble des projets.\n\n\n- __La création :__ création, consultation, gestion du code et des données des projets.\n\n\n- __La vérification :__ maintien des normes de qualité strictes pour le code à l’aide de tests et de rapports automatisés.\n\n\n- __L’empaquetage :__ création d'une chaîne d'approvisionnement logicielle fiable et cohérente avec la gestion des paquets.\n\n\n- __La sécurité :__ livraison de logiciels sécurisés et conformes avec les tests statiques de sécurité des applications (SAST), les tests dynamiques de sécurité des applications (DAST), l’analyse de conteneurs et l’analyse des dépendances.\n\n\n- __Le déploiement :__ automatisation de la phase de release et de livraison de logiciels, raccourcissement du cycle de développement logiciel, rationalisation des processus manuels, et plus encore.\n\n\n- __La surveillance :__ réduction de la fréquence et du niveau de gravité des incidents.\n\n\n- __La conformité :__ gestion des failles de sécurité, contrôle des stratégies de sécurité et de la conformité de votre entreprise.\n\n\nÀ chaque étape, la [plateforme DevSecOps de GitLab](https://about.gitlab.com/fr-fr/platform/ \"Plateforme DevSecOps de GitLab\") permet d'améliorer le workflow des équipes de développement, notamment avec l'aide de GitLab Duo, notre suite de fonctionnalités alimentées par l'IA. [GitLab Duo](https://about.gitlab.com/fr-fr/gitlab-duo/ \"GitLab Duo\") permet de booster la productivité des équipes à toutes les étapes du cycle du développement logiciel, de la planification à la surveillance, en passant par le code et les tests.\n\n\nL'architecture GitLab s'adapte à toutes les configurations, du simple projet individuel à des réalisations de grands groupes internationaux. Avant d'installer GitLab, choisissez la manière dont vous souhaitez utiliser notre plateforme : en SaaS ou Self-Managed. Pour en savoir plus, consultez notre [page de tarification](https://about.gitlab.com/fr-fr/pricing/ \"Page de tarification de GitLab\").\n\n\nSi votre choix se porte sur GitLab Self-Managed, découvrez dans cet article ses principales méthodes d’installation.\n\n\n## Comment installer GitLab Self-Managed ?\n\n\nGitLab est une plateforme de développement logiciel flexible. Elle peut être installée sur de nombreux environnements et systèmes d'exploitation Linux tels que Ubuntu, Debian, AlmaLinux, CentOS 7, et plus encore. En environnement Cloud, GitLab est pris en charge par les plateformes majeures telles qu'Amazon Web Services, Google Cloud Platform, ou encore Microsoft Azure.\n\n\nParmi tous ces [environnements d'installation de GitLab](https://about.gitlab.com/fr-fr/install/ \"Installer GitLab Self-Managed\") disponibles, vous trouverez très certainement celui que vous avez l'habitude d'utiliser. Pour cet article, nous focaliserons notre attention sur certains d’entre eux.\n\n\n### Installation de GitLab sur Linux\n\n\nLe paquet Linux est la méthode d’installation recommandée par GitLab. Également appelé Omnibus, ce paquet regroupe tous les services et outils nécessaires à l'exécution de GitLab.\n\n\n__Instructions relatives à l’[installation de GitLab sur Ubuntu](https://about.gitlab.com/fr-fr/install/#ubuntu \"Installation de GitLab sur Ubuntu\") :__\n\n\n1. __Téléchargez votre paquet Linux officiel__\n\n\nAssurez-vous de télécharger le paquet adapté à votre distribution Linux, parmi les [différentes versions disponibles](https://packages.gitlab.com/gitlab/gitlab-ee \"gitlab-ee\").\n\n\n2. __Installez et configurez les dépendances nécessaires__\n\n\n`sudo apt-get update`\n\n\n`sudo apt-get install -y curl openssh-server ca-certificates tzdata perl`\n\n\nPuis installez Postfix ou Sendmail pour envoyer vos e-mails de notification. Si vous souhaitez utiliser un autre serveur de messagerie électronique, ignorez cette étape.\n\n\n`sudo apt-get install -y postfix`\n\n\nPendant l'installation de Postfix, il se peut qu'une fenêtre de configuration s'affiche. Dans ce cas, sélectionnez « Site Internet » puis appuyez sur « Entrée ». Saisissez le DNS externe de votre serveur dans le champ « Nom de l'e-mail » et appuyez sur « Entrée ». Si d'autres fenêtres s'affichent, appuyez à nouveau sur « Entrée » pour accepter les paramètres par défaut.\n\n\n3. __Ajoutez le dépôt de paquets GitLab et installez le paquet__\n\n\n`curl https://packages.gitlab.com/install/repositories/gitlab/gitlab-ee/script.deb.sh | sudo bash`\n\n\nInstallez ensuite le paquet GitLab, configurez votre DNS puis remplacez https://gitlab.example.com/ par l’URL à laquelle vous voulez accéder à votre instance GitLab. Pour les URL avec le protocole « https:// », GitLab vous demande automatiquement un certificat Let's Encrypt. Vous pouvez également utiliser votre propre certificat ou le protocole « http:// ». Ensuite, choisissez entre un mot de passe personnalisé ou généré aléatoirement.\n\n\n`sudo EXTERNAL_URL=\"https://gitlab.example.com\" apt-get install gitlab-ee`\n\n\n`# List available versions: apt-cache madison gitlab-ee`\n\n\n`# Specifiy version: sudo EXTERNAL_URL=\"https://gitlab.example.com\" apt-get install gitlab-ee=16.2.3-ee.0`\n\n\n`# Pin the version to limit auto-updates: sudo apt-mark hold gitlab-ee`\n\n\n`# Show what packages are held back: sudo apt-mark showhold`\n\n\n4. __Accédez au nom d'hôte__\n\n\nSi vous optez pour un mot de passe généré aléatoirement, ce dernier sera stocké dans « /etc/gitlab/initial_root_password » pendant 24 heures. Pour vous connecter, utilisez ce mot de passe avec le nom d'utilisateur « root ».\n\n\n5. __Choisissez vos préférences de communication__\n\n\nVous pouvez décider pour quelles raisons et à quelle fréquence vous recevrez des nouvelles de GitLab. Inscrivez-vous à la newsletter dédiée à la sécurité pour être informés des alertes.\n\n\nRetrouvez en détail l'[installation de GitLab sur Ubuntu](https://about.gitlab.com/fr-fr/install/#ubuntu \"Installation de GitLab sur Ubuntu\"), ainsi que les étapes additionnelles recommandées pour [finaliser votre installation](https://docs.gitlab.com/ee/install/next_steps.html).\n\n\n### Installation de GitLab sur Docker\n\n\nPour [installer GitLab sur Docker](https://docs.gitlab.com/ee/install/docker/installation.html \"Installer GitLab sur Docker\"), assurez-vous d’avoir une installation Docker fonctionnelle (autre que Docker pour Windows), un agent de transfert de courrier (tel que Postfix ou Sendmail), ainsi qu’un nom d'hôte valide et accessible de l'extérieur (différent de `locahost`).\n\n\n__Instructions relatives à l'installation de GitLab sur Docker :__\n\n\n1. __Configurez le port SSH__\n\n\nGitLab utilise par défaut le port 22 pour interagir avec Git. Pour utiliser un autre port SSH, référez-vous à [notre documentation](https://docs.gitlab.com/ee/install/docker/installation.html#configure-the-ssh-port).\n\n\n2. __Créez un répertoire pour les volumes__\n\n\nCréez un répertoire `sudo mkdir -p /srv/gitlab` pour les fichiers de configuration, les journaux et les fichiers de données. Ce répertoire peut se trouver dans le répertoire personnel de l'utilisateur (par exemple `~/gitlab-docker`), ou dans un répertoire comme `/srv/gitlab`. Si vous exécutez Docker avec un utilisateur autre que `root`, accordez les permissions appropriées à l'utilisateur pour le nouveau répertoire.\n\n\nConfigurez ensuite une nouvelle variable d'environnement `$GITLAB_HOME` qui définit le chemin vers le répertoire que vous avez créé : `export GITLAB_HOME=/srv/gitlab`.\n\n\n3. __Trouvez la version et l'édition de GitLab à utiliser__\n\n\nRattachez votre déploiement à une version spécifique de GitLab. Passez en revue les versions disponibles et choisissez celle que vous souhaitez utiliser dans la page des balises Docker : [GitLab Enterprise Edition](https://hub.docker.com/r/gitlab/gitlab-ee/tags/ \"GitLab Enterprise Edition\") ou [GitLab Community Edition](https://hub.docker.com/r/gitlab/gitlab-ce/tags/ \"GitLab Community Edition\").\n\n\n4. __Choisissez une méthode d'installation__\n\n\nPour installer GitLab sur Docker, trois options s’offrent à vous : Docker Compose, Docker Engine ou Docker Swarm mode. Dans le cadre de cet article, nous allons nous intéresser uniquement à Docker Compose qui est la méthode d’installation recommandée.\n\n\n[Installez Docker Compose](https://docs.docker.com/compose/install/linux/ \"Installation de Docker Compose\"), puis créez un fichier `docker-compose.yml`. Par exemple :\n\n\n```\n\nversion: '3.6'\n\nservices:\n  gitlab:\n    image: gitlab/gitlab-ee:\u003Cversion>-ee.0\n    container_name: gitlab\n    restart: always\n    hostname: 'gitlab.example.com'\n    environment:\n      GITLAB_OMNIBUS_CONFIG: |\n        # Add any other gitlab.rb configuration here, each on its own line\n        external_url 'https://gitlab.example.com'\n    ports:\n      - '80:80'\n      - '443:443'\n      - '22:22'\n    volumes:\n      - '$GITLAB_HOME/config:/etc/gitlab'\n      - '$GITLAB_HOME/logs:/var/log/gitlab'\n      - '$GITLAB_HOME/data:/var/opt/gitlab'\n    shm_size: '256m'\n```\n\n\nVoici un autre exemple de fichier `docker-compose.yml` avec GitLab fonctionnant sur des ports HTTP et SSH personnalisés. Notez que les variables `GITLAB_OMNIBUS_CONFIG` correspondent à la section `ports` :\n\n\n```\n\nversion: '3.6'\n\nservices:\n  gitlab:\n    image: gitlab/gitlab-ee:\u003Cversion>-ee.0\n    container_name: gitlab\n    restart: always\n    hostname: 'gitlab.example.com'\n    environment:\n      GITLAB_OMNIBUS_CONFIG: |\n        external_url 'http://gitlab.example.com:8929'\n        gitlab_rails['gitlab_shell_ssh_port'] = 2424\n    ports:\n      - '8929:8929'\n      - '443:443'\n      - '2424:22'\n    volumes:\n      - '$GITLAB_HOME/config:/etc/gitlab'\n      - '$GITLAB_HOME/logs:/var/log/gitlab'\n      - '$GITLAB_HOME/data:/var/opt/gitlab'\n    shm_size: '256m'\n```\n\n\nCette configuration est équivalente à l'utilisation de `--publish 8929:8929 --publish 2424:22`.\n\nEnfin, dans le même répertoire que `docker-compose.yml`, démarrez GitLab :\n\n\n```\n\ndocker compose up -d\n\n```\n\n\nReportez-vous à la [documentation d'installation de Docker ](https://docs.gitlab.com/ee/install/docker/installation.html \"Documentation d'installation de Docker \")pour en savoir plus sur Docker Compose, Docker Engine et Docker Swarm mode.\n\n\n### Installation de GitLab sur Kubernetes\n\n\nVous pouvez déployer certains composants dans [Kubernetes](https://about.gitlab.com/fr-fr/blog/kubernetes-the-container-orchestration-solution/ \"Qu'est-ce que Kubernetes ? \"), avec une architecture de référence Cloud Native Hybrid. Pour des raisons de stabilité en production, il n’est pas recommandé de déployer les composants stateful, tels que Gitaly, dans Kubernetes.\n\n\nCloud Native Hybrid est une alternative et une configuration plus avancée par rapport à une architecture de référence standard. L'exécution de services dans Kubernetes est complexe. N'utilisez cette configuration que si vous avez de solides connaissances et une solide expérience de Kubernetes. Vous retrouverez dans la documentation les instructions pour installer GitLab suivant la configuration [Cloud Native Hybrid](https://docs.gitlab.com/ee/administration/reference_architectures/#cloud-native-hybrid \"Cloud Native Hybrid\").\n\n\nGitLab propose également une méthode d'intégration via le [chart Helm GitLab](https://docs.gitlab.com/charts/ \"Chart Helm GitLab\"). Pour les installations basées sur OpenShift, optez pour l'[opérateur GitLab](https://docs.gitlab.com/operator/installation.html \"Opérateur GitLab\"). Les valeurs par défaut du chart Helm GitLab et de l'opérateur GitLab ne sont pas recommandées pour une utilisation en production. Avec ces valeurs, une instance GitLab est créée où tous les services, y compris les données persistantes, sont déployés dans un cluster Kubernetes. Pour plus d'informations sur ces limitations, [consultez notre documentation](https://docs.gitlab.com/ee/administration/reference_architectures/#stateful-components-in-kubernetes). Pour une utilisation en production, il est recommandé de se baser sur l’architecture de référence Cloud Native Hybrid.\n\n\nNotre tutoriel touche à sa fin ! Pour connaître toutes les méthodes d’installation de GitLab Self-Managed, consultez notre [page d’installation](https://about.gitlab.com/fr-fr/install/ \"Installation GitLab Self-Managed\").\n\n\n#### Ressources utiles\n\n\n- [Architectures de référence de GitLab](https://docs.gitlab.com/ee/administration/reference_architectures/#available-reference-architectures \"Architectures de référence de GitLab\")\n\n- [GitLab Environment Toolkit](https://gitlab.com/gitlab-org/gitlab-environment-toolkit \"GitLab Environment Toolkit\")\n\n\n## FAQ sur l'installation de GitLab\n\n\n### Sur quel système d'exploitation Linux peut-on installer GitLab ?\n\n\nGitLab est disponible sur les environnements Linux suivants : Ubuntu, Debian, AlmaLinux, CentOS 7, OpenSUSE Leap, Amazon Linux, et Raspberry Pi. Le paquet Debian natif et le paquet Arch Linux sont des méthodes d'installation alternatives pour GitLab, mais elles ne sont pas officielles et ne sont pas prises en charge.\n\n\n### Comment mettre à jour GitLab ?\n\n\nConsultez la [page de mise à jour de GitLab](https://about.gitlab.com/fr-fr/update/ \"Mettre à jour GitLab\") pour utiliser notre dernière version. Un tutoriel GitLab est disponible pour les différents systèmes d'exploitation, tels que Linux, Kubernetes et Docker. La page donne accès à de nombreuses ressources, documentations officielles de maintenance et instructions pour une mise à niveau sur une version plus puissante.\n\n\n### Comment résoudre un problème d'installation de GitLab ?\n\n\nEn cas de question ou de difficulté pour installer GitLab, vous pouvez trouver de l'aide en consultant notre [documentation](https://docs.gitlab.com/ \"Documentation de GitLab\"), nos [ressources communautaires](https://about.gitlab.com/community/ \"Communauté de GitLab\"), notre [forum](https://forum.gitlab.com/ \"Forum de GitLab\") et notre [blog](https://about.gitlab.com/fr-fr/blog/ \"Blog de GitLab\"). Pour des conseils personnalisés sur votre projet, [contactez un expert GitLab](https://about.gitlab.com/fr-fr/sales/ \"Contacter un expert GitLab\").\n",[830,852],{"slug":1064,"featured":6,"template":684},"how-to-install-gitlab-beginners-guide","content:fr-fr:blog:how-to-install-gitlab-beginners-guide.yml","How To Install Gitlab Beginners Guide","fr-fr/blog/how-to-install-gitlab-beginners-guide.yml","fr-fr/blog/how-to-install-gitlab-beginners-guide",{"_path":1070,"_dir":248,"_draft":6,"_partial":6,"_locale":7,"seo":1071,"content":1077,"config":1083,"_id":1085,"_type":16,"title":1086,"_source":18,"_file":1087,"_stem":1088,"_extension":21},"/fr-fr/blog/getting-started-with-gitlab-how-to-manage-users",{"title":1072,"description":1073,"ogTitle":1072,"ogDescription":1073,"noIndex":6,"ogImage":1074,"ogUrl":1075,"ogSiteName":719,"ogType":720,"canonicalUrls":1075,"schema":1076},"Premiers pas avec GitLab : comment gérer les utilisateurs","Découvrez comment gérer les utilisateurs dans GitLab et apprenez comment configurer une collaboration sécurisée.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097273/Blog/Hero%20Images/Blog/Hero%20Images/blog-getting-started-with-gitlab-banner-0497-option4-fy25_cFwd8DYFLekdnOLmbbChp_1750097273817.png","https://about.gitlab.com/blog/getting-started-with-gitlab-how-to-manage-users","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Premiers pas avec GitLab : comment gérer les utilisateurs\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Abubakar Siddiq Ango\"}],\n        \"datePublished\": \"2025-01-14\",\n      }\n                  ",{"title":1072,"description":1073,"authors":1078,"heroImage":1074,"date":1079,"body":1080,"category":14,"tags":1081,"updatedDate":1082},[1038],"2025-01-14","*Bienvenue dans notre nouvelle 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 de GitLab.*\n\nAssurer un environnement sécurisé, conforme et collaboratif commence par la tâche la plus élémentaire : la __gestion des utilisateurs__. Dans ce tutoriel, nous vous expliquons comment ajouter des membres à votre projet, attribuer des rôles et des autorisations, et créer des groupes ainsi que des sous-groupes.\n\nRemarque : pour suivre ce tutoriel, vous devez disposer d'un compte GitLab sur GitLab.com ou l'instance GitLab Self-Managed de votre entreprise. Si vous avez besoin d'aide, consultez nos sessions d'apprentissage dédiées aux fondamentaux sur [GitLab University](https://university.gitlab.com/).\n\nEntrons maintenant dans le vif du sujet.\n\nLorsque vous créez des utilisateurs sur GitLab, ces derniers n'ont accès qu'à [leurs projets privés, aux projets publics et à ceux définis avec une visibilité interne](https://docs.gitlab.com/ee/user/public_access.html). Dans le cadre de ce tutoriel, imaginons que vous gérez un projet hautement confidentiel où seuls les membres invités doivent y avoir accès, avec différents paramètres d'autorisation. Pour cela, vous pouvez inviter des utilisateurs en tant que [membres du projet](https://docs.gitlab.com/ee/user/project/members/).\n\n## Inviter les utilisateurs à rejoindre un projet\n\n![Écran des membres du projet](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097278/Blog/Content%20Images/Blog/Content%20Images/image1_aHR0cHM6_1750097278487.png)\n\nLes utilisateurs de GitLab peuvent être invités à rejoindre un projet et [se voir attribuer un rôle](https://docs.gitlab.com/ee/user/permissions.html), qui détermine leurs droits en termes de contributions. Le propriétaire d'un projet peut confier certaines tâches administratives à d'autres utilisateurs en leur attribuant le rôle de chargé de maintenance. Ces derniers bénéficient de presque tous les privilèges du propriétaire, à l'exception de la possibilité d'apporter des modifications au projet, telles que sa suppression, son archivage ou son transfert.\n\n![Écran d'invitation des membres](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097278/Blog/Content%20Images/Blog/Content%20Images/image2_aHR0cHM6_1750097278487.png)\n\nLes [chargés de maintenance](https://docs.gitlab.com/ee/user/permissions.html#roles) peuvent ainsi inviter d'autres membres en tant que développeurs. Ces derniers ont accès à toutes les fonctionnalités requises pour créer, compiler et déployer des logiciels. Les utilisateurs qui ne sont pas des développeurs, mais qui ont besoin d'un accès à la gestion de projet peuvent être invités en tant que [planificateurs](https://about.gitlab.com/fr-fr/blog/introducing-gitlabs-new-planner-role-for-agile-planning-teams/), rapporteurs ou invités, avec différents niveaux d'accès. Ces rôles peuvent également servir à déterminer qui est autorisé à apporter des modifications à certaines branches par le biais des [branches protégées](https://docs.gitlab.com/ee/user/project/repository/branches/protected.html).\n\nSi vous travaillez avec des sous-traitants ou si votre utilisation nécessite que les autorisations des utilisateurs expirent, vous pouvez définir une date d'expiration après laquelle l'utilisateur perd l'accès au projet. Les membres du projet peuvent également être identifiés comme membres directs ou indirects, en fonction de leur [type d'attribution des droits d'accès](https://docs.gitlab.com/ee/user/project/members/#membership-types). Les membres directs sont ajoutés directement au projet, tandis que les membres indirects sont souvent hérités d'un [groupe GitLab](https://docs.gitlab.com/ee/user/group/) auquel appartient le projet.\n\nPassons maintenant aux attributions des droits d'accès au groupe.\n\n## Attribuer des droits d'accès au groupe\n\nDans GitLab, un groupe peut être un groupe principal créé à la racine d'une instance GitLab. C'est le cas de [gitlab.com/gitlab-org](http://gitlab.com/gitlab-org), un groupe parent utilisé pour organiser d'autres sous-groupes comme [gitlab.com/gitlab-org/charts](http://gitlab.com/gitlab-org/charts). Les groupes sont utiles même si vous n'avez qu'un seul projet.\n\nIls peuvent servir à :\n\n- organiser des projets similaires ou connexes\n- regrouper les utilisateurs en groupes pour mieux coordonner les équipes\n\nLorsque vous structurez votre projet à l'aide de groupes, vous pouvez assigner des équipes à des groupes spécifiques et [inviter un groupe à participer à un projet](https://docs.gitlab.com/ee/user/project/members/sharing_projects_groups.html) avec un rôle défini pour l’ensemble de l’équipe. Par exemple, vous pouvez créer un groupe `dev` pour les développeurs et développeuses de l'équipe, un groupe `pm` pour les chefs de projet et un groupe `leads` pour les responsables d'équipe. Lorsqu'une invitation est envoyée pour rejoindre ces groupes, les membres du groupe `dev` peuvent se voir attribuer le rôle de développeur, `pm` le rôle de planificateur et `leads` le rôle de chargé de maintenance.\n\n![Écran Inviter un groupe](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097279/Blog/Content%20Images/Blog/Content%20Images/image3_aHR0cHM6_1750097278488.png)\n\nLes membres de chaque groupe peuvent être ajoutés ou supprimés sans avoir à mettre à jour les autorisations du projet. Cette fonctionnalité est particulièrement utile lorsque votre équipe compte plusieurs projets. [Consultez nos bonnes pratiques](https://docs.gitlab.com/ee/user/project/members/sharing_projects_groups.html#setting-up-a-group-for-collaboration) pour utiliser les groupes à des fins collaboratives.\n\nUn autre avantage d'organiser les utilisateurs en groupes est la possibilité de [mentionner](https://docs.gitlab.com/ee/user/discussions/#mentions) l'ensemble du groupe dans les tickets, les merge requests ou les commentaires, ce qui facilite la communication au sein de l'équipe.\n\n### Comment créer des sous-groupes ?\n\nLes [sous-groupes](https://docs.gitlab.com/ee/user/group/subgroups/) permettent de mieux organiser les utilisateurs au sein d'un groupe. Vous pouvez ajouter des sous-groupes jusqu'à 20 niveaux imbriqués. Les utilisateurs d'un sous-groupe héritent des autorisations de leur groupe parent. Si vous souhaitez attribuer à un utilisateur d'un sous-groupe un rôle supérieur à celui dont il a hérité, vous devrez l'[inviter directement dans le sous-groupe](https://docs.gitlab.com/ee/user/group/subgroups/#override-ancestor-group-membership) et lui attribuer le nouveau niveau d'accès supérieur. Notez que, dans le sous-groupe, il n'est pas possible d'assigner à l'utilisateur un rôle inférieur à celui hérité du groupe parent.\n\n### Comment gérer les groupes ?\n\nEn tant que propriétaire du groupe, vous disposez de plusieurs options pour gérer le fonctionnement des utilisateurs au sein d'un groupe. Par exemple, vous pouvez définir les conditions d'accès à un groupe, activer ou désactiver les [mentions de groupe](https://docs.gitlab.com/ee/user/group/manage.html#disable-group-mentions), [restreindre l'accès](https://docs.gitlab.com/ee/user/group/manage.html#turn-on-restricted-access) ou [modérer les utilisateurs](https://docs.gitlab.com/ee/user/group/moderate_users.html). Une nouvelle fonctionnalité intéressante, encore en cours de développement au moment de la publication de cet article, est la [suppression automatique des utilisateurs inactifs](https://docs.gitlab.com/ee/user/group/moderate_users.html#automatically-remove-dormant-members) dans un délai compris entre 90 jours et 5 ans. Cette nouveauté aidera à maintenir les groupes à jour et à mieux gérer l'attribution des sièges associés à la licence. \n\n## Lancez-vous sur GitLab dès aujourd’hui !\n\nLa gestion des utilisateurs sur GitLab varie en fonction de vos besoins. Si votre entreprise atteint un stade de développement plus important, que vos workflows sont complexes et que vous avez recours à une gestion des utilisateurs plus avancée, GitLab offre des outils efficaces pour [gérer les utilisateurs Enterprise](https://docs.gitlab.com/ee/user/enterprise_user/index.html). Avec [GitLab Ultimate](https://about.gitlab.com/fr-fr/pricing/ultimate/), vous bénéficiez de fonctionnalités supplémentaires pour [gérer votre entreprise](https://docs.gitlab.com/ee/topics/set_up_organization.html), notamment une plus grande granularité et des options de conformité renforcées.\n\n> ##### Vous souhaitez approfondir vos connaissances ? [Inscrivez-vous à GitLab University](https://university.gitlab.com/). Vous pouvez également vous lancer immédiatement avec [un essai gratuit de GitLab Ultimate](https://gitlab.com/-/trial_registrations/new?glm_content=default-saas-trial&glm_source=about.gitlab.com%2F).",[830,705,852,937,14],"2025-01-21",{"slug":1084,"featured":92,"template":684},"getting-started-with-gitlab-how-to-manage-users","content:fr-fr:blog:getting-started-with-gitlab-how-to-manage-users.yml","Getting Started With Gitlab How To Manage Users","fr-fr/blog/getting-started-with-gitlab-how-to-manage-users.yml","fr-fr/blog/getting-started-with-gitlab-how-to-manage-users",{"_path":1090,"_dir":248,"_draft":6,"_partial":6,"_locale":7,"seo":1091,"content":1097,"config":1103,"_id":1105,"_type":16,"title":1106,"_source":18,"_file":1107,"_stem":1108,"_extension":21},"/fr-fr/blog/data-driven-devsecops-exploring-gitlab-insights-dashboards",{"title":1092,"description":1093,"ogTitle":1092,"ogDescription":1093,"noIndex":6,"ogImage":1094,"ogUrl":1095,"ogSiteName":719,"ogType":720,"canonicalUrls":1095,"schema":1096},"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":1092,"description":1093,"authors":1098,"heroImage":1094,"date":1100,"body":1101,"category":14,"tags":1102,"updatedDate":826},[1099],"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",[110,830,14,705,852,979],{"slug":1104,"featured":92,"template":684},"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":1110,"_dir":248,"_draft":6,"_partial":6,"_locale":7,"seo":1111,"content":1117,"config":1126,"_id":1128,"_type":16,"title":1129,"_source":18,"_file":1130,"_stem":1131,"_extension":21},"/fr-fr/blog/tutorial-migrate-from-google-cloud-source-repositories-to-gitlab",{"title":1112,"description":1113,"ogTitle":1112,"ogDescription":1113,"noIndex":6,"ogImage":1114,"ogUrl":1115,"ogSiteName":719,"ogType":720,"canonicalUrls":1115,"schema":1116},"Tutoriel : migrez de Google Cloud Source Repositories vers GitLab","Google Cloud met fin à son service Cloud Source Repositories. Découvrez comment migrer un dépôt de code source CSR vers GitLab.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097739/Blog/Hero%20Images/Blog/Hero%20Images/blog-image-template-1800x945%20%2813%29_1zdtbfPDHZVe6JC2AbdHmb_1750097738370.png","https://about.gitlab.com/blog/tutorial-migrate-from-google-cloud-source-repositories-to-gitlab","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Tutoriel : migrez de Google Cloud Source Repositories vers GitLab\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Tsukasa Komatsubara\"},{\"@type\":\"Person\",\"name\":\"Regnard Raquedan\"}],\n        \"datePublished\": \"2024-08-28\",\n      }",{"title":1112,"description":1113,"authors":1118,"heroImage":1114,"date":1121,"body":1122,"category":14,"tags":1123,"updatedDate":1125},[1119,1120],"Tsukasa Komatsubara","Regnard Raquedan","2024-08-28","L'[arrêt du service Cloud Source Repositories](https://cloud.google.com/source-repositories/docs/release-notes) (CSR) de Google Cloud a incité les équipes de développement à rechercher une alternative complète pour leurs dépôts de code source. GitLab, [partenaire technologique de Google Cloud](https://cloud.google.com/find-a-partner/partner/gitlab-inc), s’impose comme un choix judicieux en raison de ses capacités DevSecOps complètes. \n\nDécouvrez dans ce tutoriel comment migrer de CSR vers GitLab, que vous utilisiez GitLab.com ou une instance auto-gérée sur Google Cloud.\n\n## Pourquoi utiliser GitLab ?\n\nPasser de Google Cloud Source Repositories vers GitLab est une étape recommandée. En tant que partenaire stratégique de Google Cloud, GitLab s'intègre facilement à l'infrastructure existante et apporte de la valeur aux clients grâce aux éléments suivants :\n\n- **Une plateforme DevSecOps unifiée**\n    - Consolidez l'ensemble de votre cycle de développement, de la planification à la surveillance, au sein d'une seule application. Éliminez la multiplication des outils et augmentez considérablement votre productivité.\n\n- **Une intégration fluide avec Google Cloud**\n    - Connectez-vous sans effort à Google Kubernetes Engine (GKE), Cloud Build et Cloud Storage pour assurer une migration fluide et des opérations efficaces au sein de l'écosystème Google Cloud.\n\n- **Des capacités CI/CD avancées**\n    - Tirez parti de la [fonctionnalité GitLab Auto DevOps](https://docs.gitlab.com/ee/topics/autodevops/) pour tout automatiser, du scanning de sécurité au déploiement, et accélérez vos cycles de développement.\n\n- **Une assistance au codage alimentée par l'IA reconnue dans le secteur**\n    - Bénéficiez d'un développement assisté par l'IA intégré avec [GitLab Duo](https://about.gitlab.com/fr-fr/gitlab-duo/), favorisant un environnement de codage sécurisé et efficace.\n\n## Prérequis\n\nAvant de commencer la migration, assurez-vous d'avoir :\n- Un compte GitLab : créez un compte sur GitLab.com ou sur une instance auto-hébergée.\n- Un projet GitLab : créez un projet vide dans GitLab où le dépôt CSR sera migré.\n\n## Quelles sont les étapes de la migration ?\n\n1. Créez un projet GitLab vide : il servira de destination pour le dépôt CSR que vous allez migrer. Gardez ce projet vide pour le moment.\n2. Générez un jeton d'accès personnel : accédez aux paramètres de GitLab et [générez un jeton d'accès personnel](https://docs.gitlab.com/ee/user/profile/personal_access_tokens.html) avec les portées `read_repository` et `write_repository` activées. Ce jeton sera utilisé pour authentifier vos opérations Git pendant le processus de migration.\n3. Modifiez le code dans l'éditeur Cloud Shell : à partir de votre dépôt CSR, ouvrez l'éditeur de code Cloud Shell en cliquant sur le bouton « Modifier le code ». Vous devrez autoriser Cloud Shell et sélectionner « Faire confiance au dépôt » pour continuer.\n\n![Éditeur de code Cloud Shell de Google](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097750/Blog/Content%20Images/Blog/Content%20Images/image1_aHR0cHM6_1750097750517.png)\n\n4. Inspectez le statut de Git : exécutez `git status` dans Cloud Shell pour vérifier la branche actuelle et assurez-vous que tout est en ordre avant d'effectuer un push vers GitLab.\n\n![Inspectez le statut de Git](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097750/Blog/Content%20Images/Blog/Content%20Images/image2_aHR0cHM6_1750097750518.png)\n\n5. Configurez le dépôt distant : ajoutez votre projet GitLab en tant que dépôt distant en exécutant :\n\n```\ngit remote add origin [GITLAB_PROJECT_URL]\n\n```\n\n6. Remplacez `[GITLAB_PROJECT_URL]` par l'URL actuelle de votre projet GitLab.\nEffectuez un push vers GitLab, puis effectuez un push de votre dépôt local vers GitLab en exécutant : \n\n```\ngit push -u origin [BRANCH_NAME]\n\n```\n\n7. Remplacez `[BRANCH_NAME]` par le nom de la branche actuelle que vous avez noté plus tôt. Lorsqu'ils vous sont demandés, utilisez votre nom d'utilisateur GitLab et le jeton d'accès personnel comme mot de passe pour vous authentifier et terminez le push.\n\n## Bonnes pratiques\n\n- Sauvegardez avant de commencer : sauvegardez toujours votre dépôt CSR avant de démarrer le processus de migration.\n- Testez après la migration : assurez-vous que tous les aspects du dépôt, y compris les branches et les pipelines CI/CD, fonctionnent comme prévu dans GitLab.\n- Tirez parti des fonctionnalités de GitLab : exploitez les fonctionnalités DevSecOps avancées de GitLab telles que l'[IA](https://about.gitlab.com/fr-fr/gitlab-duo/), le [CI/CD](https://docs.gitlab.com/ee/ci/) et [Enterprise Agile Planning](https://about.gitlab.com/fr-fr/solutions/agile-delivery/) pour améliorer votre workflow de développement.\n\nEn plus d'être facile, la migration depuis Google Cloud Source Repositories vers GitLab offre d'autres avantages que la simple gestion du code source. Avec son intégration à Google Cloud, GitLab est un choix idéal pour les équipes de développement qui cherchent également à améliorer leur workflow.\n\n> En savoir plus sur [l'intégration de GitLab à Google Cloud](https://about.gitlab.com/blog/gitlab-google-cloud-integrations-now-in-public-beta/).",[852,1124,830],"google","2024-09-25",{"slug":1127,"featured":6,"template":684},"tutorial-migrate-from-google-cloud-source-repositories-to-gitlab","content:fr-fr:blog:tutorial-migrate-from-google-cloud-source-repositories-to-gitlab.yml","Tutorial Migrate From Google Cloud Source Repositories To Gitlab","fr-fr/blog/tutorial-migrate-from-google-cloud-source-repositories-to-gitlab.yml","fr-fr/blog/tutorial-migrate-from-google-cloud-source-repositories-to-gitlab",{"_path":1133,"_dir":248,"_draft":6,"_partial":6,"_locale":7,"seo":1134,"content":1140,"config":1149,"_id":1151,"_type":16,"title":1152,"_source":18,"_file":1153,"_stem":1154,"_extension":21},"/fr-fr/blog/ultimate-guide-to-migrating-from-aws-codecommit-to-gitlab",{"title":1135,"description":1136,"ogTitle":1135,"ogDescription":1136,"noIndex":6,"ogImage":1137,"ogUrl":1138,"ogSiteName":719,"ogType":720,"canonicalUrls":1138,"schema":1139},"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":1135,"description":1136,"authors":1141,"heroImage":1137,"date":1144,"body":1145,"category":14,"tags":1146,"updatedDate":1148},[1119,726,1142,1143],"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.",[110,1147,830,852,979,14,235],"AWS","2024-09-05",{"slug":1150,"featured":92,"template":684},"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":1156,"_dir":248,"_draft":6,"_partial":6,"_locale":7,"seo":1157,"content":1163,"config":1172,"_id":1174,"_type":16,"title":1175,"_source":18,"_file":1176,"_stem":1177,"_extension":21},"/fr-fr/blog/monitor-application-performance-with-distributed-tracing",{"title":1158,"description":1159,"ogTitle":1158,"ogDescription":1159,"noIndex":6,"ogImage":1160,"ogUrl":1161,"ogSiteName":719,"ogType":720,"canonicalUrls":1161,"schema":1162},"Surveillez les performances de vos applications avec le traçage distribué","Découvrez comment le traçage distribué résout les problèmes de performance des applications en offrant une visibilité de bout en bout et en favorisant une collaboration fluide.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098000/Blog/Hero%20Images/Blog/Hero%20Images/blog-image-template-1800x945%20%288%29_5x6kH5vwjz8cwKgSBh1w11_1750098000511.png","https://about.gitlab.com/blog/monitor-application-performance-with-distributed-tracing","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Surveillez les performances de vos applications avec le traçage distribué\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Sacha Guyon\"}],\n        \"datePublished\": \"2024-06-13\",\n      }",{"title":1158,"description":1159,"authors":1164,"heroImage":1160,"date":1166,"body":1167,"category":14,"tags":1168,"updatedDate":1171},[1165],"Sacha Guyon","2024-06-13","Les temps d'arrêt, qu'ils soient causés par des dysfonctionnements ou des problèmes de performance des applications, peuvent avoir des conséquences financières désastreuses pour les entreprises. En effet, l'enquête « Global Server Hardware and Server OS Reliability » publiée en 2022 par [Information Technology Intelligence Consulting](https://itic-corp.com/server-and-application-by-the-numbers-understanding-the-nines/), révèle qu’un temps d'arrêt d’une heure coûterait aux entreprises 301 000 dollars ou plus. Bien souvent, ces problèmes proviennent d'erreurs humaines qui se produisent lors de modifications liées au code ou à la configuration logicielle.\n\nLa résolution de ces incidents exige une collaboration étroite entre les équipes chargées du développement et des opérations. Ces dernières doivent analyser les différents composants du système pour identifier la cause profonde du changement rencontré et rétablir rapidement le système pour qu’il fonctionne à nouveau normalement.\n\nCependant, il n'est pas rare que ces équipes utilisent des outils différents pour concevoir, gérer et surveiller leurs services applicatifs et leur infrastructure. Cela n'est pas sans conséquences, car cette approche entraîne un cloisonnement des données, des changements de contexte inefficaces et une mauvaise communication entre les équipes. Tout ceci allonge ainsi le temps nécessaire à la détection et à la résolution des incidents.\n\nDécouvrez dans cet article tout ce que vous devez savoir sur le traçage distribué, sans oublier notre fonctionnalité de « [Distributed Tracing](https://docs.gitlab.com/ee/development/tracing.html) » (disponible en version bêta), une nouvelle étape vers une offre complète d’[observabilité](https://about.gitlab.com/fr-fr/blog/observability-vs-monitoring-in-devops/ \"DevOps : de la surveillance à l'observabilité\"), intégrée de manière transparente à la plateforme [DevSecOps](https://about.gitlab.com/fr-fr/topics/devsecops/ \"Qu'est-ce que DevSecOps ?\") de GitLab.\n\n## Une nouvelle ère avec GitLab Observability\n\nGitLab Observability permet aux équipes chargées du développement et des opérations de visualiser et d'analyser les erreurs, les traces, les journaux, ainsi que les indicateurs de performance de leurs applications et de leur infrastructure.\n\nEn intégrant la surveillance des performances des applications directement dans les workflows de livraison de logiciels, nous réduisons les interruptions liées aux changements de contexte, augmentant ainsi la productivité des équipes qui peuvent alors collaborer efficacement au sein d'une plateforme unifiée.\n\nDe plus, GitLab Observability comble le fossé entre le développement et les opérations en fournissant des informations précieuses sur les performances des applications en phase de production. Cela favorise la transparence, le partage d'informations et une meilleure communication entre les équipes. Elles peuvent alors détecter et résoudre plus rapidement et efficacement les bogues et problèmes de performance liés aux changements de code ou de configuration. Ainsi, cela évite que ces problèmes ne se transforment en incidents majeurs susceptibles de nuire aux activités de l'entreprise.\n\n## Qu'est-ce que le traçage distribué ?\n\nAvec le traçage distribué, les ingénieurs peuvent identifier l'origine des problèmes liés à la performance des applications. Une trace correspond à une requête d’un utilisateur unique qui chemine à travers différents services et systèmes. Cela permet aux ingénieurs d'analyser la chronologie de chaque opération et de détecter les erreurs éventuelles au fur et à mesure qu’elles se produisent.\n\nChaque trace est composée d'un ou de plusieurs spans (qui sont des opérations individuelles ou des unités de travail spécifiques). Ces spans contiennent un large éventail de métadonnées telles que le nom, les horodatages, le statut, ainsi que des tags ou des journaux pertinents. En examinant les relations entre les spans, les équipes de développement peuvent comprendre le parcours des requêtes, identifier les goulots d'étranglement en termes de performance, et localiser précisément les problèmes.\n\n### Le traçage distribué dans les microservices\n\nLe traçage distribué est particulièrement utile pour l'[architecture de microservices](https://about.gitlab.com/fr-fr/blog/what-are-the-benefits-of-a-microservices-architecture/ \"Architecture de microservices\"). Dans ce type d'architecture, une seule requête peut impliquer de nombreux appels de services à travers un système complexe. Grâce au traçage distribué, les équipes obtiennent un maximum de visibilité sur cette interaction et peuvent rapidement diagnostiquer et résoudre les problèmes.\n\n![Exemple de traçage distribué (distributed tracing)](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098009/Blog/Content%20Images/Blog/Content%20Images/image4_aHR0cHM6_1750098009139.png)\n\nPar exemple, cette trace illustre la manière dont une requête utilisateur passe par différents services pour obtenir des recommandations de produits sur un site e-commerce :\n\n- __Action de l’utilisateur.__ Cela correspond à l'action initiale de l'utilisateur. Par exemple, un clic sur un bouton pour demander des recommandations de produits sur une page produit.\n- __Frontend.__ Le frontend envoie une requête au service de recommandation pour obtenir une liste de produits recommandés.\n- __Service de recommandation.__ La requête provenant du frontend est traitée par le service de recommandation, qui génère une liste de produits recommandés.\n- __Service de catalogue.__ Le service de recommandation appelle le service de catalogue pour récupérer les détails des produits recommandés. Une icône d'alerte signale un problème ou un ralentissement à cette étape (par exemple, une réponse lente ou une erreur lors de la récupération des détails des produits).\n- __Base de données.__ Le service de catalogue interroge la base de données pour récupérer les informations détaillées des produits. Ce span montre la requête SQL effectuée dans la base de données.\n\nEn visualisant cette trace de bout en bout, les équipes de développement peuvent identifier les problèmes de performance (comme ici, une erreur au niveau du service de catalogue) et diagnostiquer puis résoudre rapidement les problèmes à travers l'ensemble du système distribué.\n\n![Exemple de trace du parcours utilisateur](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098009/Blog/Content%20Images/Blog/Content%20Images/image1_aHR0cHM6_1750098009140.png)\n\n## Comment fonctionne le traçage distribué ?\n\nDécouvrez ci-dessous une explication détaillée du fonctionnement du traçage distribué.\n\n### Collectez des données en provenance de n'importe quelle application avec OpenTelemetry\n\nLes traces et les spans peuvent être collectés avec [OpenTelemetry](https://opentelemetry.io/docs/what-is-opentelemetry/ \"Qu'est-ce qu'OpenTelemetry ?\") (un framework d’observabilité open source). Ce dernier prend en charge un large éventail de SDK et de bibliothèques dans les principaux [langages de programmation et frameworks](https://opentelemetry.io/docs/languages/). Ce framework propose une approche indépendante pour la collecte et l'exportation des données de télémétrie, permettant ainsi aux équipes de développement :\n- d'éviter toute dépendance vis-à-vis d’un fournisseur,\n- de choisir librement les outils les plus adaptés à leurs besoins.\n\nDe cette façon, si vous utilisez déjà OpenTelemetry avec un autre fournisseur et que vous souhaitez essayer les fonctionnalités de GitLab, il vous suffit d'ajouter notre point de terminaison à votre fichier de configuration pour nous envoyer vos données.\n\n![Diagramme représentant le workflow du traçage distribué](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098009/Blog/Content%20Images/Blog/Content%20Images/image5_aHR0cHM6_1750098009141.png)\n\n### Ingérez et conservez des données à grande échelle avec des requêtes rapides et en temps réel\n\nL'observabilité implique de stocker et d'interroger d'importants volumes de données, tout en assurant une faible latence pour les analyses en temps réel.\n\nPour répondre à ces exigences, nous avons développé, grâce à ClickHouse et [Kubernetes](https://about.gitlab.com/fr-fr/blog/kubernetes-the-container-orchestration-solution/ \"Qu'est-ce que Kubernetes ?\"), une [solution de stockage à long terme qui se met à l'échelle horizontalement](https://gitlab.com/gitlab-org/opstrace/opstrace).\n\nCette plateforme open source assure une performance rapide des requêtes et une évolutivité de niveau entreprise, tout en réduisant les coûts.\n\n### Explorez et analysez les traces en toute simplicité\n\nUne interface utilisateur native avancée est essentielle pour une exploration efficace des données. Pour cela, nous avons construit une interface, en commençant par notre Trace Explorer, permettant aux utilisateurs d'examiner les traces et de mieux comprendre les performances de leurs applications :\n\n- __Filtrage avancé.__ Filtrez par service, nom d'opération, statut et intervalle de temps. L'autocomplétion facilite la création des requêtes.\n- __Mise en évidence des erreurs.__ Identifiez facilement les spans contenant des erreurs dans les résultats de recherche.\n- __Métriques RED.__ Visualisez le taux de requêtes, le taux d'erreurs et la durée moyenne depuis un graphique de série temporelle pour toute recherche en temps réel.\n- __Vue chronologique.__ Les traces individuelles sont affichées sous forme de diagramme en cascade, garantissant une vue complète d'une requête distribuée entre les différents services et opérations.\n- __Données historiques.__ Les utilisateurs peuvent interroger les traces remontant jusqu'à 30 jours en arrière.\n\n![Exploration de traces sous forme de graphique de série temporelle](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098009/Blog/Content%20Images/Blog/Content%20Images/image3_aHR0cHM6_1750098009141.png)\n\n## Comment nous utilisons le traçage distribué chez GitLab\n\nL'utilisation de nos propres fonctionnalités en interne (aussi appelé Dogfooding) est une valeur fondamentale et une pratique essentielle chez GitLab.\n\nC'est pourquoi, pour répondre aux besoins de nos équipes d'ingénierie et d'opérations, nous avons déjà commencé à utiliser les premières versions du traçage distribué.\n\nÀ travers ces exemples, découvrez comment nos équipes utilisent le traçage distribué :\n\n### Déboguez les erreurs et les problèmes de performance dans GitLab Agent pour Kubernetes\n\nLe groupe « [Environments](https://handbook.gitlab.com/handbook/engineering/development/ops/deploy/environments/) » (équipe responsable des environnements dans la phase de déploiement du cycle de vie DevOps) utilise le traçage distribué pour identifier et résoudre divers problèmes liés à [GitLab Agent pour Kubernetes](https://gitlab.com/gitlab-org/cluster-integration/gitlab-agent \"GitLab Agent pour Kubernetes\") (comme les délais d'attente ou les problèmes de latence élevée).\n\nLes vues « Trace List » et « Trace Timeline » fournissent des informations précieuses permettant aux équipes de traiter ces problèmes efficacement. Ces traces sont ensuite partagées et discutées dans les tickets correspondants, favorisant ainsi une collaboration efficace entre les équipes pour la résolution des problèmes.\n\n### Optimisez le temps d'exécution des pipelines en identifiant les goulots d'étranglement\n\nNotre dépôt principal [exécute plus de 100 000 pipelines chaque mois](https://gitlab.com/gitlab-org/gitlab/-/pipelines/charts). Si le temps d'exécution de ces pipelines variait ne serait-ce que d'une minute, cela pourrait ajouter plus de 2 000 heures de travail, soit l'équivalent de 87 jours supplémentaires. C'est pourquoi, lorsque le code source de GitLab se déploie lentement, son impact est considérable, tant sur notre productivité que sur nos coûts d'exploitation.\n\nPour optimiser le temps d'exécution des pipelines, les [équipes d'ingénierie de la plateforme GitLab](https://handbook.gitlab.com/handbook/engineering/infrastructure/) utilisent un [outil personnalisé](https://gitlab.com/gitlab-com/gl-infra/gitlab-pipeline-trace) qui convertit les pipelines de déploiement GitLab en traces.\n\nAinsi, la vue « Trace Timeline » leur permet de :\n- visualiser en détail la chronologie d'exécution des pipelines complexes\n- repérer les jobs qui ralentissent l'ensemble du processus.\n\nEn identifiant ces goulots d'étranglement, nos équipes peuvent optimiser l'exécution des jobs (par exemple, en accélérant l'échec du job, ou en exécutant davantage de jobs en parallèle), afin d'améliorer l'efficacité globale du pipeline. [Notre script est disponible gratuitement](https://gitlab.com/gitlab-com/gl-infra/gitlab-pipeline-trace), vous pouvez donc l'adapter à vos propres pipelines.\n\n## Testez le traçage distribué sur GitLab\n\n[Participez à notre bêta privée](https://docs.gitlab.com/operations/observability/ \"Testez le traçage distribué sur GitLab\") et testez nos fonctionnalités. Votre contribution nous aidera à développer des outils qui répondent parfaitement à vos besoins et à vos défis. Aidez- nous à façonner l'avenir de l'observabilité au sein de GitLab !\n",[1169,705,681,830,1170],"performance","collaboration","2025-02-04",{"slug":1173,"featured":92,"template":684},"monitor-application-performance-with-distributed-tracing","content:fr-fr:blog:monitor-application-performance-with-distributed-tracing.yml","Monitor Application Performance With Distributed Tracing","fr-fr/blog/monitor-application-performance-with-distributed-tracing.yml","fr-fr/blog/monitor-application-performance-with-distributed-tracing",{"_path":1179,"_dir":248,"_draft":6,"_partial":6,"_locale":7,"seo":1180,"content":1186,"config":1195,"_id":1197,"_type":16,"title":1198,"_source":18,"_file":1199,"_stem":1200,"_extension":21},"/fr-fr/blog/tutorial-automated-release-and-release-notes-with-gitlab",{"ogTitle":1181,"schema":1182,"ogImage":1183,"ogDescription":1184,"ogSiteName":719,"noIndex":6,"ogType":720,"ogUrl":1185,"title":1181,"canonicalUrls":1185,"description":1184},"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":1183,"body":1187,"authors":1188,"updatedDate":1190,"date":1191,"title":1181,"tags":1192,"description":1184,"category":14},"**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",[1189],"Ben Ridley","2025-07-09","2023-11-01",[853,110,1193,704,1194],"DevOps","git",{"slug":1196,"featured":6,"template":684},"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",3,[691,712,736,756,775,793,815,838,861],1759347877155]