[{"data":1,"prerenderedAt":814},["ShallowReactive",2],{"/en-us/blog/tags/integrations/":3,"navigation-fr-fr":19,"banner-fr-fr":439,"footer-fr-fr":452,"integrations-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/integrations","tags",false,"",{"tag":9,"tagSlug":9},"integrations",{"template":11},"BlogTag","content:en-us:blog:tags:integrations.yml","yaml","Integrations","content","en-us/blog/tags/integrations.yml","en-us/blog/tags/integrations","yml",{"_path":20,"_dir":21,"_draft":6,"_partial":6,"_locale":7,"data":22,"_id":435,"_type":13,"title":436,"_source":15,"_file":437,"_stem":438,"_extension":18},"/shared/fr-fr/main-navigation","fr-fr",{"logo":23,"freeTrial":28,"sales":33,"login":38,"items":43,"search":376,"minimal":412,"duo":426},{"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,297,357],{"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","/fr-fr/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":284},"Ressources",{"dataNavLevelOne":195},"resources",{"text":197,"config":198},"Afficher toutes les ressources",{"href":199,"dataGaName":195,"dataGaLocation":27},"/fr-fr/resources/",[201,233,256],{"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":9,"dataGaLocation":27},"/fr-fr/integrations/",{"title":234,"items":235},"Découvrir",[236,241,246,251],{"text":237,"config":238},"Histoires de succès client",{"href":239,"dataGaName":240,"dataGaLocation":27},"/fr-fr/customers/","customer success stories",{"text":242,"config":243},"Blog",{"href":244,"dataGaName":245,"dataGaLocation":27},"/fr-fr/blog/","blog",{"text":247,"config":248},"Travail à distance",{"href":249,"dataGaName":250,"dataGaLocation":27},"https://handbook.gitlab.com/handbook/company/culture/all-remote/","remote",{"text":252,"config":253},"TeamOps",{"href":254,"dataGaName":255,"dataGaLocation":27},"/fr-fr/teamops/","teamops",{"title":257,"items":258},"Connecter",[259,264,269,274,279],{"text":260,"config":261},"Services GitLab",{"href":262,"dataGaName":263,"dataGaLocation":27},"/fr-fr/services/","services",{"text":265,"config":266},"Communauté",{"href":267,"dataGaName":268,"dataGaLocation":27},"/community/","community",{"text":270,"config":271},"Forum",{"href":272,"dataGaName":273,"dataGaLocation":27},"https://forum.gitlab.com/","forum",{"text":275,"config":276},"Événements",{"href":277,"dataGaName":278,"dataGaLocation":27},"/events/","events",{"text":280,"config":281},"Partenaires",{"href":282,"dataGaName":283,"dataGaLocation":27},"/fr-fr/partners/","partners",{"backgroundColor":285,"textColor":286,"text":287,"image":288,"link":292},"#2f2a6b","#fff","L'avenir du développement logiciel. Tendances et perspectives.",{"altText":289,"config":290},"carte promo The Source",{"src":291},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1758208064/dzl0dbift9xdizyelkk4.svg",{"text":293,"config":294},"Lire les articles les plus récents",{"href":295,"dataGaName":296,"dataGaLocation":27},"/fr-fr/the-source/","the source",{"text":298,"config":299,"lists":301},"Société",{"dataNavLevelOne":300},"company",[302],{"items":303},[304,309,315,317,322,327,332,337,342,347,352],{"text":305,"config":306},"À propos",{"href":307,"dataGaName":308,"dataGaLocation":27},"/fr-fr/company/","about",{"text":310,"config":311,"footerGa":314},"Emplois",{"href":312,"dataGaName":313,"dataGaLocation":27},"/jobs/","jobs",{"dataGaName":313},{"text":275,"config":316},{"href":277,"dataGaName":278,"dataGaLocation":27},{"text":318,"config":319},"Leadership",{"href":320,"dataGaName":321,"dataGaLocation":27},"/company/team/e-group/","leadership",{"text":323,"config":324},"Équipe",{"href":325,"dataGaName":326,"dataGaLocation":27},"/company/team/","team",{"text":328,"config":329},"Manuel",{"href":330,"dataGaName":331,"dataGaLocation":27},"https://handbook.gitlab.com/","handbook",{"text":333,"config":334},"Relations avec les investisseurs",{"href":335,"dataGaName":336,"dataGaLocation":27},"https://ir.gitlab.com/","investor relations",{"text":338,"config":339},"Centre de confiance",{"href":340,"dataGaName":341,"dataGaLocation":27},"/fr-fr/security/","trust center",{"text":343,"config":344},"Centre pour la transparence de l'IA",{"href":345,"dataGaName":346,"dataGaLocation":27},"/fr-fr/ai-transparency-center/","ai transparency center",{"text":348,"config":349},"Newsletter",{"href":350,"dataGaName":351,"dataGaLocation":27},"/company/contact/","newsletter",{"text":353,"config":354},"Presse",{"href":355,"dataGaName":356,"dataGaLocation":27},"/press/","press",{"text":358,"config":359,"lists":360},"Nous contacter",{"dataNavLevelOne":300},[361],{"items":362},[363,366,371],{"text":34,"config":364},{"href":36,"dataGaName":365,"dataGaLocation":27},"talk to sales",{"text":367,"config":368},"Aide",{"href":369,"dataGaName":370,"dataGaLocation":27},"/support/","get help",{"text":372,"config":373},"Portail clients GitLab",{"href":374,"dataGaName":375,"dataGaLocation":27},"https://customers.gitlab.com/customers/sign_in/","customer portal",{"close":377,"login":378,"suggestions":385},"Fermer",{"text":379,"link":380},"Pour rechercher des dépôts et des projets, connectez-vous à",{"text":381,"config":382},"gitlab.com",{"href":41,"dataGaName":383,"dataGaLocation":384},"search login","search",{"text":386,"default":387},"Suggestions",[388,391,396,398,403,408],{"text":56,"config":389},{"href":61,"dataGaName":390,"dataGaLocation":384},"GitLab Duo (AI)",{"text":392,"config":393},"Suggestions de code (IA)",{"href":394,"dataGaName":395,"dataGaLocation":384},"/fr-fr/solutions/code-suggestions/","Code Suggestions (AI)",{"text":108,"config":397},{"href":110,"dataGaName":108,"dataGaLocation":384},{"text":399,"config":400},"GitLab sur AWS",{"href":401,"dataGaName":402,"dataGaLocation":384},"/fr-fr/partners/technology-partners/aws/","GitLab on AWS",{"text":404,"config":405},"GitLab sur Google Cloud ",{"href":406,"dataGaName":407,"dataGaLocation":384},"/fr-fr/partners/technology-partners/google-cloud-platform/","GitLab on Google Cloud",{"text":409,"config":410},"Pourquoi utiliser GitLab ?",{"href":69,"dataGaName":411,"dataGaLocation":384},"Why GitLab?",{"freeTrial":413,"mobileIcon":418,"desktopIcon":423},{"text":414,"config":415},"Commencer votre essai gratuit",{"href":416,"dataGaName":32,"dataGaLocation":417},"https://gitlab.com/-/trials/new/","nav",{"altText":419,"config":420},"Icône GitLab",{"src":421,"dataGaName":422,"dataGaLocation":417},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1758203874/jypbw1jx72aexsoohd7x.svg","gitlab icon",{"altText":419,"config":424},{"src":425,"dataGaName":422,"dataGaLocation":417},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1758203875/gs4c8p8opsgvflgkswz9.svg",{"freeTrial":427,"mobileIcon":431,"desktopIcon":433},{"text":428,"config":429},"En savoir plus sur GitLab Duo",{"href":61,"dataGaName":430,"dataGaLocation":417},"gitlab duo",{"altText":419,"config":432},{"src":421,"dataGaName":422,"dataGaLocation":417},{"altText":419,"config":434},{"src":425,"dataGaName":422,"dataGaLocation":417},"content:shared:fr-fr:main-navigation.yml","Main Navigation","shared/fr-fr/main-navigation.yml","shared/fr-fr/main-navigation",{"_path":440,"_dir":21,"_draft":6,"_partial":6,"_locale":7,"title":441,"titleMobile":441,"button":442,"config":447,"_id":449,"_type":13,"_source":15,"_file":450,"_stem":451,"_extension":18},"/shared/fr-fr/banner","La plateforme GitLab Duo Agent est maintenant disponible en version bêta publique !",{"text":443,"config":444},"Essayer la version bêta",{"href":445,"dataGaName":446,"dataGaLocation":27},"/fr-fr/gitlab-duo/agent-platform/","duo banner",{"layout":448},"release","content:shared:fr-fr:banner.yml","shared/fr-fr/banner.yml","shared/fr-fr/banner",{"_path":453,"_dir":21,"_draft":6,"_partial":6,"_locale":7,"data":454,"_id":660,"_type":13,"title":661,"_source":15,"_file":662,"_stem":663,"_extension":18},"/shared/fr-fr/main-footer",{"text":455,"source":456,"edit":462,"contribute":467,"config":472,"items":477,"minimal":651},"Git est une marque déposée de Software Freedom Conservancy et notre utilisation de « GitLab » est sous licence",{"text":457,"config":458},"Afficher le code source de la page",{"href":459,"dataGaName":460,"dataGaLocation":461},"https://gitlab.com/gitlab-com/marketing/digital-experience/about-gitlab-com/","page source","footer",{"text":463,"config":464},"Modifier cette page",{"href":465,"dataGaName":466,"dataGaLocation":461},"https://gitlab.com/gitlab-com/marketing/digital-experience/about-gitlab-com/-/blob/main/content/","web ide",{"text":468,"config":469},"Veuillez contribuer",{"href":470,"dataGaName":471,"dataGaLocation":461},"https://gitlab.com/gitlab-com/marketing/digital-experience/about-gitlab-com/-/blob/main/CONTRIBUTING.md/","please contribute",{"twitter":473,"facebook":474,"youtube":475,"linkedin":476},"https://twitter.com/gitlab","https://www.facebook.com/gitlab","https://www.youtube.com/channel/UCnMGQ8QHMAnVIsI3xJrihhg","https://www.linkedin.com/company/gitlab-com",[478,501,555,588,622],{"title":45,"links":479,"subMenu":484},[480],{"text":481,"config":482},"Plateforme DevSecOps",{"href":54,"dataGaName":483,"dataGaLocation":461},"devsecops platform",[485],{"title":188,"links":486},[487,491,496],{"text":488,"config":489},"Voir les forfaits",{"href":190,"dataGaName":490,"dataGaLocation":461},"view plans",{"text":492,"config":493},"Pourquoi choisir GitLab Premium ?",{"href":494,"dataGaName":495,"dataGaLocation":461},"/fr-fr/pricing/premium/","why premium",{"text":497,"config":498},"Pourquoi choisir GitLab Ultimate ?",{"href":499,"dataGaName":500,"dataGaLocation":461},"/fr-fr/pricing/ultimate/","why ultimate",{"title":502,"links":503},"Solutions",[504,509,512,514,519,524,528,531,534,539,541,543,545,550],{"text":505,"config":506},"Transformation digitale",{"href":507,"dataGaName":508,"dataGaLocation":461},"/fr-fr/topics/digital-transformation/","digital transformation",{"text":510,"config":511},"Sécurité et conformité",{"href":136,"dataGaName":137,"dataGaLocation":461},{"text":121,"config":513},{"href":104,"dataGaName":105,"dataGaLocation":461},{"text":515,"config":516},"Développement agile",{"href":517,"dataGaName":518,"dataGaLocation":461},"/fr-fr/solutions/agile-delivery/","agile delivery",{"text":520,"config":521},"Transformation cloud",{"href":522,"dataGaName":523,"dataGaLocation":461},"/fr-fr/topics/cloud-native/","cloud transformation",{"text":525,"config":526},"SCM",{"href":118,"dataGaName":527,"dataGaLocation":461},"source code management",{"text":108,"config":529},{"href":110,"dataGaName":530,"dataGaLocation":461},"continuous integration & delivery",{"text":160,"config":532},{"href":162,"dataGaName":533,"dataGaLocation":461},"value stream management",{"text":535,"config":536},"GitOps",{"href":537,"dataGaName":538,"dataGaLocation":461},"/fr-fr/solutions/gitops/","gitops",{"text":173,"config":540},{"href":175,"dataGaName":176,"dataGaLocation":461},{"text":178,"config":542},{"href":180,"dataGaName":181,"dataGaLocation":461},{"text":183,"config":544},{"href":185,"dataGaName":186,"dataGaLocation":461},{"text":546,"config":547},"Formation",{"href":548,"dataGaName":549,"dataGaLocation":461},"/fr-fr/solutions/education/","education",{"text":551,"config":552},"Services financiers",{"href":553,"dataGaName":554,"dataGaLocation":461},"/fr-fr/solutions/finance/","financial services",{"title":193,"links":556},[557,559,561,563,566,568,572,574,576,578,580,582,584,586],{"text":205,"config":558},{"href":207,"dataGaName":208,"dataGaLocation":461},{"text":210,"config":560},{"href":212,"dataGaName":213,"dataGaLocation":461},{"text":215,"config":562},{"href":217,"dataGaName":218,"dataGaLocation":461},{"text":220,"config":564},{"href":222,"dataGaName":565,"dataGaLocation":461},"docs",{"text":242,"config":567},{"href":244,"dataGaName":245},{"text":569,"config":570},"Histoires de réussite client",{"href":571,"dataGaLocation":461},"/customers/",{"text":237,"config":573},{"href":239,"dataGaName":240,"dataGaLocation":461},{"text":247,"config":575},{"href":249,"dataGaName":250,"dataGaLocation":461},{"text":260,"config":577},{"href":262,"dataGaName":263,"dataGaLocation":461},{"text":252,"config":579},{"href":254,"dataGaName":255,"dataGaLocation":461},{"text":265,"config":581},{"href":267,"dataGaName":268,"dataGaLocation":461},{"text":270,"config":583},{"href":272,"dataGaName":273,"dataGaLocation":461},{"text":275,"config":585},{"href":277,"dataGaName":278,"dataGaLocation":461},{"text":280,"config":587},{"href":282,"dataGaName":283,"dataGaLocation":461},{"title":298,"links":589},[590,592,594,596,598,600,602,606,611,613,615,617],{"text":305,"config":591},{"href":307,"dataGaName":300,"dataGaLocation":461},{"text":310,"config":593},{"href":312,"dataGaName":313,"dataGaLocation":461},{"text":318,"config":595},{"href":320,"dataGaName":321,"dataGaLocation":461},{"text":323,"config":597},{"href":325,"dataGaName":326,"dataGaLocation":461},{"text":328,"config":599},{"href":330,"dataGaName":331,"dataGaLocation":461},{"text":333,"config":601},{"href":335,"dataGaName":336,"dataGaLocation":461},{"text":603,"config":604},"Sustainability",{"href":605,"dataGaName":603,"dataGaLocation":461},"/sustainability/",{"text":607,"config":608},"Diversité, inclusion et appartenance (DIB)",{"href":609,"dataGaName":610,"dataGaLocation":461},"/fr-fr/diversity-inclusion-belonging/","Diversity, inclusion and belonging",{"text":338,"config":612},{"href":340,"dataGaName":341,"dataGaLocation":461},{"text":348,"config":614},{"href":350,"dataGaName":351,"dataGaLocation":461},{"text":353,"config":616},{"href":355,"dataGaName":356,"dataGaLocation":461},{"text":618,"config":619},"Déclaration de transparence sur l'esclavage moderne",{"href":620,"dataGaName":621,"dataGaLocation":461},"https://handbook.gitlab.com/handbook/legal/modern-slavery-act-transparency-statement/","modern slavery transparency statement",{"title":358,"links":623},[624,627,629,631,636,641,646],{"text":625,"config":626},"Échanger avec un expert",{"href":36,"dataGaName":37,"dataGaLocation":461},{"text":367,"config":628},{"href":369,"dataGaName":370,"dataGaLocation":461},{"text":372,"config":630},{"href":374,"dataGaName":375,"dataGaLocation":461},{"text":632,"config":633},"Statut",{"href":634,"dataGaName":635,"dataGaLocation":461},"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":461},"/fr-fr/privacy/","privacy statement",{"text":647,"config":648},"Préférences en matière de cookies",{"dataGaName":649,"dataGaLocation":461,"id":650,"isOneTrustButton":90},"cookie preferences","ot-sdk-btn",{"items":652},[653,655,658],{"text":637,"config":654},{"href":639,"dataGaName":640,"dataGaLocation":461},{"text":656,"config":657},"Politique de confidentialité",{"href":644,"dataGaName":645,"dataGaLocation":461},{"text":647,"config":659},{"dataGaName":649,"dataGaLocation":461,"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":788,"totalPagesCount":812,"initialPosts":813},[666,693,716,741,763],{"_path":667,"_dir":245,"_draft":6,"_partial":6,"_locale":7,"seo":668,"content":676,"config":686,"_id":689,"_type":13,"title":690,"_source":15,"_file":691,"_stem":692,"_extension":18},"/fr-fr/blog/efficient-devsecops-workflows-hands-on-python-gitlab-api-automation",{"title":669,"description":670,"ogTitle":669,"ogDescription":670,"noIndex":6,"ogImage":671,"ogUrl":672,"ogSiteName":673,"ogType":674,"canonicalUrls":672,"schema":675},"Utiliser l'API python-gitlab pour améliorer vos workflows DevSecOps","Vous souhaitez améliorer vos workflows DevSecOps ? Découvrez dans ce tutoriel des exemples et bonnes pratiques d’utilisation de l’API python-gitlab.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749659883/Blog/Hero%20Images/post-cover-image.jpg","https://about.gitlab.com/blog/efficient-devsecops-workflows-hands-on-python-gitlab-api-automation","https://about.gitlab.com","article","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Utiliser l'API python-gitlab pour améliorer vos workflows DevSecOps\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Michael Friedrich\"}],\n        \"datePublished\": \"2023-02-01\",\n      }",{"title":669,"description":670,"authors":677,"heroImage":671,"date":679,"body":680,"category":681,"tags":682},[678],"Michael Friedrich","2023-02-01","Un jour, un ami m’a dit : « Le travail manuel est un bug ». Depuis, face à\ndes tâches répétitives, j’ai pris l’habitude de les automatiser autant que\npossible. \n\n\nPar exemple, en interrogeant une [API\nREST](https://about.gitlab.com/fr-fr/blog/what-is-rest-api/ \"API\nREST\") pour faire un inventaire des paramètres, ou en effectuant des appels\nd’API pour créer de nouveaux commentaires dans les tickets ou les merge\nrequests de GitLab. L'interaction avec l'API REST de GitLab peut se faire de\ndifférentes manières, en utilisant des requêtes HTTP avec curl (ou\n[hurl](https://about.gitlab.com/blog/how-to-continously-test-web-apps-apis-with-hurl-and-gitlab-ci-cd/\n\"hurl\")) en ligne de commande, ou en écrivant un script dans un langage de\nprogrammation. \n\n\nDans ce dernier cas, il faut effectuer des tâches fastidieuses avec le code\nbrut des requêtes HTTP et l'analyse des réponses JSON. Grâce à la communauté\nGitLab, de nombreux langages sont pris en charge par les bibliothèques\nd'abstraction d'API. Elles prennent en charge tous les attributs de l’API,\najoutent des fonctions d'aide pour obtenir, créer et supprimer des objets,\net facilitent ainsi la tâche des équipes de développement. La [bibliothèque\npython-gitlab](https://python-gitlab.readthedocs.io/en/stable/ \"Bibliothèque\npython-gitlab\") est une bibliothèque écrite en Python, riche en\nfonctionnalités et facile à utiliser.\n\n\nDans cet article, vous apprendrez les bases de l’utilisation de la\nbibliothèque python-gitlab en vous familiarisant avec les objets de l’API,\nles attributs, la pagination et les ensembles de résultats. Vous découvrirez\négalement des cas d'utilisation concrets tels que la collecte de données, la\ngénération de synthèses et l’écriture de données dans l'API pour créer des\ncommentaires et des validations. \n\n\nIl y a encore beaucoup à apprendre, avec de nombreux cas d'utilisation\ninspirés des questions posées par la communauté sur le forum, Hacker News,\ndes tickets, et bien plus encore.\n\n\n## Premiers pas\n\n\nLa [documentation\npython-gitlab](https://python-gitlab.readthedocs.io/en/stable/api-usage.html\n\"Documentation python-gitlab\") est une excellente ressource pour débuter.\nElle offre un aperçu des types d'objets et de leurs méthodes, ainsi que des\nexemples de workflows combinés. Cette ressource est idéale pour faire vos\npremiers pas, en plus de la [documentation sur les ressources de l'API\nGitLab](https://docs.gitlab.com/ee/api/api_resources.html \"Documentation sur\nles ressources de l'API GitLab\") qui fournit les attributs d'objet associés.\n\n\nLes exemples de code présentés dans cet article nécessitent Python 3.8+ et\nla bibliothèque `python-gitlab`. Des exigences supplémentaires sont\nspécifiées dans le fichier `requirements.txt`. Un exemple nécessite `pyyaml`\npour l'analyse de la configuration YAML. Pour suivre et mettre en pratique\nle code des cas d'utilisation, il est recommandé de cloner le projet,\nd'installer les prérequis et d'exécuter les scripts. \n\n\nExemple avec Homebrew sur macOS :\n\n\n```shell\n\ngit clone\nhttps://gitlab.com/gitlab-de/use-cases/gitlab-api/gitlab-api-python.git\n\n\ncd gitlab-api-python\n\n\nbrew install python\n\n\npip3 install -r requirements.txt\n\n\npython3 \u003Cscriptname>.py\n\n```\n\n\nLes scripts n'utilisent pas de bibliothèque partagée commune fournissant des\nfonctions génériques pour la lecture des paramètres ou d’autres\nfonctionnalités d'aide supplémentaires. L’objectif est de montrer des\nexemples faciles à suivre, qui peuvent être utilisés de manière autonome\npour des tests, et qui nécessitent uniquement l'installation de la\nbibliothèque python-gitlab.\n\n\nNous recommandons d'améliorer le code pour une utilisation en production.\nCela vous aidera à créer un projet d’API tooling maintenu, incluant par\nexemple des images de conteneurs et des modèles CI/CD que les équipes de\ndéveloppement peuvent utiliser au sein d'une plateforme\n[DevSecOps](https://about.gitlab.com/fr-fr/topics/devsecops/ \"Qu'est-ce que\nDevSecOps ?\").\n\n\n## Configuration\n\n\nSans configuration, python-gitlab exécutera des requêtes non authentifiées\nsur le serveur par défaut : `https://gitlab.com`. Les paramètres de\nconfiguration les plus courants concernent l'instance GitLab à laquelle se\nconnecter, et la méthode d'authentification en spécifiant les jetons\nd'accès. Python-gitlab prend en charge différents types de configuration :\nun fichier de configuration ou des variables d'environnement.\n\n\nLe [fichier de\nconfiguration](https://python-gitlab.readthedocs.io/en/stable/cli-usage.html#cli-configuration\n\"Fichier de configuration CLI\") est disponible pour les liaisons de\nbibliothèque d’API et pour l'interface de ligne de commande (que nous\nn’aborderons pas dans cet article). Le fichier de configuration prend en\ncharge les [credential\nhelpers](https://python-gitlab.readthedocs.io/en/stable/cli-usage.html#credential-helpers\n\"Credential helpers\") pour accéder directement aux jetons.\n\n\nLes variables d'environnement, en tant que méthode de configuration\nalternative, vous offrent un moyen simple d'exécuter le script dans un\nterminal, de l'intégrer dans des images de conteneurs et de le préparer à\nêtre exécuté dans des [pipelines\nCI/CD](https://about.gitlab.com/fr-fr/topics/ci-cd/cicd-pipeline/ \"Pipeline\nCI/CD\").\n\n\nVous devez lancer la configuration dans le contexte du script Python.\nImportez la bibliothèque `os` pour récupérer les variables d'environnement à\nl'aide de la méthode `os.environ.get()`. Le premier paramètre spécifie la\nclé, le second paramètre définit la valeur par défaut lorsque la variable\nn'est pas disponible dans l'environnement.\n\n\n```python\n\nimport os\n\n\ngl_server = os.environ.get('GL_SERVER', 'https://gitlab.com')\n\n\nprint(gl_server)\n\n```\n\n\nLe paramétrage dans le terminal peut se faire directement pour la commande\nuniquement, ou être exporté dans l'environnement shell.\n\n\n```shell\n\n$ GL_SERVER=’https://gitlab.company.com’ python3 script.py\n\n\n$ export GL_SERVER=’https://gitlab.company.com’\n\n$ python3 script.py\n\n```\n\n\nNous recommandons d'ajouter des contrôles de sécurité pour s’assurer que\ntoutes les variables sont définies avant de continuer l'exécution du\nprogramme. L'extrait de code suivant importe les bibliothèques requises, lit\nla variable d'environnement `GL_SERVER`, et attend de l'utilisateur qu'il\ndéfinisse la variable `GL_TOKEN`. Si ce n'est pas le cas, le script affiche\net génère des erreurs, puis appelle `sys.exit(1)`, pour indiquer un statut\nd’erreur. \n\n\n```python\n\nimport gitlab\n\nimport os\n\nimport sys\n\n\nGITLAB_SERVER = os.environ.get('GL_SERVER', 'https://gitlab.com')\n\nGITLAB_TOKEN = os.environ.get('GL_TOKEN')\n\n\nif not GITLAB_TOKEN:\n    print(\"Please set the GL_TOKEN env variable.\")\n    sys.exit(1)\n```\n\n\nExaminons maintenant un exemple plus détaillé, qui crée une connexion à\nl'API et effectue une requête de données.\n\n\n## Gestion des objets : l'objet GitLab\n\n\nToute interaction avec l'API nécessite une instanciation de l'objet GitLab.\nC'est le point d'entrée pour configurer le serveur GitLab auquel se\nconnecter et s'authentifier à l'aide de jetons d'accès, et définir d’autres\nparamètres globaux pour la pagination, le chargement d’objets, et plus\nencore. \n\n\nL'exemple suivant exécute une requête non authentifiée sur GitLab.com. Il\nest possible d'accéder aux points de terminaison d’API publique, et\nd'obtenir par exemple un [modèle .gitignore pour\nPython](https://python-gitlab.readthedocs.io/en/stable/gl_objects/templates.html#gitignore-templates\n\"Modèle .gitignore pour Python\").\n\n\n[python_gitlab_object_unauthenticated.py](https://gitlab.com/gitlab-da/use-cases/gitlab-api/gitlab-api-python/-/blob/main/python_gitlab_object_unauthenticated.py)\n\n\n```python\n\nimport gitlab\n\n\ngl = gitlab.Gitlab()\n\n\n# Get .gitignore templates without authentication\n\ngitignore_templates = gl.gitignores.get('Python')\n\n\nprint(gitignore_templates.content)\n\n```\n\n\nDans les sections suivantes, nous vous partageons des informations\ndétaillées sur : \n\n\n- La gestion et le chargement des objets,\n\n- La pagination des résultats,\n\n- Le travail avec les relations entre objets,\n\n- Le travail avec différents scopes de collection d'objets.\n\n\n### La gestion et le chargement des objets\n\n\nLa bibliothèque python-gitlab donne accès aux ressources GitLab en utilisant\nce que l’on appelle des «\n[Gestionnaires](https://python-gitlab.readthedocs.io/en/stable/api-usage.html#managers)\n». Chaque type de gestionnaire implémente des méthodes pour travailler avec\nles ensembles de données (list, get, etc.).\n\n\nLe script ci-dessous montre comment accéder aux sous-groupes, aux projets\ndirects et à tous les projets, y compris les sous-groupes, aux tickets, aux\nepics et aux tâches. Une authentification est nécessaire pour accéder à tous\nles attributs. L'extrait de code utilise donc des variables pour obtenir le\njeton d'authentification, et utilise également la variable `GROUP_ID` pour\nspécifier un groupe principal à partir duquel il faut commencer la\nrecherche.\n\n\n```python\n\n#!/usr/bin/env python\n\n\nimport gitlab\n\nimport os\n\nimport sys\n\n\nGITLAB_SERVER = os.environ.get('GL_SERVER', 'https://gitlab.com')\n\n# https://gitlab.com/gitlab-de/use-cases/\n\nGROUP_ID = os.environ.get('GL_GROUP_ID', 16058698)\n\nGITLAB_TOKEN = os.environ.get('GL_TOKEN')\n\n\nif not GITLAB_TOKEN:\n    print(\"Please set the GL_TOKEN env variable.\")\n    sys.exit(1)\n\ngl = gitlab.Gitlab(GITLAB_SERVER, private_token=GITLAB_TOKEN)\n\n\n# Main\n\nmain_group = gl.groups.get(GROUP_ID)\n\n\nprint(\"Sub groups\")\n\nfor sg in main_group.subgroups.list():\n    print(\"Subgroup name: {sg}\".format(sg=sg.name))\n\nprint(\"Projects (direct)\")\n\nfor p in main_group.projects.list():\n    print(\"Project name: {p}\".format(p=p.name))\n\nprint(\"Projects (including subgroups)\")\n\nfor p in main_group.projects.list(include_subgroups=True, all=True):\n     print(\"Project name: {p}\".format(p=p.name))\n\nprint(\"Issues\")\n\nfor i in main_group.issues.list(state='opened'):\n    print(\"Issue title: {t}\".format(t=i.title))\n\nprint(\"Epics\")\n\nfor e in main_group.issues.list():\n    print(\"Epic title: {t}\".format(t=e.title))\n\nprint(\"Todos\")\n\nfor t in gl.todos.list(state='pending'):\n    print(\"Todo: {t} url: {u}\".format(t=t.body, u=t.target_url\n```\n\n\nVous pouvez exécuter le script `python_gitlab_object_manager_methods.py` en\nremplaçant la variable `GROUP_ID` sur GitLab.com SaaS pour analyser votre\npropre groupe. Vous devez spécifier la variable `GL_SERVER` pour les\ninstances auto-gérées. `GL_TOKEN` doit fournir le jeton d'accès personnel.\n\n\n```shell\n\nexport GL_TOKEN=xxx\n\n\nexport GL_SERVER=”https://gitlab.company.com”\n\n\nexport GL_SERVER=”https://gitlab.com”\n\n\nexport GL_GROUP_ID=1234\n\n\npython3 python_gitlab_object_manager_methods.py\n\n```\n\n\nÀ partir de maintenant, les exemples n'affichent plus les en-têtes Python et\nl'analyse des variables d'environnement, afin de se concentrer sur\nl'algorithme et les fonctionnalités. Tous les scripts sont open source sous\nlicence MIT, et sont disponibles dans [ce\nprojet](https://gitlab.com/gitlab-da/use-cases/gitlab-api/gitlab-api-python).\n\n\n### La pagination des résultats\n\n\nPar défaut, l’API GitLab ne renvoie pas tous les ensembles de résultats et\nexige que les clients utilisent la\n[pagination](https://docs.gitlab.com/ee/api/rest/index.html#pagination\n\"Pagination GitLab\") pour parcourir toutes les pages de résultats. La\nbibliothèque python-gitlab permet aux utilisateurs de [définir les\nparamètres](https://python-gitlab.readthedocs.io/en/stable/api-usage.html#pagination)\nglobalement dans l'objet GitLab, ou sur chaque appel `list()`. Cela permet\nd'éviter que tous les ensembles de résultats déclenchent des requêtes API,\nce qui peut ralentir l'exécution du script. Utilisez `iterator=True`, et les\nappels d'API sont déclenchés à la demande lors de l'accès à l'objet.\n\n\nL'exemple suivant recherche le nom de groupe `everyonecancontribute` et\nutilise la pagination du jeu de clés pour afficher 100 résultats sur chaque\npage. L'itérateur est défini sur true dans `gl.groups.list(iterator=True)`\npour récupérer de nouveaux ensembles de résultats à la demande. Si le nom du\ngroupe recherché est trouvé, la boucle s'interrompt et affiche un résumé,\nincluant la mesure de la durée totale de la requête de recherche.\n\n\n```python\n\nSEARCH_GROUP_NAME=\"everyonecancontribute\"\n\n\n# Use keyset pagination\n\n# https://python-gitlab.readthedocs.io/en/stable/api-usage.html#pagination\n\ngl = gitlab.Gitlab(GITLAB_SERVER, private_token=GITLAB_TOKEN,\n    pagination=\"keyset\", order_by=\"id\", per_page=100)\n\n# Iterate over the list, and fire new API calls in case the result set does\nnot match yet\n\ngroups = gl.groups.list(iterator=True)\n\n\nfound_page = 0\n\nstart = timer()\n\n\nfor group in groups:\n    if SEARCH_GROUP_NAME == group.name:\n        # print(group) # debug\n        found_page = groups.current_page\n        break\n\nend = timer()\n\n\nduration = f'{end-start:.2f}'\n\n\nif found_page > 0:\n    print(\"Pagination API example for Python with GitLab{desc} - found group {g} on page {p}, duration {d}s\".format(\n        desc=\", the DevSecOps platform\", g=SEARCH_GROUP_NAME, p=found_page, d=duration))\nelse:\n    print(\"Could not find group name '{g}', duration {d}\".format(g=SEARCH_GROUP_NAME, d=duration))\n```\n\nL'exécution de `python_gitlab_pagination.py` a permis de trouver le groupe\n[everyonecancontribute](https://gitlab.com/everyonecancontribute) à la page\n5.\n\n\n```shell\n\n$ python3 python_gitlab_pagination.py\n\nPagination API example for Python with GitLab, the DevSecOps platform -\nfound group everyonecancontribute on page 5, duration 8.51s\n\n```\n\n\n### Le travail avec les relations entre objets\n\n\nLorsque vous travaillez avec des relations entre objets, par exemple pour\ncollecter tous les projets dans un groupe donné, vous devez envisager des\nétapes supplémentaires. Par défaut, les objets de projet renvoyés présentent\ndes attributs limités. Les objets gérables nécessitent un appel\nsupplémentaire `get()` pour obtenir l'objet de projet complet de l'API en\narrière-plan. Ce workflow permet de réduire les temps d’attente et le trafic\nen limitant les attributs immédiatement renvoyés.\n\n\nL'exemple suivant illustre le problème en parcourant tous les projets d'un\ngroupe et en essayant d'appeler la fonction `project.branches.list()`. Cela\ngénère une exception dans le flux try/except. Le deuxième exemple obtient un\nobjet de projet gérable et tente à nouveau d'appeler la fonction.\n\n\n```python\n\n# Main\n\ngroup = gl.groups.get(GROUP_ID)\n\n\n# Collect all projects in group and subgroups\n\nprojects = group.projects.list(include_subgroups=True, all=True)\n\n\nfor project in projects:\n    # Try running a method on a weak object\n    try:\n       print(\"🤔 Project: {pn} 💡 Branches: {b}\\n\".format(\n        pn=project.name,\n        b=\", \".join([x.name for x in project.branches.list()])))\n    except Exception as e:\n        print(\"Got exception: {e} \\n ===================================== \\n\".format(e=e))\n\n    # Retrieve a full manageable project object\n    # https://python-gitlab.readthedocs.io/en/stable/gl_objects/groups.html#examples\n    manageable_project = gl.projects.get(project.id)\n\n    # Print a method available on a manageable object\n    print(\"🤔 Project: {pn} 💡 Branches: {b}\\n\".format(\n        pn=manageable_project.name,\n        b=\", \".join([x.name for x in manageable_project.branches.list()])))\n```\n\n\nLe gestionnaire d'exceptions dans la bibliothèque python-gitlab affiche le\nmessage d'erreur et renvoie à la documentation. Pour le débogage, notez que\nles objets peuvent ne pas être disponibles pour la gestion lorsque vous ne\npouvez pas accéder aux attributs de l'objet ou aux appels de fonction.\n\n\n```shell\n\n$ python3 python_gitlab_manageable_objects.py\n\n\n🤔 Project: GitLab API Playground 💡 Branches: cicd-demo-automated-comments,\ndocs-mr-approval-settings, main\n\n\nGot exception: 'GroupProject' object has no attribute 'branches'\n\n\n\u003Cclass 'gitlab.v4.objects.projects.GroupProject'> was created via a\n\nlist() call and only a subset of the data may be present. To ensure\n\nall data is present get the object using a get(object.id) call. For\n\nmore details, see:\n\n\nhttps://python-gitlab.readthedocs.io/en/v3.8.1/faq.html#attribute-error-list\n =====================================\n```\n\n\n[Consultez le script\ncomplet](https://gitlab.com/gitlab-da/use-cases/gitlab-api/gitlab-api-python/-/blob/main/python_gitlab_manageable_objects.py).\n\n\n### Le travail avec différents scopes de collection d'objets\n\n\nParfois, le script doit collecter tous les projets d'une instance\nauto-gérée, d'un groupe avec des sous-groupes, ou d'un projet unique. Ce\ndernier cas est utile pour accélérer les tests sur les attributs requis, et\nla récupération du groupe facilite les tests à grande échelle par la suite.\nL'extrait de code suivant collecte tous les objets de projet dans la liste\n`projects` et y ajoute les objets provenant des différentes configurations\nentrantes. Vous retrouverez également à nouveau le modèle d'objet gérable\npour le projet dans les groupes.\n\n\n```python\n    # Collect all projects, or prefer projects from a group id, or a project id\n    projects = []\n\n    # Direct project ID\n    if PROJECT_ID:\n        projects.append(gl.projects.get(PROJECT_ID))\n\n    # Groups and projects inside\n    elif GROUP_ID:\n        group = gl.groups.get(GROUP_ID)\n\n        for project in group.projects.list(include_subgroups=True, all=True):\n            # https://python-gitlab.readthedocs.io/en/stable/gl_objects/groups.html#examples\n            manageable_project = gl.projects.get(project.id)\n            projects.append(manageable_project)\n\n    # All projects on the instance (may take a while to process)\n    else:\n        projects = gl.projects.list(get_all=True)\n```\n\n\nL'exemple complet se trouve dans [ce\nscript](https://gitlab.com/gitlab-da/use-cases/gitlab-api/gitlab-api-python/-/blob/main/get_mr_approval_rules.py)\npour lister les paramètres des règles d'approbation des merge requests pour\nles cibles de projet spécifiées.\n\n\n## Utilisation de l’approche DevSecOps pour les actions de lecture API\n\n\nLe jeton d'accès authentifié nécessite un scope `read_api`.\n\n\nLes cas d’utilisation suivants seront abordés :\n\n- Lister les branches par état de fusion,\n\n- Afficher les paramètres du projet pour révision : règles d'approbation des\nmerge requests,\n\n- Inventaire : obtenir toutes les variables CI/CD protégées ou masquées,\n\n- Télécharger un fichier depuis le dépôt,\n\n- Aide à la migration : lister tous les clusters Kubernetes basés sur des\ncertificats,\n\n- Productivité des équipes : vérifier si les merge requests existantes\nnécessitent un rebase après avoir fusionné une merge request de\nrefactorisation majeure.  \n\n\n### Lister les branches par état de fusion \n\n\nPour nettoyer un projet\n[Git](https://about.gitlab.com/fr-fr/blog/what-is-git/ \"Qu'est-ce\nque Git ?\"), il est courant d'évaluer le nombre de branches fusionnées et\nnon fusionnées. En réponse à une [question sur le forum de la communauté\nGitLab](https://forum.gitlab.com/t/python-gitlab-project-branch-list-filter/80257)\nconcernant le filtrage des listes de branches, j'ai écrit un\n[script](https://gitlab.com/gitlab-da/use-cases/gitlab-api/gitlab-api-python/-/tree/main)\naidant à cela. La méthode `branches.list()` renvoie tous les objets de\nbranche stockés dans une liste temporaire, pour un traitement ultérieur en\ndeux boucles : la collecte des noms de branches fusionnées, et celle des\nnoms de branches non fusionnées. L'attribut `merged` sur l'objet `branch`\nest une valeur booléenne qui indique si la branche a été fusionnée ou non.\n\n\n```python\n\nproject = gl.projects.get(PROJECT_ID, lazy=False, pagination=\"keyset\",\norder_by=\"updated_at\", per_page=100)\n\n\n# Get all branches\n\nreal_branches = []\n\nfor branch in project.branches.list():\n    real_branches.append(branch)\n\nprint(\"All branches\")\n\nfor rb in real_branches:\n    print(\"Branch: {b}\".format(b=rb.name))\n\n# Get all merged branches\n\nmerged_branches_names = []\n\nfor branch in real_branches:\n    if branch.default:\n        continue # ignore the default branch for merge status\n\n    if branch.merged:\n        merged_branches_names.append(branch.name)\n\nprint(\"Branches merged: {b}\".format(b=\", \".join(merged_branches_names)))\n\n\n# Get un-merged branches\n\nnot_merged_branches_names = []\n\nfor branch in real_branches:\n    if branch.default:\n        continue # ignore the default branch for merge status\n\n    if not branch.merged:\n        not_merged_branches_names.append(branch.name)\n\nprint(\"Branches not merged: {b}\".format(b=\",\n\".join(not_merged_branches_names)))\n\n```\n\n\nLe workflow est destiné à être lu étape par étape. Vous pouvez vous\nentraîner à optimiser le code Python pour la collecte conditionnelle des\nnoms de branches.\n\n\n### Afficher les paramètres du projet pour examen : règles d'approbation des\nmerge requests\n\n\nLe\n[script](https://gitlab.com/gitlab-da/use-cases/gitlab-api/gitlab-api-python/-/blob/main/get_mr_approval_rules.py)\nsuivant parcourt tous les objets de projet collectés et vérifie si des\nrègles d'approbation sont spécifiées. Si la longueur de la liste est\nsupérieure à zéro, il parcourt la liste en boucle et affiche les paramètres\navec la méthode JSON pretty print.\n\n\n```python\n    # Loop over projects and print the settings\n    # https://python-gitlab.readthedocs.io/en/stable/gl_objects/merge_request_approvals.html\n    for project in projects:\n        if len(project.approvalrules.list()) > 0:\n            #print(project) #debug\n            print(\"# Project: {name}, ID: {id}\\n\\n\".format(name=project.name_with_namespace, id=project.id))\n            print(\"[MR Approval settings]({url}/-/settings/merge_requests)\\n\\n\".format(url=project.web_url))\n\n            for ar in project.approvalrules.list():\n                print(\"## Approval rule: {name}, ID: {id}\".format(name=ar.name, id=ar.id))\n                print(\"\\n```json\\n\")\n                print(json.dumps(ar.attributes, indent=2)) # TODO: can be more beautiful, but serves its purpose with pretty print JSON\n                print(\"\\n```\\n\")\n\n```\n\n\n### Inventaire : obtenir toutes les variables CI/CD protégées ou masquées\n\n\nLes [variables CI/CD](https://docs.gitlab.com/ee/ci/variables/ \"Variables\nCI/CD\") sont utiles au paramétrage des pipelines et peuvent être configurées\nglobalement sur l'instance, dans les groupes et dans les projets. Nous\npouvons aussi y stocker des informations confidentielles, des mots de passe\nou encore des secrets. Il peut parfois être nécessaire d’avoir une vue\nd'ensemble de toutes les variables CI/CD protégées ou masquées pour estimer\nle nombre de variables à actualiser, lors de la rotation des jetons par\nexemple.\n\n\nLe\n[script](https://gitlab.com/gitlab-da/use-cases/gitlab-api/gitlab-api-python/-/blob/main/get_all_cicd_variables_masked_or_protected.py)\nsuivant récupère tous les groupes et projets, puis tente de collecter les\nvariables CI/CD de l'instance globale (cela nécessite des autorisations\nd'administrateur), des groupes et des projets (cela nécessite des\nautorisations de chargé de maintenance/propriétaire). Il affiche toutes les\nvariables CI/CD qui sont soit protégées, soit masquées, en précisant qu'une\nvaleur potentiellement secrète y est stockée.\n\n\n```python\n\n#!/usr/bin/env python\n\n\nimport gitlab\n\nimport os\n\nimport sys\n\n\n# Helper function to evaluate secrets and print the variables\n\ndef eval_print_var(var):\n    if var.protected or var.masked:\n        print(\"🛡️🛡️🛡️ Potential secret: Variable '{name}', protected {p}, masked: {m}\".format(name=var.key,p=var.protected,m=var.masked))\n\nGITLAB_SERVER = os.environ.get('GL_SERVER', 'https://gitlab.com')\n\nGITLAB_TOKEN = os.environ.get('GL_TOKEN') # token requires maintainer+\npermissions. Instance variables require admin access.\n\nPROJECT_ID = os.environ.get('GL_PROJECT_ID') #optional\n\nGROUP_ID = os.environ.get('GL_GROUP_ID', 8034603) #\nhttps://gitlab.com/everyonecancontribute\n\n\nif not GITLAB_TOKEN:\n    print(\"🤔 Please set the GL_TOKEN env variable.\")\n    sys.exit(1)\n\ngl = gitlab.Gitlab(GITLAB_SERVER, private_token=GITLAB_TOKEN)\n\n\n# Collect all projects, or prefer projects from a group id, or a project id\n\nprojects = []\n\n# Collect all groups, or prefer group from a group id\n\ngroups = []\n\n\n# Direct project ID\n\nif PROJECT_ID:\n    projects.append(gl.projects.get(PROJECT_ID))\n\n# Groups and projects inside\n\nelif GROUP_ID:\n    group = gl.groups.get(GROUP_ID)\n\n    for project in group.projects.list(include_subgroups=True, all=True):\n        # https://python-gitlab.readthedocs.io/en/stable/gl_objects/groups.html#examples\n        manageable_project = gl.projects.get(project.id)\n        projects.append(manageable_project)\n\n    groups.append(group)\n\n# All projects/groups on the instance (may take a while to process, use\niterators to fetch on-demand).\n\nelse:\n    projects = gl.projects.list(iterator=True)\n    groups = gl.groups.list(iterator=True)\n\nprint(\"# List of all CI/CD variables marked as secret (instance, groups,\nprojects)\")\n\n\n# https://python-gitlab.readthedocs.io/en/stable/gl_objects/variables.html\n\n\n# Instance variables (if the token has permissions)\n\nprint(\"Instance variables, if accessible\")\n\ntry:\n    for i_var in gl.variables.list(iterator=True):\n        eval_print_var(i_var)\nexcept:\n    print(\"No permission to fetch global instance variables, continueing without.\")\n    print(\"\\n\")\n\n# group variables (maintainer permissions for groups required)\n\nfor group in groups:\n    print(\"Group {n}, URL: {u}\".format(n=group.full_path, u=group.web_url))\n    for g_var in group.variables.list(iterator=True):\n        eval_print_var(g_var)\n\n    print(\"\\n\")\n\n# Loop over projects and print the settings\n\nfor project in projects:\n    # skip archived projects, they throw 403 errors\n    if project.archived:\n        continue\n\n    print(\"Project {n}, URL: {u}\".format(n=project.path_with_namespace, u=project.web_url))\n    for p_var in project.variables.list(iterator=True):\n        eval_print_var(p_var)\n\n    print(\"\\n\")\n```\n\n\nLe script n’affiche pas les valeurs des variables, cela étant réservé comme\nexercice pour les environnements sécurisés. Pour stocker des secrets, faites\nplutôt appel à des [fournisseurs\nexternes](https://docs.gitlab.com/ee/ci/secrets/).\n\n\n### Télécharger un fichier depuis le dépôt\n\n\nL'objectif de ce\n[script](https://gitlab.com/gitlab-da/use-cases/gitlab-api/gitlab-api-python/-/blob/main/get_raw_file_content.py)\nest de télécharger un fichier à partir d’un chemin spécifié dans une branche\ndonnée, et de stocker son contenu dans un nouveau fichier.\n\n\n```python\n\n# Goal: Try to download README.md from\nhttps://gitlab.com/gitlab-de/use-cases/gitlab-api/gitlab-api-python/-/blob/main/README.md\n\nFILE_NAME = 'README.md'\n\nBRANCH_NAME = 'main'\n\n\n# Search the file in the repository tree and get the raw blob\n\nfor f in project.repository_tree():\n    print(\"File path '{name}' with id '{id}'\".format(name=f['name'], id=f['id']))\n\n    if f['name'] == FILE_NAME:\n        f_content = project.repository_raw_blob(f['id'])\n        print(f_content)\n\n# Alternative approach: Get the raw file from the main branch\n\nraw_content = project.files.raw(file_path=FILE_NAME, ref=BRANCH_NAME)\n\nprint(raw_content)\n\n\n# Store the file on disk\n\nwith open('raw_README.md', 'wb') as f:\n    project.files.raw(file_path=FILE_NAME, ref=BRANCH_NAME, streamed=True, action=f.write)\n```\n\n\n### Aide à la migration : lister tous les clusters Kubernetes basés sur des\ncertificats\n\n\nL'intégration des clusters\n[Kubernetes](https://about.gitlab.com/fr-fr/blog/kubernetes-the-container-orchestration-solution/\n\"Qu'est-ce que Kubernetes ?\") basée sur des certificats dans GitLab [a été\ndépréciée](https://docs.gitlab.com/ee/update/deprecations.html#self-managed-certificate-based-integration-with-kubernetes).\nPour faciliter les plans de migration, l'inventaire des groupes et projets\nexistants peut être automatisé à l'aide de l'API GitLab.\n\n\n```python\n\ngroups = [ ]\n\n\n# get GROUP_ID group\n\ngroups.append(gl.groups.get(GROUP_ID))\n\n\nfor group in groups:\n    for sg in group.subgroups.list(include_subgroups=True, all=True):\n        real_group = gl.groups.get(sg.id)\n        groups.append(real_group)\n\ngroup_clusters = {}\n\nproject_clusters = {}\n\n\nfor group in groups:\n    #Collect group clusters\n    g_clusters = group.clusters.list()\n\n    if len(g_clusters) > 0:\n        group_clusters[group.id] = g_clusters\n\n    # Collect all projects in group and subgroups and their clusters\n    projects = group.projects.list(include_subgroups=True, all=True)\n\n    for project in projects:\n        # https://python-gitlab.readthedocs.io/en/stable/gl_objects/groups.html#examples\n        manageable_project = gl.projects.get(project.id)\n\n        # skip archived projects\n        if project.archived:\n            continue\n\n        p_clusters = manageable_project.clusters.list()\n\n        if len(p_clusters) > 0:\n            project_clusters[project.id] = p_clusters\n\n# Print summary\n\nprint(\"## Group clusters\\n\\n\")\n\nfor g_id, g_clusters in group_clusters.items():\n    url = gl.groups.get(g_id).web_url\n    print(\"Group ID {g_id}: {u}\\n\\n\".format(g_id=g_id, u=url))\n    print_clusters(g_clusters)\n\nprint(\"## Project clusters\\n\\n\")\n\nfor p_id, p_clusters in project_clusters.items():\n    url = gl.projects.get(p_id).web_url\n    print(\"Project ID {p_id}: {u}\\n\\n\".format(p_id=p_id, u=url))\n    print_clusters(p_clusters)\n```\n\n\n[Consultez le script\ncomplet](https://gitlab.com/gitlab-da/use-cases/gitlab-api/gitlab-api-python/-/blob/main/list_cert_based_kubernetes_clusters.py).\n\n\n### Productivité des équipes : vérifier si les merge requests existantes\nnécessitent un rebase après avoir fusionné une merge request de\nrefactorisation majeure\n\n\nLe dépôt du [manuel GitLab](https://about.gitlab.com/handbook/ \"Manuel de\nGitLab\") est un large monorepo qui contient de nombreuses merge requests\ncréées, examinées, approuvées et fusionnées. Certaines revues prennent plus\nde temps que d'autres, et certaines merge requests impactent plusieurs\npages, lorsqu'il s'agit par exemple de renommer une chaîne de caractères ou\n[toutes les pages du\nmanuel](https://about.gitlab.com/handbook/about/#count-handbook-pages). Le\nmanuel Marketing avait besoin d’une restructuration (pensez à une\nrefactorisation du code), et de nombreux répertoires et chemins d'accès ont\nété déplacés ou renommés. \n\n\nLes [tâches liées aux\ntickets](https://gitlab.com/gitlab-com/www-gitlab-com/-/issues/13991#tasks)\nont augmenté au fil du temps, et nous craignons que des conflits sur\nd'autres merge requests apparaissent après avoir fusionné des changements\nimportants. Avec python-gitlab vous pouvez récupérer toutes les merge\nrequests dans un projet donné, y compris les détails sur la branche Git, sur\nles chemins sources modifiés, et bien plus encore.\n\n\nLe script résultant configure une liste des sources touchées par toutes les\nmerge requests, vérifie si la merge request diffère avec `mr.diffs.list()`,\net si un modèle correspond à la valeur dans `old_path`. Si une\ncorrespondance est trouvée, le script l'enregistre et sauvegarde la merge\nrequest dans le dictionnaire `seen_mr`, pour un résumé ultérieur. Des\nattributs supplémentaires sont collectés pour afficher une liste de tâches\nen Markdown contenant des URL, afin de faciliter le copier-coller dans les\n[descriptions des\ntickets](https://gitlab.com/gitlab-com/www-gitlab-com/-/issues/13991#additional-tasks).\n[Consultez le script\ncomplet](https://gitlab.com/gitlab-da/use-cases/gitlab-api/gitlab-api-python/-/blob/main/search_mr_contains_updated_path.py).\n\n\n```python\n\nPATH_PATTERNS = [\n    'path/to/handbook/source/page.md',\n]\n\n\n# Only list opened MRs\n\n#\nhttps://python-gitlab.readthedocs.io/en/stable/gl_objects/merge_requests.html#project-merge-requests\n\nmrs = project.mergerequests.list(state='opened', iterator=True)\n\n\nseen_mr = {}\n\n\nfor mr in mrs:\n    # https://docs.gitlab.com/ee/api/merge_requests.html#list-merge-request-diffs\n    real_mr = project.mergerequests.get(mr.get_id())\n    real_mr_id = real_mr.attributes['iid']\n    real_mr_url = real_mr.attributes['web_url']\n\n    for diff in real_mr.diffs.list(iterator=True):\n        real_diff = real_mr.diffs.get(diff.id)\n\n        for d in real_diff.attributes['diffs']:\n            for p in PATH_PATTERNS:\n                if p in d['old_path']:\n                    print(\"MATCH: {p} in MR {mr_id}, status '{s}', title '{t}' - URL: {mr_url}\".format(\n                        p=p,\n                        mr_id=real_mr_id,\n                        s=mr_status,\n                        t=real_mr.attributes['title'],\n                        mr_url=real_mr_url))\n\n                    if not real_mr_id in seen_mr:\n                        seen_mr[real_mr_id] = real_mr\n\nprint(\"\\n# MRs to update\\n\")\n\n\nfor id, real_mr in seen_mr.items():\n    print(\"- [ ] !{mr_id} - {mr_url}+ Status: {s}, Title: {t}\".format(\n        mr_id=id,\n        mr_url=real_mr.attributes['web_url'],\n        s=real_mr.attributes['detailed_merge_status'],\n        t=real_mr.attributes['title']))\n```\n\n\n## Cas d’utilisation DevSecOps pour les actions d'écriture de l’API\n\n\nLe jeton d'accès authentifié nécessite une [portée d’autorisation complète\nde\nl’API](https://docs.gitlab.com/ee/user/profile/personal_access_tokens.html#personal-access-token-scopes). \n\n\nLes cas d’utilisation suivants sont abordés :\n\n- Déplacer des epics d’un groupe à l’autre,\n\n- Conformité : vérifier que les paramètres du projet ne sont pas remplacés,\n\n- Prendre des notes, générer un aperçu de la date d'échéance,\n\n\n### Déplacer des epics d’un groupe à l’autre\n\n\nVous devez parfois déplacer des epics dans un autre groupe. Une question\nposée dans le Slack de GitLab nous a incité à examiner une [proposition de\nfonctionnalité pour l'interface\nutilisateur](https://gitlab.com/gitlab-org/gitlab/-/issues/12689), pour plus\ntard écrire un script API permettant d'automatiser ces étapes. L'idée\nconsiste à déplacer une epic d'un groupe source vers un groupe cible, et de\ncopier son titre, sa description et ses labels. Puisque les epics permettent\nde regrouper les tickets, elles doivent également être réaffectées à l'epic\ncible. Il faut aussi prendre en compte les relations parent-enfant des\nepics, toutes les epics enfants des epics sources devant être réaffectées à\nl'epic cible.\n\n\nLe script suivant recherche d'abord tous les attributs de l'epic source,\npuis crée une nouvelle epic cible avec des attributs minimaux : titre et\ndescription. La liste des labels est copiée et les modifications sont\nconservées grâce à l'appel `save()`. Les tickets attribués à l'epic doivent\nêtre recréés dans l'epic cible. L'appel `create()` crée l'élément de\nrelation, et non un nouvel objet de ticket en tant que tel. Le déplacement\ndes epics enfants nécessite une approche différente, car la relation est\ninversée : le `parent_id` de l'epic enfant doit être comparé à l'identifiant\nde l'epic source et, s'il correspond, mis à jour vers l'identifiant de\nl'epic cible. Après avoir tout copié avec succès, l'epic source doit être\npassée à l'état `closed`.\n\n\n```python\n\n#!/usr/bin/env python\n\n\n# Description: Show how epics can be moved between groups, including title,\ndescription, labels, child epics and issues.\n\n# Requirements: python-gitlab Python libraries. GitLab API write access, and\nmaintainer access to all configured groups/projects.\n\n# Author: Michael Friedrich \u003Cmfriedrich@gitlab.com>\n\n# License: MIT, (c) 2023-present GitLab B.V.\n\n\nimport gitlab\n\nimport os\n\nimport sys\n\n\nGITLAB_SERVER = os.environ.get('GL_SERVER', 'https://gitlab.com')\n\n# https://gitlab.com/gitlab-da/use-cases/gitlab-api\n\nSOURCE_GROUP_ID = os.environ.get('GL_SOURCE_GROUP_ID', 62378643)\n\n# https://gitlab.com/gitlab-da/use-cases/gitlab-api/epic-move-target\n\nTARGET_GROUP_ID = os.environ.get('GL_TARGET_GROUP_ID', 62742177)\n\n# https://gitlab.com/groups/gitlab-da/use-cases/gitlab-api/-/epics/1\n\nEPIC_ID = os.environ.get('GL_EPIC_ID', 1)\n\nGITLAB_TOKEN = os.environ.get('GL_TOKEN')\n\n\nif not GITLAB_TOKEN:\n    print(\"Please set the GL_TOKEN env variable.\")\n    sys.exit(1)\n\ngl = gitlab.Gitlab(GITLAB_SERVER, private_token=GITLAB_TOKEN)\n\n\n# Main\n\n# Goal: Move epic to target group, including title, body, labels, and child\nepics and issues.\n\nsource_group = gl.groups.get(SOURCE_GROUP_ID)\n\ntarget_group = gl.groups.get(TARGET_GROUP_ID)\n\n\n# Create a new target epic and copy all its items, then close the source\nepic.\n\nsource_epic = source_group.epics.get(EPIC_ID)\n\n# print(source_epic) #debug\n\n\nepic_title = source_epic.title\n\nepic_description = source_epic.description\n\nepic_labels = source_epic.labels\n\nepic_issues = source_epic.issues.list()\n\n\n# Create the epic with minimal attributes\n\ntarget_epic = target_group.epics.create({\n    'title': epic_title,\n    'description': epic_description,\n})\n\n\n# Assign the list\n\ntarget_epic.labels = epic_labels\n\n\n# Persist the changes in the new epic\n\ntarget_epic.save()\n\n\n# Epic issues need to be re-assigned in a loop\n\nfor epic_issue in epic_issues:\n    ei = target_epic.issues.create({'issue_id': epic_issue.id})\n\n# Child epics need to update their parent_id to the new epic\n\n# Need to search in all epics, use lazy object loading\n\nfor sge in source_group.epics.list(lazy=True):\n    # this epic has the source epic as parent epic?\n    if sge.parent_id == source_epic.id:\n        # Update the parent id\n        sge.parent_id = target_epic.id\n        sge.save()\n\nprint(\"Copied source epic {source_id} ({source_url}) to target epic\n{target_id} ({target_url})\".format(\n    source_id=source_epic.id, source_url=source_epic.web_url,\n    target_id=target_epic.id, target_url=target_epic.web_url))\n\n# Close the old epic\n\nsource_epic.state_event = 'close'\n\nsource_epic.save()\n\nprint(\"Closed source epic {source_id} ({source_url})\".format(\n    source_id=source_epic.id, source_url=source_epic.web_url))\n```\n\n\n```shell\n\n$  python3 move_epic_between_groups.py\n\nCopied source epic 725341\n(https://gitlab.com/groups/gitlab-da/use-cases/gitlab-api/-/epics/1) to\ntarget epic 725358\n(https://gitlab.com/groups/gitlab-da/use-cases/gitlab-api/epic-move-target/-/epics/6)\n\nClosed source epic 725341\n(https://gitlab.com/groups/gitlab-da/use-cases/gitlab-api/-/epics/1)\n\n```\n\n\nL'[epic\ncible](https://gitlab.com/groups/gitlab-da/use-cases/gitlab-api/epic-move-target/-/epics/5\n\"Epic cible\") a été créée et affiche le résultat attendu : même titre,\ndescription, labels, epic enfant et tickets. \n\n\n![Tutoriel sur l'API GitLab : déplacer des\nepics](https://about.gitlab.com/images/blogimages/efficient-devsecops-workflows-python-gitlab-handson/python_gitlab_moved_epic_with_all_attributes.png){:\n.shadow}\n\n\n__Exercice :__ le script ne copie pas encore les\n[commentaires](https://python-gitlab.readthedocs.io/en/stable/gl_objects/notes.html)\net les [fils de\ndiscussion](https://python-gitlab.readthedocs.io/en/stable/gl_objects/discussions.html).\nFaites des recherches et aidez-nous à mettre à jour le script. Les merge\nrequests sont les bienvenues !\n\n\n### Conformité : vérifier que les paramètres du projet ne sont pas remplacés\n\n\nLes paramètres des projets et des groupes peuvent être modifiés\naccidentellement par des membres de l'équipe. Les exigences de conformité\ndoivent être respectées. Autre cas d’utilisation : gérer la configuration\navec des outils d’[Infrastructure as\nCode](https://about.gitlab.com/fr-fr/topics/gitops/infrastructure-as-code/\n\"Infrastructure as Code\") et s'assurer que la configuration de GitLab reste\nla même au niveau du groupe, du projet et autres. Des outils comme Ansible\nou Terraform peuvent invoquer un script API ou utiliser la bibliothèque\npython-gitlab pour effectuer des tâches de gestion des paramètres.\n\n\nDans l'exemple suivant, seule la branche `main` est protégée.\n\n\n![API python-gitlab : protection des\nbranches](https://about.gitlab.com/images/blogimages/efficient-devsecops-workflows-python-gitlab-handson/python_gitlab_protected_branches_settings_main.png){:\n.shadow}\n\n\nSupposons qu'une nouvelle branche `production` a été ajoutée et qu’elle doit\négalement être protégée. Le script suivant définit le dictionnaire des\nbranches protégées et leurs niveaux d'accès pour les autorisations de push\net de fusion au niveau du chargé de maintenance. Il établit la logique de\ncomparaison de la [documentation python-gitlab sur les branches\nprotégées](https://python-gitlab.readthedocs.io/en/stable/gl_objects/protected_branches.html).\n\n\n```python\n\n#!/usr/bin/env python\n\n\nimport gitlab\n\nimport os\n\nimport sys\n\n\nGITLAB_SERVER = os.environ.get('GL_SERVER', 'https://gitlab.com')\n\n# https://gitlab.com/gitlab-da/use-cases/\n\nGROUP_ID = os.environ.get('GL_GROUP_ID', 16058698)\n\nGITLAB_TOKEN = os.environ.get('GL_TOKEN')\n\n\nPROTECTED_BRANCHES = {\n    'main': {\n        'merge_access_level': gitlab.const.AccessLevel.MAINTAINER,\n        'push_access_level': gitlab.const.AccessLevel.MAINTAINER\n    },\n    'production': {\n        'merge_access_level': gitlab.const.AccessLevel.MAINTAINER,\n        'push_access_level': gitlab.const.AccessLevel.MAINTAINER\n    },\n}\n\n\nif not GITLAB_TOKEN:\n    print(\"Please set the GL_TOKEN env variable.\")\n    sys.exit(1)\n\ngl = gitlab.Gitlab(GITLAB_SERVER, private_token=GITLAB_TOKEN)\n\n\n# Main\n\ngroup = gl.groups.get(GROUP_ID)\n\n\n# Collect all projects in group and subgroups\n\nprojects = group.projects.list(include_subgroups=True, all=True)\n\n\nfor project in projects:\n    # Retrieve a full manageable project object\n    # https://python-gitlab.readthedocs.io/en/stable/gl_objects/groups.html#examples\n    manageable_project = gl.projects.get(project.id)\n\n    # https://python-gitlab.readthedocs.io/en/stable/gl_objects/protected_branches.html\n    protected_branch_names = []\n\n    for pb in manageable_project.protectedbranches.list():\n        manageable_protected_branch = manageable_project.protectedbranches.get(pb.name)\n        print(\"Protected branch name: {n}, merge_access_level: {mal}, push_access_level: {pal}\".format(\n            n=manageable_protected_branch.name,\n            mal=manageable_protected_branch.merge_access_levels,\n            pal=manageable_protected_branch.push_access_levels\n        ))\n\n        protected_branch_names.append(manageable_protected_branch.name)\n\n    for branch_to_protect, levels in PROTECTED_BRANCHES.items():\n        # Fix missing protected branches\n        if branch_to_protect not in protected_branch_names:\n            print(\"Adding branch {n} to protected branches settings\".format(n=branch_to_protect))\n            p_branch = manageable_project.protectedbranches.create({\n                'name': branch_to_protect,\n                'merge_access_level': gitlab.const.AccessLevel.MAINTAINER,\n                'push_access_level': gitlab.const.AccessLevel.MAINTAINER\n            })\n```\n\n\nL'exécution du script affiche la branche `main` existante, ainsi qu’une note\nindiquant que la branche `production` sera mise à jour. La capture d'écran\ndes paramètres du dépôt démontre cette action.\n\n\n```\n\n$ python3\nenforce_protected_branches.py                                               \n─╯\n\nProtected branch name: main, merge_access_level: [{'id': 67294702,\n'access_level': 40, 'access_level_description': 'Maintainers', 'user_id':\nNone, 'group_id': None}], push_access_level: [{'id': 68546039,\n'access_level': 40, 'access_level_description': 'Maintainers', 'user_id':\nNone, 'group_id': None}]\n\nAdding branch production to protected branches settings\n\n```\n\n\n![Capture d'écran de code en Python avec\nGitLab](https://about.gitlab.com/images/blogimages/efficient-devsecops-workflows-python-gitlab-handson/python_gitlab_protected_branches_settings_main_production.png){:\n.shadow}\n\n\n### Prise de notes : générer un aperçu de la date d'échéance\n\n\nUne [discussion de Hacker News sur les outils de prise de\nnotes](https://news.ycombinator.com/item?id=32155848) nous a inspiré la\ncréation d'un tableau Markdown, extrait de fichiers de prise de notes, et\ntrié par date d'échéance. Le script est plus complexe à comprendre.\n","engineering",[9,683,684,685],"tutorial","DevSecOps","DevSecOps platform",{"slug":687,"featured":6,"template":688},"efficient-devsecops-workflows-hands-on-python-gitlab-api-automation","BlogPost","content:fr-fr:blog:efficient-devsecops-workflows-hands-on-python-gitlab-api-automation.yml","Efficient Devsecops Workflows Hands On Python Gitlab Api Automation","fr-fr/blog/efficient-devsecops-workflows-hands-on-python-gitlab-api-automation.yml","fr-fr/blog/efficient-devsecops-workflows-hands-on-python-gitlab-api-automation",{"_path":694,"_dir":245,"_draft":6,"_partial":6,"_locale":7,"seo":695,"content":701,"config":710,"_id":712,"_type":13,"title":713,"_source":15,"_file":714,"_stem":715,"_extension":18},"/fr-fr/blog/enhance-application-security-with-gitlab-hackerone",{"title":696,"description":697,"ogTitle":696,"ogDescription":697,"noIndex":6,"ogImage":698,"ogUrl":699,"ogSiteName":673,"ogType":674,"canonicalUrls":699,"schema":700},"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":696,"description":697,"authors":702,"heroImage":698,"date":704,"body":705,"category":706,"tags":707,"updatedDate":709},[703],"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","security",[706,683,9,283,685,684,708],"bug bounty","2025-05-13",{"slug":711,"featured":6,"template":688},"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":717,"_dir":245,"_draft":6,"_partial":6,"_locale":7,"seo":718,"content":724,"config":735,"_id":737,"_type":13,"title":738,"_source":15,"_file":739,"_stem":740,"_extension":18},"/fr-fr/blog/gitlab-duo-amazon-q-transform-ideas-into-code-in-minutes",{"title":719,"description":720,"ogTitle":719,"ogDescription":720,"noIndex":6,"ogImage":721,"ogUrl":722,"ogSiteName":673,"ogType":674,"canonicalUrls":722,"schema":723},"GitLab Duo combiné à Amazon Q : créez de nouvelles fonctionnalités en quelques minutes","GitLab Duo combiné à Amazon Q analyse les descriptions de vos tickets et génère des solutions de code complètes et opérationnelles.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097127/Blog/Hero%20Images/Blog/Hero%20Images/Screenshot%202024-11-27%20at%204.55.28%E2%80%AFPM_4VVz6DgGBOvbGY8BUmd068_1750097126673.png","https://about.gitlab.com/blog/gitlab-duo-amazon-q-transform-ideas-into-code-in-minutes","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"GitLab Duo combiné à Amazon Q : créez de nouvelles fonctionnalités en quelques minutes\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Cesar Saavedra\"}],\n        \"datePublished\": \"2025-04-28\",\n      }\n                  ",{"title":719,"description":720,"authors":725,"heroImage":721,"date":727,"body":728,"category":729,"tags":730,"updatedDate":734},[726],"Cesar Saavedra","2025-04-28","Vous est-il déjà arrivé de passer des jours, voire des semaines, à transformer des idées complexes en code opérationnel ? Toutes les équipes de développement connaissent cette situation. Malgré un concept solide et des exigences claires, il peut falloir beaucoup de temps et d'efforts pour élaborer un code déployable. \n\nEt si les capacités de l'[IA agentique](https://about.gitlab.com/fr-fr/topics/agentic-ai/) pouvaient tout changer ? C'est exactement ce que propose [GitLab Duo combiné à Amazon Q](https://about.gitlab.com/fr-fr/blog/gitlab-duo-with-amazon-q-agentic-ai-optimized-for-aws/). En associant la plateforme [DevSecOps](https://about.gitlab.com/fr-fr/topics/devsecops/ \"Qu'est-ce que le DevSecOps ? \") complète alimentée par l'IA de GitLab aux fonctionnalités avancées de cloud computing d'AWS, cette intégration vous permet d'accélérer considérablement votre processus de développement d'applications, le tout au sein de votre workflow GitLab habituel. Le code que vos équipes de développement écrivent en plusieurs jours peut désormais être généré automatiquement en quelques minutes à partir des descriptions et exigences incluses dans vos tickets GitLab. \n\n## Transformer un ticket en code opérationnel\n\nDécouvrons comment cette fonctionnalité d'IA agentique fonctionne en pratique. Imaginez que vous deviez développer une application de calcul de prêt immobilier. Voici comment procéder à l'aide de GitLab Duo combiné à Amazon Q :\n\n1. **Créez votre ticket dans GitLab :** créez un [ticket](https://docs.gitlab.com/user/project/issues/) classique, contenant la liste complète des exigences de votre application. Ce ticket sert de point de départ pour développer votre solution logicielle.\n\n2. **Activez Amazon Q :** une fois votre ticket créé, ajoutez simplement un commentaire contenant la commande d'action rapide “/q dev” pour lancer Amazon Q et laisser la magie opérer. \n\n3. **Génération automatique du code :** GitLab Duo combiné à Amazon Q analyse votre ticket et le contexte de votre code source, puis génère automatiquement un code répondant à toutes vos spécifications. Et cerise sur le gâteau : l'IA soumet également ce code dans une merge request, prête pour la revue.\n\n![Capture d'écran de la fenêtre contextuelle de GitLab Duo combiné à Amazon Q](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097156/Blog/Content%20Images/Blog/Content%20Images/image1_aHR0cHM6_1750097156018.png)\n\n4. **Revue de l'application générée** : consultez la merge request pour vérifier que le code correspond bien à vos attentes et apportez des ajustements si nécessaire. \n\n5. **Testez votre application** : enfin, assurez-vous que l'application s'exécute correctement. Vous disposez désormais d'un code opérationnel conforme à vos exigences initiales, sans effort superflu.\n\n## Une nouvelle ère pour votre développement logiciel\n\nGitLab Duo combiné à Amazon Q révolutionne le développement logiciel en automatisant intelligemment les tâches complexes, réduisant ainsi drastiquement le temps nécessaire pour produire du code opérationnel. En tirant parti de l'IA agentique, vous pouvez accélérer le déploiement de vos nouvelles fonctionnalités, ce qui permet à vos équipes de se concentrer sur des tâches plus stratégiques.\n\nAvec GitLab Duo combiné à Amazon Q, dites adieu aux tâches manuelles et développez des logiciels plus rapidement, plus efficacement et plus facilement. Vous pouvez ainsi :\n\n* **Accélérer votre processus de développement** en automatisant la création de code conformément aux exigences du projet.\n* **Maintenir une qualité constante** lors de la génération de code, pour l'ensemble de vos projets.\n* **Réduire la charge mentale** en limitant la traduction manuelle des exigences en code opérationnel.\n* **Accélérer vos cycles de sortie des nouvelles versions** en supprimant les goulots d'étranglement, notamment ceux liés à l'implémentation.\n* **Optimiser l'expertise de votre équipe** en la recentrant sur la revue de code et l'optimisation de ce dernier, plutôt que sur son écriture.\n\nVous souhaitez découvrir GitLab Duo combiné à Amazon Q ? Regardez notre vidéo de démonstration et découvrez dès aujourd'hui comment optimiser votre workflow de développement.\n\n\u003C!-- blank line -->\n\u003Cfigure class=\"video_container\">\n  \u003Ciframe src=\"https://www.youtube.com/embed/jxxzNst3jpo?si=j_LQdZhUnwqoQEst\" title=\"GitLab Duo with Amazon Q demo video for dev workflow\" frameborder=\"0\" allowfullscreen=\"true\"> \u003C/iframe>\n\u003C/figure>\n\u003C!-- blank line -->\n\n> Pour en savoir plus sur GitLab Duo combiné à Amazon Q, [consultez notre documentation](https://docs.gitlab.com/user/duo_amazon_q/ \"Documentation Amazon Q\") ou [contactez notre équipe](https://about.gitlab.com/fr-fr/partners/technology-partners/aws/).","ai-ml",[731,732,683,685,733,9],"AI/ML","AWS","product","2025-06-03",{"slug":736,"featured":90,"template":688},"gitlab-duo-amazon-q-transform-ideas-into-code-in-minutes","content:fr-fr:blog:gitlab-duo-amazon-q-transform-ideas-into-code-in-minutes.yml","Gitlab Duo Amazon Q Transform Ideas Into Code In Minutes","fr-fr/blog/gitlab-duo-amazon-q-transform-ideas-into-code-in-minutes.yml","fr-fr/blog/gitlab-duo-amazon-q-transform-ideas-into-code-in-minutes",{"_path":742,"_dir":245,"_draft":6,"_partial":6,"_locale":7,"seo":743,"content":749,"config":757,"_id":759,"_type":13,"title":760,"_source":15,"_file":761,"_stem":762,"_extension":18},"/fr-fr/blog/gitlab-duo-with-amazon-q-devsecops-meets-agentic-ai",{"title":744,"description":745,"ogTitle":744,"ogDescription":745,"noIndex":6,"ogImage":746,"ogUrl":747,"ogSiteName":673,"ogType":674,"canonicalUrls":747,"schema":748},"GitLab Duo combiné à Amazon Q : quand le DevSecOps rencontre l’IA agentique","L'intégration d'agents d'IA autonomes dans la plateforme DevSecOps alimentée par l'IA de GitLab accélère la productivité des équipes de développement, la modernisation des applications et l'innovation.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749659604/Blog/Hero%20Images/Screenshot_2024-11-27_at_4.55.28_PM.png","https://about.gitlab.com/blog/gitlab-duo-with-amazon-q-devsecops-meets-agentic-ai","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"GitLab Duo combiné à Amazon Q : quand le DevSecOps rencontre l’IA agentique\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Emilio Salvador\"}],\n        \"datePublished\": \"2024-12-03\",\n      }",{"title":744,"description":745,"authors":750,"heroImage":746,"date":752,"body":753,"category":729,"tags":754,"updatedDate":756},[751],"Emilio Salvador","2024-12-03","Nous sommes ravis d'annoncer le lancement de GitLab Duo combiné à Amazon Q, une offre commune qui réunit la plateforme DevSecOps complète alimentée par l'IA de GitLab et les agents d'IA autonomes d'Amazon Q dans une solution unique et intégrée.\n\nGitLab Duo combiné à Amazon Q révolutionne le développement logiciel en intégrant de puissants agents d'IA directement dans vos workflows quotidiens. Au lieu de passer d'un outil à l'autre, les développeurs peuvent désormais accélérer les tâches clés (du développement de fonctionnalités aux revues de code) au sein de la plateforme DevSecOps complète de GitLab. Les agents d'IA d'Amazon Q agissent comme des assistants intelligents qui automatisent les tâches chronophages, telles que la génération de code à partir des conditions requises, la création de tests unitaires, les revues de code et la modernisation des applications Java. En gérant ces tâches complexes, cette offre commune aide les équipes à se concentrer sur l'innovation, tout en respectant les normes strictes de sécurité et de qualité.\n\nCette offre propose une expérience développeur optimisée pour les entreprises, avec les fonctionnalités suivantes :\n* La plateforme GitLab unifiée avec un magasin de données unique, qui automatise la compilation, les tests, l'empaquetage et le déploiement de code sécurisé\n* GitLab Duo combiné à Amazon Q Developer, qui tire parti du contexte des projets GitLab pour générer des modifications dans plusieurs fichiers en fonction des tâches\n* Les agents d'IA Amazon Q intégrés à GitLab Duo, qui mettent à jour les tickets et créent des merge requests par tâche, avec des autorisations limitées au projet\n\n\u003Cdiv style=\"padding:56.25% 0 0 0;position:relative;\">\u003Ciframe src=\"https://player.vimeo.com/video/1033653810?badge=0&autopause=0&player_id=0&app_id=58479\" frameborder=\"0\" allow=\"autoplay; fullscreen; picture-in-picture; clipboard-write\" style=\"position:absolute;top:0;left:0;width:100%;height:100%;\" title=\"GitLab Duo and Amazon Q\">\u003C/iframe>\u003C/div>\u003Cscript src=\"https://player.vimeo.com/api/player.js\">\u003C/script>\n\n## Un partenariat innovant entre GitLab et AWS\n\nGitLab Duo combiné à Amazon Q est le fruit d'une collaboration étroite entre les équipes d'ingénierie de GitLab et d'AWS, qui ont uni leurs forces pour transformer le développement logiciel. Ce partenariat associe l'expertise de GitLab en matière de pratique DevSecOps unifiée au leadership d'AWS dans le domaine du cloud computing, pour créer une solution innovante qui comprend la façon de travailler des équipes de développement.\n\nL'intégration des agents autonomes d'Amazon Q à la plateforme complète alimentée par l'IA de GitLab ne se limite pas à une simple intégration technique. Nous proposons une expérience qui rend le développement alimenté par l'IA naturel tout en garantissant la sécurité, la conformité et la fiabilité exigées par les entreprises.\n\nLes analystes du secteur reconnaissent l'importance de cette intégration pour améliorer le développement logiciel alimenté par l'IA :\n\n***« Avec cette offre commune, GitLab et AWS unissent leurs forces pour faire de l'IA agentique une réalité dans le développement logiciel », explique Katie Norton, Research Manager chez IDC. « GitLab Duo combiné à Amazon Q répond à des besoins bien définis et à des défis critiques qui permettent aux clients d'exploiter pleinement le potentiel de l'IA. »***\n\n***« Tant les développeurs que les entreprises pour lesquelles ils travaillent recherchent de plus en plus des expériences simplifiées et unifiées », déclare Rachel Stephens, Senior Analyst chez RedMonk. « Surtout à l'ère de l'IA, où la sécurité et la protection des données sont primordiales, les entreprises veulent exploiter la puissance des technologies de pointe tout en contrôlant les risques et en éliminant les chaînes d'outils logiciels disparates. Le partenariat entre GitLab Duo et Amazon Q offre aux développeurs les outils dont ils ont besoin dans le cadre d'une expérience DevSecOps complète. »***\n\n## 4 avantages clés pour les clients \n\nGitLab Duo combiné à Amazon Q associe l'approche DevSecOps alimentée par l'IA à l'ensemble le plus complet de fonctionnalités de cloud computing et permet aux équipes de développement de :\n\n### 1. Rationaliser le développement de fonctionnalités, de l'idée au code \n\nLes équipes de développement passent souvent de nombreuses heures à traduire les exigences en code, ce qui ralentit la livraison de fonctionnalités et aboutit à un déploiement incohérent. Vous pouvez désormais faire appel à GitLab Duo combiné à Amazon Q en utilisant la nouvelle action rapide `/q dev`, qui convertit en quelques minutes une description de ticket directement en code prêt à être intégré dans une merge request. L'agent analyse les exigences, planifie la mise en œuvre et génère une merge request complète, tout en respectant les normes de développement de votre équipe. Les équipes peuvent itérer rapidement grâce aux retours constructifs fournis dans les commentaires, ce qui réduit considérablement le délai nécessaire pour passer de l'idée à la production.\n\n\u003Cdiv style=\"padding:56.25% 0 0 0;position:relative;\">\u003Ciframe src=\"https://player.vimeo.com/video/1034050110?badge=0&autopause=0&player_id=0&app_id=58479\" frameborder=\"0\" allow=\"autoplay; fullscreen; picture-in-picture; clipboard-write\" style=\"position:absolute;top:0;left:0;width:100%;height:100%;\" title=\"Feature Dev with Rev\">\u003C/iframe>\u003C/div>\u003Cscript src=\"https://player.vimeo.com/api/player.js\">\u003C/script>\n\n### 2. Moderniser facilement le code hérité \n\nLa mise à niveau des applications Java nécessite généralement des semaines de planification minutieuse, des modifications manuelles du code et des tests approfondis. L'action rapide `/q transform` change la donne en automatisant l'ensemble du processus de modernisation du code des applications Java. En quelques minutes, et non plus en quelques heures, l'agent analyse votre code base Java 8 ou 11, crée un plan de mise à niveau complet et génère des merge requests entièrement documentées pour la migration vers Java 17. Chaque modification est suivie et traçable, ce qui donne confiance aux équipes tout en améliorant la sécurité et les performances des applications.\n\n\u003Cdiv style=\"padding:56.25% 0 0 0;position:relative;\">\u003Ciframe src=\"https://player.vimeo.com/video/1034050145?badge=0&autopause=0&player_id=0&app_id=58479\" frameborder=\"0\" allow=\"autoplay; fullscreen; picture-in-picture; clipboard-write\" style=\"position:absolute;top:0;left:0;width:100%;height:100%;\" title=\"QCT\">\u003C/iframe>\u003C/div>\u003Cscript src=\"https://player.vimeo.com/api/player.js\">\u003C/script>\n\n### 3. Accélérer les revues de code tout en maintenant la qualité \n\nLes revues de code créent souvent des goulots d'étranglement : les équipes attendent des jours pour obtenir des retours constructifs, mais doivent maintenir des normes cohérentes. Avec l'action rapide `/q review`, vous obtenez des retours instantanés et intelligents sur la qualité et la sécurité du code directement dans les merge requests. En identifiant automatiquement les problèmes potentiels et en suggérant des améliorations en fonction de vos normes, les équipes peuvent maintenir un code de haute qualité tout en réduisant considérablement les cycles de revue de code.\n\n\u003Cdiv style=\"padding:56.25% 0 0 0;position:relative;\">\u003Ciframe src=\"https://player.vimeo.com/video/1034050136?badge=0&autopause=0&player_id=0&app_id=58479\" frameborder=\"0\" allow=\"autoplay; fullscreen; picture-in-picture; clipboard-write\" style=\"position:absolute;top:0;left:0;width:100%;height:100%;\" title=\"Code Reviews\">\u003C/iframe>\u003C/div>\u003Cscript src=\"https://player.vimeo.com/api/player.js\">\u003C/script>\n\n### 4. Automatiser les tests pour livrer du code en toute confiance\n\nLa création manuelle de tests prend beaucoup de temps et aboutit souvent à une couverture de test incohérente entre les équipes. Avec l'action rapide `/q test`, vous pouvez générer automatiquement des tests unitaires complets qui comprennent la logique de votre application. L'agent assure une couverture de test de toutes les parties du code les plus critiques et des cas particuliers en s'alignant sur vos modèles de test actuels. Grâce à cette automatisation, les équipes peuvent détecter les problèmes plus tôt et maintenir des normes de qualité cohérentes, ce qui permet aux développeurs de gagner un temps précieux.\n\n\u003Cdiv style=\"padding:54.37% 0 0 0;position:relative;\">\u003Ciframe src=\"https://player.vimeo.com/video/1034050181?badge=0&autopause=0&player_id=0&app_id=58479\" frameborder=\"0\" allow=\"autoplay; fullscreen; picture-in-picture; clipboard-write\" style=\"position:absolute;top:0;left:0;width:100%;height:100%;\" title=\"Use GitLab Duo with Amazon Q to add tests\">\u003C/iframe>\u003C/div>\u003Cscript src=\"https://player.vimeo.com/api/player.js\">\u003C/script>\n\n## Sécurité et garde-fous de niveau entreprise\n\nConçue pour offrir une mise à l'échelle et une sécurité accrue aux entreprises, cette offre associe la sécurité, la conformité et la confidentialité intégrées de GitLab à l'agent d'IA d'Amazon Q. Elle accélère ainsi les workflows de développement, ce qui permet aux entreprises de livrer des logiciels sécurisés plus rapidement.\n\nElle inclut :\n\n* Des garde-fous intégrés qui maintiennent la vélocité du développement  \n* Des contrôles granulaires pour les fonctionnalités alimentées par l'IA à tous les niveaux : utilisateur, projet et groupe  \n* La sécurité intégrée à chaque étape du développement dans les workflows existants\n\nLes équipes DevSecOps peuvent faire évoluer l'environnement de développement en toute sécurité avec le cloud le plus utilisé au monde.\n\n## Ce qui vous attend\n\nGitLab Duo combiné à Amazon Q s'appuie sur notre intégration existante avec [AWS annoncée en mai 2024](https://press.aboutamazon.com/2024/4/aws-announces-general-availability-of-amazon-q-the-most-capable-generative-ai-powered-assistant-for-accelerating-software-development-and-leveraging-companies-internal-data). Il s'agit d'une étape importante dans notre mission commune de transformation du développement logiciel. Cette intégration plus poussée des fonctionnalités d'IA marque le début de notre collaboration élargie avec AWS. Nous continuerons à faire évoluer ces fonctionnalités en nous concentrant sur les objectifs suivants :\n\n* Extension des fonctionnalités d'IA à l'ensemble du cycle du développement logiciel  \n* Amélioration de la productivité des équipes de développement  \n* Réponse aux exigences de développement des entreprises à grande échelle\n\n**GitLab Duo combiné à Amazon Q est disponible dès aujourd'hui dans une [branche publique](https://gitlab.com/groups/gitlab-org/-/epics/16059) du Projet GitLab.org. Pour bénéficier d'un accès en avant-première et en savoir plus sur la façon dont GitLab et AWS transforment votre processus de développement logiciel, consultez [notre site web](https://about.gitlab.com/fr-fr/partners/technology-partners/aws/).**",[755,732,731,685,9],"news","2024-12-06",{"slug":758,"featured":90,"template":688},"gitlab-duo-with-amazon-q-devsecops-meets-agentic-ai","content:fr-fr:blog:gitlab-duo-with-amazon-q-devsecops-meets-agentic-ai.yml","Gitlab Duo With Amazon Q Devsecops Meets Agentic Ai","fr-fr/blog/gitlab-duo-with-amazon-q-devsecops-meets-agentic-ai.yml","fr-fr/blog/gitlab-duo-with-amazon-q-devsecops-meets-agentic-ai",{"_path":764,"_dir":245,"_draft":6,"_partial":6,"_locale":7,"seo":765,"content":771,"config":782,"_id":784,"_type":13,"title":785,"_source":15,"_file":786,"_stem":787,"_extension":18},"/fr-fr/blog/ultimate-guide-to-migrating-from-aws-codecommit-to-gitlab",{"title":766,"description":767,"ogTitle":766,"ogDescription":767,"noIndex":6,"ogImage":768,"ogUrl":769,"ogSiteName":673,"ogType":674,"canonicalUrls":769,"schema":770},"Migrer d'AWS CodeCommit vers GitLab : le guide complet ","Ce tutoriel vous explique comment migrer depuis les services Amazon Web Services (AWS) vers la plateforme DevSecOps de GitLab.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097810/Blog/Hero%20Images/Blog/Hero%20Images/blog-image-template-1800x945%20%2828%29_4mi0l4wzUa5VI4wtf8gInx_1750097810027.png","https://about.gitlab.com/blog/ultimate-guide-to-migrating-from-aws-codecommit-to-gitlab","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Migrer d'AWS CodeCommit vers GitLab : le guide complet \",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Tsukasa Komatsubara\"},{\"@type\":\"Person\",\"name\":\"Darwin Sanoy\"},{\"@type\":\"Person\",\"name\":\"Samer Akkoub\"},{\"@type\":\"Person\",\"name\":\"Bart Zhang\"}],\n        \"datePublished\": \"2024-08-26\",\n      }",{"title":766,"description":767,"authors":772,"heroImage":768,"date":777,"body":778,"category":733,"tags":779,"updatedDate":781},[773,774,775,776],"Tsukasa Komatsubara","Darwin Sanoy","Samer Akkoub","Bart Zhang","2024-08-26","Le 25 juillet 2024, AWS a communiqué une annonce importante concernant son service CodeCommit : AWS a décidé de fermer l'accès des nouveaux clients à CodeCommit. Bien que les clients existants puissent continuer à utiliser ce service, AWS n'introduira pas de nouvelles fonctionnalités, concentrant uniquement son attention sur la sécurité, la disponibilité et l'amélioration des performances.\n\nÀ la suite de cette annonce, les équipes de développement ont commencé à envisager de migrer leurs dépôts vers d'autres fournisseurs Git. En réponse à ces changements, nous avons rédigé ce guide complet dans le but d'aider les équipes à migrer vers GitLab et à s'intégrer avec d'autres services AWS.\n\n**Remarque :** pour en savoir plus sur les recommandations officielles d'AWS en matière de migration, veuillez consulter [leur article de blog](https://aws.amazon.com/blogs/devops/how-to-migrate-your-aws-codecommit-repository-to-another-git-provider/ \"Article de blog d'AWS annonçant l’arrêt d'AWS CodeCommit\").\n\n## À propos de ce guide\n\nCe guide contient des informations complètes destinées aux équipes de développement qui utilisent GitLab et qui envisagent une intégration avec les services AWS, ou à celles qui envisagent de migrer des dépôts [Git](https://about.gitlab.com/fr-fr/blog/what-is-git/ \"Qu'est-ce que Git ? \") hébergés sur AWS vers GitLab.com. \n\nNotre guide est composé de quatre sections principales :\n\n- __Migration en parallèle vers GitLab :__ nous vous expliquons comment migrer progressivement des dépôts existants hébergés sur AWS vers GitLab.com, tout en minimisant les risques.\n\n- __Intégration avec AWS CodeBuild :__ nous détaillons les étapes à suivre pour intégrer les dépôts GitLab avec AWS CodeBuild, et mettre en place un environnement d'[intégration continue (CI)](https://about.gitlab.com/fr-fr/topics/ci-cd/benefits-continuous-integration/ \"Qu'est-ce que l'intégration continue (CI) ?\") puissant.\n\n- __Intégration avec AWS CodePipeline :__ nous décrivons comment connecter les dépôts GitLab avec AWS CodePipeline pour construire des pipelines de [livraison continue (CD)](https://about.gitlab.com/fr-fr/topics/continuous-delivery/ \"Qu'est-ce que la livraison continue (CD) ?\") efficaces.\n\n- __Intégrations downstream pour AWS CodePipeline et CodeStar Connections :__ nous expliquons comment tirer parti des connexions entre GitLab et AWS pour disposer d'un accès étendu aux services, ce qui vous ouvre différentes possibilités d'intégration dans l'écosystème AWS.\n\nGrâce à ce guide, vous apprendrez à construire un workflow de développement efficace et flexible en combinant les puissantes fonctionnalités de [GitLab et AWS](https://about.gitlab.com/fr-fr/partners/technology-partners/aws/ \"GitLab et AWS\").\n\n## Section 1 : migration en parallèle vers GitLab \n\nSi vous envisagez de migrer des dépôts Git hébergés sur AWS vers GitLab.com, cette section présente des méthodes pour réaliser la migration progressivement tout en minimisant les risques. En mettant à profit les capacités de mise en miroir de GitLab, vous pouvez maintenir les flux de développement existants tout en testant le nouvel environnement.\n\n### Pourquoi la migration en parallèle est-elle importante ?\n\nLes migrations de systèmes à grande échelle comportent toujours des risques, en particulier des impacts potentiels sur les projets de développement en cours, les intégrations existantes et les processus automatisés. L'adoption d'une approche de migration en parallèle offre les avantages suivants :\n\n1. __Une minimisation des risques :__ testez le nouvel environnement tout en maintenant les systèmes existants opérationnels \n2. __Une transition fluide :__ les équipes de développement peuvent s'habituer progressivement au nouveau système.\n3. __Des tests d'intégration :__ testez minutieusement toutes les intégrations et l'automatisation dans le nouvel environnement.\n4. __Une pérennité :__ donnez aux équipes les moyens de migrer progressivement vers GitLab [CI/CD](https://about.gitlab.com/fr-fr/topics/ci-cd/ \"Qu'est-ce que le CI/CD ?\"), tout en continuant à utiliser le CI existant.\n\nLa migration en parallèle n'est pas nécessaire si vous savez déjà que vous souhaitez passer directement à GitLab.\n\n### Quelles sont les étapes pour migrer vers GitLab.com ? \n\n#### Étape 1 : configurez GitLab.com\n\n- Vérifiez si votre entreprise utilise déjà un groupe sur GitLab.com et si elle a mis en place une authentification unique (SSO). Si c'est le cas, vous vous servirez des deux.\n- Si votre entreprise n'a pas de compte sur GitLab.com, accédez au [site de GitLab](www.gitlab.com/fr-fr) et créez un nouveau compte ou connectez-vous à votre compte existant.\n- Créez un nouvel espace de nommage pour l'entreprise (un groupe au niveau racine sur GitLab.com).\n- Choisissez un nom disponible qui reflète l'ensemble de votre entreprise.\n\n#### Étape 2 : importez le dépôt\nPour effectuer la migration en parallèle, utilisez la fonctionnalité de mise en miroir de type « pull » de GitLab. Elle vous permet de synchroniser automatiquement les modifications des dépôts hébergés sur AWS vers GitLab.com.\n\n1. Accédez au groupe cible GitLab.com.\n2. En haut à droite, cliquez sur « Nouveau projet ».\n3. Sur la page « Créer un nouveau projet », cliquez sur « Importer un projet ».\n4. Sur la page « Importer un projet », cliquez sur « Dépôt par URL ».\n5. Saisissez l'URL de votre dépôt hébergé sur AWS dans le champ « URL du dépôt Git ».\n6. Sous le champ URL du dépôt Git, cochez « Dépôt miroir ».\n7. Configurez ensuite l'authentification. Dans la console AWS CodeCommit, sélectionnez l'URL du clone du dépôt que vous allez migrer. Si vous prévoyez d'importer des dépôts CodeCommit dans GitLab, vous pouvez utiliser l'URL HTTPS de CodeCommit pour cloner le dépôt en utilisant la fonctionnalité de mise en miroir du dépôt de GitLab. Vous devrez également fournir vos identifiants de connexion Git d'AWS pour votre utilisateur IAM (Identity and Access Management) dans GitLab. Reportez-vous à ce [guide](https://docs.aws.amazon.com/codecommit/latest/userguide/setting-up-gc.html) pour créer des identifiants de connexion Git pour AWS CodeCommit.\n\n![URL du clone](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097822/Blog/Content%20Images/Blog/Content%20Images/clone-url-screenshot__1__aHR0cHM6_1750097822121.png)\n\nCette configuration effectuera automatiquement un pull des modifications du dépôt hébergé sur AWS vers GitLab.com. La fréquence par défaut est de cinq minutes.\n\nPour plus d'informations, consultez notre [documentation sur la fonctionnalité de mise en miroir du dépôt de GitLab](https://docs.gitlab.com/ee/user/project/repository/mirror/).\n\n#### Étape 3 : testez et validez les intégrations\n\n1. __[Pipelines CI/CD](https://about.gitlab.com/fr-fr/topics/ci-cd/cicd-pipeline/ \"Qu'est-ce qu'un pipeline CI/CD ?\") :__ configurez le fichier `.gitlab-ci.yml` dans [GitLab CI](https://about.gitlab.com/fr-fr/blog/ci-deployment-and-environments/ \"Comment déployer du code dans des environnements multiples avec GitLab CI\") pour répliquer les pipelines existants. Plus d'informations sur [la planification d'une migration vers GitLab CI/CD à partir d'autres outils CI](https://docs.gitlab.com/ee/ci/migration/plan_a_migration.html) sont à votre disposition dans notre documentation.\n2. Gestion des tickets : importez les tickets du projet et testez les workflows.\n3. Revue de code : configurez le processus de merge request et testez les workflows de revue.\n#### Étape 4 : migrez progressivement\n\n1. Commencez par des projets de petite envergure ou non critiques pour vous habituer à travailler sur GitLab.com.\n2. Proposez une formation aux membres de votre équipe et laissez-leur le temps de s'adapter aux nouveaux workflows.\n3. Migrez les projets progressivement en vous assurant que les intégrations et les workflows fonctionnent correctement.\n\nPour plus d'informations, consultez la section [Automatisation des migrations de CodeCommit vers GitLab](https://gitlab.com/guided-explorations/aws/migrating-from-codecommit-to-gitlab/-/blob/main/migrating_codecommit_to_gitlab.md).\n\n#### Étape 5 : finalisez la migration\nUne fois que vous avez terminé tous les tests et validations et que votre équipe s'est habituée au nouvel environnement, planifiez une migration complète. Pour chaque projet :\n\n1. Fixez une date de migration et informez toutes les parties prenantes.\n2. Effectuez la synchronisation finale des données.\n3. Supprimez les paramètres de mise en miroir du projet GitLab.\n4. Passez les dépôts hébergés sur AWS en lecture seule et transférez tous les projets de développement vers GitLab.com.\n\n#### Étape 6 : évaluez l'adoption de nouvelles capacités\n\nAvec GitLab, la collaboration et l'automatisation des workflows offrent aux équipes de développement beaucoup plus d'opportunités qu’avec CodeCommit. Comme le processus de merge request est particulièrement sophistiqué par rapport à CodeCommit, cela peut prendre un peu de temps pour comprendre les capacités des fonctionnalités. \n\nUne fois que les dépôts sont stables sur GitLab, il est très facile d'expérimenter GitLab CI/CD en parallèle d'une solution existante. Les équipes peuvent prendre le temps de perfectionner leur automatisation GitLab CI/CD sans affecter les workflows de production.\n\nLa gestion des artefacts GitLab est également très performante, notamment la fonctionnalité Releases et les nombreux registres de paquet.\n\n### En résumé\nEn adoptant une approche de migration en parallèle vers GitLab, vous pouvez réaliser une transition en douceur tout en minimisant les risques. Ce processus permet aux équipes de s'adapter progressivement au nouvel environnement et de s'assurer que toutes les intégrations et automatisations fonctionnent correctement. \n\n## Section 2 : intégrez GitLab avec AWS CodeBuild\n\nSi vous souhaitez compiler et tester du code à partir de dépôts GitLab à l'aide d'AWS CodeBuild, notre guide complet vous aidera à mettre en place un pipeline CI efficace.\n\n### Prérequis\n\n- Compte GitLab.com\n- Compte AWS\n- AWS CLI (configurée)\n\n### Étape 1 : créez une connexion entre GitLab et AWS CodeStar Connections\n\n1. Connectez-vous à la console de gestion AWS et accédez au service AWS CodeBuild.\n2. Sélectionnez « Paramètres » > « Connexions » dans le panneau de navigation de gauche.\n3. Cliquez sur le bouton « Créer une connexion ».\n4. Choisissez « GitLab » comme fournisseur.\n5. Donnez un nom à la connexion et cliquez sur « Connecter à GitLab ».\n6. Vous serez redirigé vers la page d'authentification de GitLab.\n7. Approuvez les autorisations nécessaires.\n8. Une fois la connexion effectuée, son statut passera à « Disponible ».\n\n![Configuration de CodeStar Connect](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097822/Blog/Content%20Images/Blog/Content%20Images/codestar-connections-setup_aHR0cHM6_1750097822122.png)\n\n### Étape 2 : créez un projet AWS CodeBuild\n\n1. Cliquez sur « Créer un projet de construction » dans le tableau de bord d'AWS CodeBuild.\n2. Saisissez le nom du projet et une description.\n3. Pour les paramètres source, sélectionnez « GitLab » comme fournisseur.\n4. Choisissez la connexion que vous venez de créer, puis indiquez la branche et le dépôt GitLab.\n\n![Ajout d'un projet CodeBuild](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097822/Blog/Content%20Images/Blog/Content%20Images/codepipeline_step_3_add_codebuild_aHR0cHM6_1750097822123.png)\n\n**Remarque : à partir de l'étape 3, veuillez configurer les paramètres en fonction de votre environnement et de vos besoins spécifiques.**\n\n### En résumé\nCette section détaille comment intégrer les dépôts GitLab avec AWS CodeBuild. Cette configuration met en place un pipeline d'[intégration continue](https://about.gitlab.com/fr-fr/topics/ci-cd/benefits-continuous-integration/ \"Qu'est-ce que l'intégration continue (CI) ?\") où les modifications de code effectuées dans GitLab sont automatiquement compilées et testées à l'aide d'AWS CodeBuild.\n\n## Section 3 : intégrez GitLab avec AWS CodePipeline\n\nCe guide détaillé vous apportera les informations nécessaires si vous souhaitez mettre en œuvre la livraison continue à partir de dépôts GitLab à l'aide d'AWS CodePipeline. L'intégration est encore plus facile maintenant que GitLab est un fournisseur AWS CodeStar Connections.\n\n### Prérequis\n\n- Compte GitLab.com\n- Compte AWS\n- AWS CLI (configurée)\n\n### Étape 1 : créez une connexion entre GitLab et AWS CodeStar Connections\n\n1. Connectez-vous à la console de gestion AWS et accédez au service AWS CodePipeline.\n2. Sélectionnez « Paramètres » > « Connexions » dans le panneau de navigation de gauche.\n3. Cliquez sur le bouton « Créer une connexion ».\n4. Choisissez « GitLab » comme fournisseur.\n5. Donnez un nom à la connexion et cliquez sur « Connecter à GitLab ».\n6. Vous serez redirigé vers la page d'authentification de GitLab.\n7. Approuvez les autorisations nécessaires.\n8. Une fois la connexion effectuée, son statut passera à « Disponible ».\n\n![Configuration de CodeStar Connections](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097822/Blog/Content%20Images/Blog/Content%20Images/codestar-connections-setup_aHR0cHM6_1750097822122.png)\n\n### Étape 2 : créez un pipeline AWS CodePipeline\n\n1. Cliquez sur « Créer un pipeline » dans le tableau de bord d'AWS CodePipeline.\n2. Donnez un nom au pipeline et cliquez sur « Suivant ».\n3. Sélectionnez « GitLab » comme fournisseur source.\n4. Choisissez la connexion que vous venez de créer, puis indiquez la branche et le dépôt GitLab.\n5. Sélectionnez le type de déclencheur : vous pouvez déclencher l'exécution du pipeline AWS CodePipeline en fonction d'événements pull ou push pour des branches et des types de fichiers spécifiques au sein de votre dépôt.\n\n![Ajout du fournisseur source](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097822/Blog/Content%20Images/Blog/Content%20Images/codestar-connections-setup_aHR0cHM6_1750097822125.png)\n\n![Ajout d'une configuration source](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097822/Blog/Content%20Images/Blog/Content%20Images/codepipeline_step_2_source_provider_aHR0cHM6_1750097822127.png)\n\n**Remarque : à partir de l'étape 3, veuillez configurer les paramètres en fonction de votre environnement et de vos besoins spécifiques.**\n\n### En résumé \nCette section explique comment intégrer les dépôts GitLab avec AWS CodePipeline. Cette configuration crée un pipeline de livraison continue où les modifications de code effectuées dans GitLab sont automatiquement déployées dans votre environnement AWS.\n\n## Section 4 : migrez vers GitLab\n\nL'intégration de GitLab avec AWS vous donne accès à de puissantes fonctionnalités pour optimiser vos workflows de développement et de déploiement. Elle vous aide aussi à résoudre vos problèmes de gestion du code source. Cette intégration peut être réalisée de plusieurs manières, qui offrent chacune des avantages uniques :\n\n- L'utilisation d'AWS CodeStar Connections pour associer GitLab aux services AWS favorise la cohérence du workflow en permettant la connexion de dépôts Git externes, comme GitLab, à divers services AWS. Cette configuration prend en charge les compilations automatisées, les déploiements et d'autres actions essentielles directement à partir de votre dépôt GitLab, ce qui optimise l'intégration de votre processus de développement.\n\n- La connexion de GitLab avec AWS CodePipeline à l'aide de AWS CodeStar Connections fait passer l'automatisation au niveau supérieur en vous permettant de créer un pipeline CI/CD complet. Cette approche intègre GitLab avec AWS CodePipeline. Vous pouvez ainsi automatiser l'ensemble du processus (du contrôle des sources et des compilations, aux tests et déploiement) en utilisant des services AWS tels que AWS CodeBuild et AWS CodeDeploy. Vous bénéficiez ainsi d'un processus de livraison robuste, évolutif et efficace.\n\n![Tableau des nouvelles technologies et solutions pour associer GitLab et AWS](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097822/Blog/Content%20Images/Blog/Content%20Images/codepipeline_step_2_source_configured_aHR0cHM6_1750097822129.png)\n\n### 1. Connectez GitLab aux services AWS à l'aide d'AWS CodeStar Connections\n\nLe service AWS CodeStar Connections vous permet de connecter des dépôts Git externes (tels que GitHub ou Bitbucket) aux services AWS. Vous pouvez également utiliser CodeStar Connections pour connecter GitLab aux services AWS. Si vous utilisez GitLab, vous devrez peut-être configurer une connexion personnalisée en tant que serveur HTTP Git. \n\nCette méthode permet de connecter les services AWS suivants à GitLab :\n\n- **AWS Service Catalog**\n\nAWS Service Catalog aide les entreprises à standardiser et à gérer les ressources AWS. Son intégration à GitLab améliore la transparence de la gestion des ressources et simplifie le suivi des changements. Plus précisément, vous pouvez automatiser les mises à jour du catalogue en fonction des validations GitLab, ce qui améliore l'efficacité opérationnelle.\n\n- __AWS CodeBuild__\n\nAWS CodeBuild est un service qui compile votre code source, exécute des tests et produit des packages logiciels prêts à être déployés. L'intégration de GitLab avec AWS CodeBuild lance des processus de compilation automatisés à chaque fois qu'un push de modifications de code sur GitLab est effectué. La cohérence des compilations est ainsi garantie, tandis que la collaboration et le [contrôle des versions](https://about.gitlab.com/fr-fr/topics/version-control/ \"Qu'est-ce que le contrôle de version ?\") sont facilités.\n\n- __AWS Glue__\n\nLe service de blocs-notes intégrés à AWS Glue vous permet de développer et d'exécuter de manière interactive des tâches de préparation de données et ETL (processus d'extraction, de transformation et de chargement). L'intégration de GitLab avec les blocs-notes intégrés à AWS Glue vous permet de contrôler les versions des blocs-notes et des scripts ETL, de favoriser la collaboration entre les membres de l'équipe et d'améliorer la gestion de la qualité des pipelines de traitement des données.\n\n- __AWS Proton__\n\nAWS Proton automatise le développement et le déploiement de [microservices](https://about.gitlab.com/fr-fr/blog/what-are-the-benefits-of-a-microservices-architecture/ \"Architecture de microservices\") et d'applications [serverless](https://about.gitlab.com/fr-fr/topics/serverless/ \"Qu'est-ce que le serverless ?\"). En intégrant GitLab à AWS Proton, vous pouvez gérer l'[Infrastructure as Code](https://about.gitlab.com/fr-fr/topics/gitops/infrastructure-as-code/ \"Qu'est-ce que l'infrastructure en tant que code (IaC) ?\"), automatiser les déploiements et gérer l'environnement de façon cohérente. L'efficacité des processus de développement s'en trouve améliorée.\n\nAWS CodeStar Connections prend en charge davantage de services, ce qui facilite la connexion de GitLab avec d'autres services AWS. Nous vous conseillons de vérifier régulièrement si de nouveaux services prennent en charge CodeStar Connections.\n\n### 2. Connectez AWS CodePipeline à GitLab à l'aide AWS CodeStar Connections (y compris CodeDeploy)\n\nAWS CodePipeline est un service de livraison continue qui automatise le processus de livraison de logiciels. Pour connecter GitLab à AWS CodePipeline, vous devez utiliser AWS CodeStar Connections. Cette configuration vous permet de désigner un dépôt GitLab comme source et d'automatiser l'ensemble du pipeline CI/CD.\n\nAWS CodePipeline prend en charge les actions principales suivantes :\n- **Contrôle de version :** Amazon AWS CodeCommit, GitHub, Bitbucket, GitLab\n- **Compilations et tests :** AWS CodeBuild, Jenkins\n- **Déploiement :** AWS CodeDeploy, Elastic Beanstalk, ECS, S3\n- **Approbation :** approbation manuelle\n- **Gestion de l'infrastructure :** AWS CloudFormation\n- **Serverless :** AWS Lambda\n- **Tests :** AWS Device Farm\n- **Actions personnalisées :** AWS Step Functions\n\nEn intégrant GitLab avec AWS CodePipeline, vous pouvez automatiquement déclencher le pipeline chaque fois qu'un push de modifications de code sur GitLab est effectué, ce qui garantit la cohérence à chaque étape du processus, de la compilation au déploiement. De plus, avec les capacités de contrôle de version de GitLab, il est plus facile de suivre l'historique et les statuts de déploiement, ce qui permet une livraison de logiciels plus flexible et plus fiable.\n\n## Conclusion\n\nCe guide complet vous a expliqué comment effectuer la migration et l'intégration de GitLab avec AWS. La stratégie d'hébergement et d'intégration de code est propre à chaque entreprise. C’est pourquoi nous vous invitons à utiliser ce tutoriel comme point de départ pour établir votre propre stratégie d'intégration et de mise en œuvre de GitLab + AWS.\n\nPour consulter des informations plus détaillées et des configurations avancées, reportez-vous aux ressources suivantes :\n\n- [Documentation GitLab](https://docs.gitlab.com/)\n- [Guide de l'utilisateur AWS CodeBuild](https://docs.aws.amazon.com/codebuild/latest/userguide/welcome.html)\n- [Guide de l'utilisateur AWS CodePipeline](https://docs.aws.amazon.com/codepipeline/latest/userguide/welcome.html)\n- [Documentation GitLab CI/CD](https://docs.gitlab.com/ee/ci/)\n- [Intégration avec AWS](https://docs.gitlab.com/ee/solutions/cloud/aws/gitlab_aws_integration.html)\n\nSi vous avez des questions ou si vous avez besoin d'aide, contactez [l'assistance GitLab](https://about.gitlab.com/support/) ou l'assistance AWS. Nous espérons que ce guide complet vous aidera à progresser dans votre parcours d'intégration AWS-GitLab.",[108,732,685,683,780,733,9],"solutions architecture","2024-09-05",{"slug":783,"featured":90,"template":688},"ultimate-guide-to-migrating-from-aws-codecommit-to-gitlab","content:fr-fr:blog:ultimate-guide-to-migrating-from-aws-codecommit-to-gitlab.yml","Ultimate Guide To Migrating From Aws Codecommit To Gitlab","fr-fr/blog/ultimate-guide-to-migrating-from-aws-codecommit-to-gitlab.yml","fr-fr/blog/ultimate-guide-to-migrating-from-aws-codecommit-to-gitlab",{"_path":789,"_dir":245,"_draft":6,"_partial":6,"_locale":7,"seo":790,"content":796,"config":806,"_id":808,"_type":13,"title":809,"_source":15,"_file":810,"_stem":811,"_extension":18},"/fr-fr/blog/4-must-know-devops-principles",{"title":791,"description":792,"ogTitle":791,"ogDescription":792,"noIndex":6,"ogImage":793,"ogUrl":794,"ogSiteName":673,"ogType":674,"canonicalUrls":794,"schema":795},"Principes DevOps : les fondamentaux pour un développement réussi","Découvrez 4 principes DevOps clés pour développer des logiciels plus rapidement et de meilleure qualité.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749665982/Blog/Hero%20Images/jpvalery-9pLx0sLli4unsplash.jpg","https://about.gitlab.com/blog/4-must-know-devops-principles","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Principes DevOps : les fondamentaux pour un développement réussi\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"GitLab\"}],\n        \"datePublished\": \"2022-02-11\",\n      }",{"title":791,"description":792,"authors":797,"heroImage":793,"date":799,"body":800,"category":801,"tags":802,"updatedDate":805},[798],"GitLab","2022-02-11","La méthodologie de développement de logiciels [DevOps](https://about.gitlab.com/fr-fr/topics/devops/ \"DevOps\"), bien que populaire, peut paraître un peu déroutante pour les novices. D’autant plus lorsqu'elle englobe d'autres domaines tels que la sécurité (DevSecOps), les affaires (BizDevOps), ou d'autres spécificités.\n\nDans cet article, découvrez les quatre grands principes DevOps et pourquoi ils sont essentiels au bon développement et déploiement de vos logiciels.\n\n## Qu’est-ce que le DevOps ? \n\nLe DevOps réunit deux pratiques autrefois séparées : le développement de logiciels et les opérations IT. L'une de ses principales missions est d'accélérer le cycle de vie du développement logiciel en favorisant un environnement collaboratif entre ces différentes équipes.\n\nLes principes fondamentaux de l’approche DevOps comprennent une culture de la collaboration et de la communication, des tests automatisés, des releases et des déploiements, ainsi que des itérations fréquentes. Un autre terme couramment utilisé dans l'univers DevOps est le [DevSecOps](https://about.gitlab.com/fr-fr/topics/devsecops/ \"DevSecOps\"), qui fait référence à une pratique DevOps dans laquelle l’accent est mis sur la sécurité. \n\nL'essentiel de l’approche DevOps réside dans quatre grands principes clés qui vous aideront à améliorer les pratiques de développement de votre entreprise :\n\n- L’automatisation du cycle de vie du développement logiciel \n- La collaboration et la communication\n- L’amélioration continue et la réduction de la source de gaspillage\n- La concentration sur les besoins des utilisateurs avec des boucles de rétroaction courtes\n\n## Quels sont les principes DevOps ?\n\nIl y a environ quinze ans, une nouvelle idée émerge : réunir et faire collaborer de manière harmonieuse le développement et les opérations IT. Nous sommes alors en 2009 lorsque Patrick Debois, aujourd'hui considéré comme l'un des grands mentors de cette méthodologie, invente le terme « DevOps ». Le DevOps intègre de nombreux principes du [développement logiciel Agile](https://about.gitlab.com/fr-fr/topics/agile-delivery/ \"Développement logiciel Agile\") avec pour objectif de supprimer les silos entre les équipes de développement (Dev) et celles des opérations (Ops).\n\nDepuis lors, les pratiques DevOps n'ont cessé de gagner en popularité auprès des petites et grandes entreprises, dotées ou non de systèmes hérités. Si cette méthodologie a connu une adoption aussi rapide, c'est grâce à sa capacité à s'adapter aux besoins et à l'environnement unique de chaque entreprise, tout en répondant à ses différents objectifs commerciaux.\n\nS’il existe de nombreuses variantes à la méthodologie DevOps, quatre principes fondamentaux peuvent cependant être identifiés.\n\n### L’automatisation du cycle de vie du développement logiciel\n\nLe Graal, pour toute équipe DevOps, c'est l'automatisation. Avant l'apparition de l’approche DevOps, le développement de logiciels impliquait, à chaque étape du processus, un effort manuel important nécessitant une intervention humaine.\n\nAvec un tel besoin en ressources humaines, il n'était pas rare pour les entreprises de mettre à jour ou de publier un nouveau code seulement une fois par an, et cela pour les plus productives. En effet, la plupart suivait plutôt un rythme de publication de 18 ou 24 mois. De nos jours, en partie grâce à l'automatisation, les « [équipes DevOps](https://about.gitlab.com/blog/how-to-make-your-devops-team-elite-performers/ \"Equipes DevOps confirmées\") confirmées » arrivent à publier du code plusieurs fois par jour.\n\nPour comprendre la puissance et l'importance de l'automatisation en DevOps, prenons l'exemple des tests logiciels, étape souvent négligée et sous-estimée. Elle est d'ailleurs bien trop souvent mise en cause lors de retards de déploiement logiciel.\n\nEt pour cause : les tests logiciels sont probablement l'étape la plus chronophage de toute l’approche DevOps. En effet, cette dernière exige des équipes qu'elles préparent des scénarios auxquels elles feront passer une multitude de tests, pour ensuite analyser les résultats et appliquer des correctifs. La phase de tests est en réalité essentielle car sans elle, les entreprises risqueraient de publier un code erroné, voire un code non sécurisé.\n\nC’est là qu’entre en jeu l'automatisation avec l’idée que les [tests logiciels](https://about.gitlab.com/blog/want-faster-releases-your-answer-lies-in-automated-software-testing/ \"Tests logiciels\") les plus élémentaires peuvent se faire au fur et à mesure de l'écriture du code. L'automatisation des tests, dans ce nouveau paradigme, permet alors d'accélérer considérablement l'ensemble du processus de développement logiciel. En plus de booster la productivité des équipes et de réduire les erreurs humaines, ce principe DevOps permet également aux testeurs de logiciels de se concentrer sur des problèmes plus importants liés à la qualité du code. \n\nBien que l'automatisation des tests soit l'une des avancées majeures de l’approche DevOps, elle est loin d'être la seule. Nous retrouvons également l'[intégration continue](https://about.gitlab.com/fr-fr/topics/ci-cd/ \"Intégration continue\") qui automatise le processus de déplacement d'un nouveau code vers le code existant, tandis que le [déploiement continu](https://about.gitlab.com/fr-fr/blog/how-to-keep-up-with-ci-cd-best-practices/ \"Déploiement continu\") permet d'automatiser les releases. Sans oublier, l'[infrastructure en tant que code (IaC)](https://about.gitlab.com/fr-fr/topics/gitops/infrastructure-as-code/ \"Infrastructure en tant que code\") qui facilite quant à elle l'automatisation du processus de provisionnement des environnements de développement.\n\n### La collaboration et la communication\n\nUne bonne équipe DevOps dispose de l'automatisation, mais une équipe DevOps confirmée communique et collabore en permanence. Derrière l'idée de réunir les équipes Dev et Ops (ainsi que les équipes dédiées à la sécurité et aux tests, les parties prenantes, etc.), il s'agit surtout de les encourager à collaborer et à communiquer de manière harmonieuse. \n\nCe principe DevOps peut sembler évident, mais il est en réalité plus compliqué qu'il n'y paraît. En effet, il n'est pas rare pour les différentes équipes de reprendre leurs vieilles habitudes et de fonctionner avec une vision, voire même des outils, cloisonnés, comme en témoigne le scénario suivant : les équipes Dev veulent écrire du code et le publier ; les équipes Ops se concentrent sur les outils, la conformité et le cloud et les équipes Sec s’assurent que le code est sûr.\n\nDans ce scénario, les équipes Dev, Ops et Sec n'ont pas les mêmes priorités et ne parlent peut-être pas le même « langage », ce qui les empêche de travailler en harmonie. Elles sont alors susceptibles d'aborder la résolution de problèmes sous des angles très différents. \n\nDe plus, il arrive que [les équipes Dev et Sec ne s'entendent pas](https://about.gitlab.com/blog/developer-security-divide/), en partie parce que le fossé en matière de communication et de collaboration est important. Il y a donc un véritable enjeu à rassembler chaque équipe et surtout à les inciter à [penser et voir les choses différemment](https://about.gitlab.com/blog/want-secure-software-development-our-top-5-tips-to-bring-dev-and-sec-together/ \"5 conseils pour rapprocher les équipes Dev et Sec\").\n\n### L’amélioration continue et la réduction de la source de gaspillage\n\nS'appuyant fortement sur des méthodologies de développement logiciel déjà existantes, notamment les méthodes Agile et Lean, l’approche DevOps se concentre également sur la réduction de la source de gaspillage et l'amélioration continue. Qu'il s'agisse d'automatiser des tâches répétitives comme les tests (afin de gagner du temps) ou de réduire le nombre d'étapes nécessaires à la publication d'un nouveau code, les équipes DevOps performantes continuent de mesurer les indicateurs de performance afin de déterminer les domaines qui peuvent être améliorés. \n\nAinsi, ce principe DevOps encourage notamment les équipes à [améliorer continuellement leurs délais de publication](https://about.gitlab.com/blog/why-improving-continuously-speeds-up-delivery/ \"Amélioration du délai de publication\"), ou encore à réduire le [temps moyen de récupération](https://pipelinedriven.org/article/devops-metric-mean-time-to-recovery-mttr-definition-and-reasoning \"Temps moyen de récupération\") (MTTR - Mean Time to Recovery) et le nombre de bogues détectés.\n\n### La concentration sur les besoins des utilisateurs avec les boucles de rétroaction courtes\n\nLe dernier principe incontournable de l’approche DevOps est l'importance d'impliquer l'utilisateur à chaque étape du processus. Grâce aux principes DevOps précédemment cités, les équipes bénéficient normalement de plus de temps, qu'elles peuvent mettre à contribution pour se concentrer sur les besoins des utilisateurs et développer des fonctionnalités répondant à leurs attentes. \n\nIl est évidemment difficile de se mettre à la place des utilisateurs finaux, et il peut être encore [plus compliqué pour les équipes d'implémenter des processus œuvrant dans ce sens](https://about.gitlab.com/blog/journey-to-the-outer-loop/). Cependant, maintenant que vos équipes automatisent certaines tâches, communiquent plus efficacement entre elles et ont à cœur d'améliorer chaque étape du cycle du développement logiciel, elles pourront écouter et intégrer les retours des utilisateurs, plus facilement et plus rapidement. \n\n## Quels sont les défis liés à la mise en œuvre des principes DevOps ?\n\nLa mise en œuvre d’une approche DevOps peut s'avérer difficile, surtout si elle est mise en place pour première fois au sein d’une entreprise. \n\nVoici quelques-uns des principaux défis à connaître avant de se lancer : \n\n- __Briser les silos.__ Il peut être difficile de modifier la dynamique entre les équipes Dev et Ops auparavant distinctes. Prenez donc le temps de comprendre les rôles de chacun, leurs habitudes et leurs outils de travail.\n- __Comprendre le jargon.__ La méthodologie DevOps s'accompagne de beaucoup de jargon technique et de nombreux acronymes difficiles à comprendre pour les non initiés (comme le [CI/CD](https://about.gitlab.com/fr-fr/topics/ci-cd/ \"Qu'est-ce que le CI/CD ?\")). Prenez le temps d'étudier ces différents termes et rappelez-vous qu'apprendre en travaillant est parfaitement acceptable.\n- __Migrer à partir d'un logiciel hérité.__ Le concept DevOps peut être particulièrement délicat pour les équipes qui tentent de migrer des logiciels hérités. Par exemple, de nombreux outils conçus pour le DevOps ne fonctionnent pas avec les [mainframes](https://www.lemagit.fr/definition/Mainframe \"Mainframe\") (système informatique central de haute performance). Les intégrations peuvent être difficiles, même pour des professionnels DevOps expérimentés.\n- __Réduire le nombre d’outils.__ Les équipes passent tellement de temps à intégrer et à gérer la maintenance des outils que cela les empêche de développer, de publier et de surveiller leur code. C'est ce que l'on appelle communément la « taxe liée à la chaîne d'outils » (« toolchain tax »). \n- __Apprivoiser la frustration de la courbe d'apprentissage.__ L’approche DevOps est compliquée et comprendre son fonctionnement se fait progressivement. Faites preuve de patience et de compréhension avec vos équipes, et ce tout au long de la mise en œuvre de cette méthodologie. Aidez-vous de toutes les ressources disponibles, telles que la documentation technique et les services d'assistance de votre plateforme DevOps pour réussir votre apprentissage continu. \n\n## Comment intégrer l’approche DevOps dans votre organisation ?\n\nAvant de mettre en place une approche DevOps, nous vous conseillons de suivre les étapes suivantes : \n\n1. Définissez des objectifs, \n2. Clarifiez les rôles et responsabilités de chaque partie prenante impliquée,\n3. Commencez petit et, avec l'expérience, faites évoluer progressivement votre stratégie,\n4. Prévoyez d'automatiser autant que possible,\n5. Planifiez votre chaîne d'outils et n'oubliez pas qu’elle peut toujours être modifiée par la suite,\n6. Mettez en place des points de contrôle réguliers,\n7. Soyez prêt à itérer constamment (mais seulement après avoir attendu suffisamment longtemps pour prouver qu'une nouvelle itération est nécessaire), \n\n## Quel avenir pour le DevOps ?\n\nL'adoption de l’approche DevOps a connu une croissance importante lors de la pandémie de Covid-19. Dépassant les difficultés classiques liées à la gestion de projet et au travail collaboratif, en particulier à distance, les équipes de développement ont alors concentré leurs efforts sur l’adoption de nouvelles technologies, plus performantes.\n\nL'utilisation de technologies avancées, comme [Kubernetes](https://about.gitlab.com/fr-fr/blog/kubernetes-the-container-orchestration-solution/ \"Kubernetes\"), les [plateformes DevOps](https://about.gitlab.com/fr-fr/topics/devops-platform/ \"Plateforme DevOps\") et l’intelligence artificielle (IA) ou le machine learning (ML), nous donnent des indications sur ce à quoi pourrait ressembler l'avenir du DevOps.\n\nDans ce contexte, il paraît logique de s'attendre à ce que le futur du DevOps implique : \n\n- encore plus d'automatisation des processus,\n- une prise de décision plus intelligente alimentée par l’ IA et le ML (en commençant très certainement par la revue de code), \n- un choix d'outils plus réfléchi, comme l'adoption d’une plateforme DevOps pour rationaliser le processus de développement.\n","insights",[803,804,9],"DevOps","collaboration","2024-10-22",{"slug":807,"featured":6,"template":688},"4-must-know-devops-principles","content:fr-fr:blog:4-must-know-devops-principles.yml","4 Must Know Devops Principles","fr-fr/blog/4-must-know-devops-principles.yml","fr-fr/blog/4-must-know-devops-principles",1,[666,693,716,741,763],1758326309915]