[{"data":1,"prerenderedAt":966},["ShallowReactive",2],{"/en-us/blog/tags/devops/":3,"navigation-fr-fr":20,"banner-fr-fr":441,"footer-fr-fr":454,"DevOps-tag-page-fr-fr":666},{"_path":4,"_dir":5,"_draft":6,"_partial":6,"_locale":7,"content":8,"config":11,"_id":13,"_type":14,"title":15,"_source":16,"_file":17,"_stem":18,"_extension":19},"/en-us/blog/tags/devops","tags",false,"",{"tag":9,"tagSlug":10},"DevOps","devops",{"template":12},"BlogTag","content:en-us:blog:tags:devops.yml","yaml","Devops","content","en-us/blog/tags/devops.yml","en-us/blog/tags/devops","yml",{"_path":21,"_dir":22,"_draft":6,"_partial":6,"_locale":7,"data":23,"_id":437,"_type":14,"title":438,"_source":16,"_file":439,"_stem":440,"_extension":19},"/shared/fr-fr/main-navigation","fr-fr",{"logo":24,"freeTrial":29,"sales":34,"login":39,"items":44,"search":378,"minimal":414,"duo":428},{"config":25},{"href":26,"dataGaName":27,"dataGaLocation":28},"/fr-fr/","gitlab logo","header",{"text":30,"config":31},"Commencer un essai gratuit",{"href":32,"dataGaName":33,"dataGaLocation":28},"https://gitlab.com/-/trial_registrations/new?glm_source=about.gitlab.com&glm_content=default-saas-trial/","free trial",{"text":35,"config":36},"Contacter l'équipe commerciale",{"href":37,"dataGaName":38,"dataGaLocation":28},"/fr-fr/sales/","sales",{"text":40,"config":41},"Connexion",{"href":42,"dataGaName":43,"dataGaLocation":28},"https://gitlab.com/users/sign_in/","sign in",[45,89,188,193,299,359],{"text":46,"config":47,"cards":49,"footer":72},"Plateforme",{"dataNavLevelOne":48},"platform",[50,56,64],{"title":46,"description":51,"link":52},"La plateforme DevSecOps alimentée par l'IA la plus complète",{"text":53,"config":54},"Découvrir notre plateforme",{"href":55,"dataGaName":48,"dataGaLocation":28},"/fr-fr/platform/",{"title":57,"description":58,"link":59},"GitLab Duo (IA)","Créez des logiciels plus rapidement en tirant parti de l'IA à chaque étape du développement",{"text":60,"config":61},"Découvrez GitLab Duo",{"href":62,"dataGaName":63,"dataGaLocation":28},"/fr-fr/gitlab-duo/","gitlab duo ai",{"title":65,"description":66,"link":67},"Choisir GitLab","10 raisons pour lesquelles les entreprises choisissent GitLab",{"text":68,"config":69},"En savoir plus",{"href":70,"dataGaName":71,"dataGaLocation":28},"/fr-fr/why-gitlab/","why gitlab",{"title":73,"items":74},"Démarrer avec",[75,80,85],{"text":76,"config":77},"Ingénierie de plateforme",{"href":78,"dataGaName":79,"dataGaLocation":28},"/fr-fr/solutions/platform-engineering/","platform engineering",{"text":81,"config":82},"Expérience développeur",{"href":83,"dataGaName":84,"dataGaLocation":28},"/fr-fr/developer-experience/","Developer experience",{"text":86,"config":87},"MLOps",{"href":88,"dataGaName":86,"dataGaLocation":28},"/fr-fr/topics/devops/the-role-of-ai-in-devops/",{"text":90,"left":91,"config":92,"link":94,"lists":98,"footer":170},"Produit",true,{"dataNavLevelOne":93},"solutions",{"text":95,"config":96},"Voir toutes les solutions",{"href":97,"dataGaName":93,"dataGaLocation":28},"/fr-fr/solutions/",[99,125,148],{"title":100,"description":101,"link":102,"items":107},"Automatisation","CI/CD et automatisation pour accélérer le déploiement",{"config":103},{"icon":104,"href":105,"dataGaName":106,"dataGaLocation":28},"AutomatedCodeAlt","/fr-fr/solutions/delivery-automation/","automated software delivery",[108,112,116,121],{"text":109,"config":110},"CI/CD",{"href":111,"dataGaLocation":28,"dataGaName":109},"/fr-fr/solutions/continuous-integration/",{"text":113,"config":114},"Développement assisté par l'IA",{"href":62,"dataGaLocation":28,"dataGaName":115},"AI assisted development",{"text":117,"config":118},"Gestion du code source",{"href":119,"dataGaLocation":28,"dataGaName":120},"/fr-fr/solutions/source-code-management/","Source Code Management",{"text":122,"config":123},"Livraison de logiciels automatisée",{"href":105,"dataGaLocation":28,"dataGaName":124},"Automated software delivery",{"title":126,"description":127,"link":128,"items":133},"Securité","Livrez du code plus rapidement sans compromettre la sécurité",{"config":129},{"href":130,"dataGaName":131,"dataGaLocation":28,"icon":132},"/fr-fr/solutions/security-compliance/","security and compliance","ShieldCheckLight",[134,139,144],{"text":135,"config":136},"Application Security Testing",{"href":137,"dataGaName":138,"dataGaLocation":28},"/solutions/application-security-testing/","Application security testing",{"text":140,"config":141},"Sécurité de la chaîne d'approvisionnement logicielle",{"href":142,"dataGaLocation":28,"dataGaName":143},"/fr-fr/solutions/supply-chain/","Software supply chain security",{"text":145,"config":146},"Software Compliance",{"href":147,"dataGaName":145,"dataGaLocation":28},"/solutions/software-compliance/",{"title":149,"link":150,"items":155},"Mesures",{"config":151},{"icon":152,"href":153,"dataGaName":154,"dataGaLocation":28},"DigitalTransformation","/fr-fr/solutions/visibility-measurement/","visibility and measurement",[156,160,165],{"text":157,"config":158},"Visibilité et mesures",{"href":153,"dataGaLocation":28,"dataGaName":159},"Visibility and Measurement",{"text":161,"config":162},"Gestion de la chaîne de valeur",{"href":163,"dataGaLocation":28,"dataGaName":164},"/fr-fr/solutions/value-stream-management/","Value Stream Management",{"text":166,"config":167},"Données d'analyse et informations clés",{"href":168,"dataGaLocation":28,"dataGaName":169},"/fr-fr/solutions/analytics-and-insights/","Analytics and insights",{"title":171,"items":172},"GitLab pour",[173,178,183],{"text":174,"config":175},"Entreprises",{"href":176,"dataGaLocation":28,"dataGaName":177},"/fr-fr/enterprise/","enterprise",{"text":179,"config":180},"PME",{"href":181,"dataGaLocation":28,"dataGaName":182},"/fr-fr/small-business/","small business",{"text":184,"config":185},"Secteur public",{"href":186,"dataGaLocation":28,"dataGaName":187},"/fr-fr/solutions/public-sector/","public sector",{"text":189,"config":190},"Tarifs",{"href":191,"dataGaName":192,"dataGaLocation":28,"dataNavLevelOne":192},"/fr-fr/pricing/","pricing",{"text":194,"config":195,"link":197,"lists":201,"feature":286},"Ressources",{"dataNavLevelOne":196},"resources",{"text":198,"config":199},"Afficher toutes les ressources",{"href":200,"dataGaName":196,"dataGaLocation":28},"/fr-fr/resources/",[202,235,258],{"title":203,"items":204},"Premiers pas",[205,210,215,220,225,230],{"text":206,"config":207},"Installation",{"href":208,"dataGaName":209,"dataGaLocation":28},"/fr-fr/install/","install",{"text":211,"config":212},"Guides de démarrage rapide",{"href":213,"dataGaName":214,"dataGaLocation":28},"/fr-fr/get-started/","quick setup checklists",{"text":216,"config":217},"Apprentissage",{"href":218,"dataGaLocation":28,"dataGaName":219},"https://university.gitlab.com/","learn",{"text":221,"config":222},"Documentation sur le produit",{"href":223,"dataGaName":224,"dataGaLocation":28},"https://docs.gitlab.com/","product documentation",{"text":226,"config":227},"Vidéos sur les bonnes pratiques",{"href":228,"dataGaName":229,"dataGaLocation":28},"/fr-fr/getting-started-videos/","best practice videos",{"text":231,"config":232},"Intégrations",{"href":233,"dataGaName":234,"dataGaLocation":28},"/fr-fr/integrations/","integrations",{"title":236,"items":237},"Découvrir",[238,243,248,253],{"text":239,"config":240},"Histoires de succès client",{"href":241,"dataGaName":242,"dataGaLocation":28},"/fr-fr/customers/","customer success stories",{"text":244,"config":245},"Blog",{"href":246,"dataGaName":247,"dataGaLocation":28},"/fr-fr/blog/","blog",{"text":249,"config":250},"Travail à distance",{"href":251,"dataGaName":252,"dataGaLocation":28},"https://handbook.gitlab.com/handbook/company/culture/all-remote/","remote",{"text":254,"config":255},"TeamOps",{"href":256,"dataGaName":257,"dataGaLocation":28},"/fr-fr/teamops/","teamops",{"title":259,"items":260},"Connecter",[261,266,271,276,281],{"text":262,"config":263},"Services GitLab",{"href":264,"dataGaName":265,"dataGaLocation":28},"/fr-fr/services/","services",{"text":267,"config":268},"Communauté",{"href":269,"dataGaName":270,"dataGaLocation":28},"/community/","community",{"text":272,"config":273},"Forum",{"href":274,"dataGaName":275,"dataGaLocation":28},"https://forum.gitlab.com/","forum",{"text":277,"config":278},"Événements",{"href":279,"dataGaName":280,"dataGaLocation":28},"/events/","events",{"text":282,"config":283},"Partenaires",{"href":284,"dataGaName":285,"dataGaLocation":28},"/fr-fr/partners/","partners",{"backgroundColor":287,"textColor":288,"text":289,"image":290,"link":294},"#2f2a6b","#fff","L'avenir du développement logiciel. Tendances et perspectives.",{"altText":291,"config":292},"carte promo The Source",{"src":293},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1758208064/dzl0dbift9xdizyelkk4.svg",{"text":295,"config":296},"Lire les articles les plus récents",{"href":297,"dataGaName":298,"dataGaLocation":28},"/fr-fr/the-source/","the source",{"text":300,"config":301,"lists":303},"Société",{"dataNavLevelOne":302},"company",[304],{"items":305},[306,311,317,319,324,329,334,339,344,349,354],{"text":307,"config":308},"À propos",{"href":309,"dataGaName":310,"dataGaLocation":28},"/fr-fr/company/","about",{"text":312,"config":313,"footerGa":316},"Emplois",{"href":314,"dataGaName":315,"dataGaLocation":28},"/jobs/","jobs",{"dataGaName":315},{"text":277,"config":318},{"href":279,"dataGaName":280,"dataGaLocation":28},{"text":320,"config":321},"Leadership",{"href":322,"dataGaName":323,"dataGaLocation":28},"/company/team/e-group/","leadership",{"text":325,"config":326},"Équipe",{"href":327,"dataGaName":328,"dataGaLocation":28},"/company/team/","team",{"text":330,"config":331},"Manuel",{"href":332,"dataGaName":333,"dataGaLocation":28},"https://handbook.gitlab.com/","handbook",{"text":335,"config":336},"Relations avec les investisseurs",{"href":337,"dataGaName":338,"dataGaLocation":28},"https://ir.gitlab.com/","investor relations",{"text":340,"config":341},"Centre de confiance",{"href":342,"dataGaName":343,"dataGaLocation":28},"/fr-fr/security/","trust center",{"text":345,"config":346},"Centre pour la transparence de l'IA",{"href":347,"dataGaName":348,"dataGaLocation":28},"/fr-fr/ai-transparency-center/","ai transparency center",{"text":350,"config":351},"Newsletter",{"href":352,"dataGaName":353,"dataGaLocation":28},"/company/contact/","newsletter",{"text":355,"config":356},"Presse",{"href":357,"dataGaName":358,"dataGaLocation":28},"/press/","press",{"text":360,"config":361,"lists":362},"Nous contacter",{"dataNavLevelOne":302},[363],{"items":364},[365,368,373],{"text":35,"config":366},{"href":37,"dataGaName":367,"dataGaLocation":28},"talk to sales",{"text":369,"config":370},"Aide",{"href":371,"dataGaName":372,"dataGaLocation":28},"/support/","get help",{"text":374,"config":375},"Portail clients GitLab",{"href":376,"dataGaName":377,"dataGaLocation":28},"https://customers.gitlab.com/customers/sign_in/","customer portal",{"close":379,"login":380,"suggestions":387},"Fermer",{"text":381,"link":382},"Pour rechercher des dépôts et des projets, connectez-vous à",{"text":383,"config":384},"gitlab.com",{"href":42,"dataGaName":385,"dataGaLocation":386},"search login","search",{"text":388,"default":389},"Suggestions",[390,393,398,400,405,410],{"text":57,"config":391},{"href":62,"dataGaName":392,"dataGaLocation":386},"GitLab Duo (AI)",{"text":394,"config":395},"Suggestions de code (IA)",{"href":396,"dataGaName":397,"dataGaLocation":386},"/fr-fr/solutions/code-suggestions/","Code Suggestions (AI)",{"text":109,"config":399},{"href":111,"dataGaName":109,"dataGaLocation":386},{"text":401,"config":402},"GitLab sur AWS",{"href":403,"dataGaName":404,"dataGaLocation":386},"/fr-fr/partners/technology-partners/aws/","GitLab on AWS",{"text":406,"config":407},"GitLab sur Google Cloud ",{"href":408,"dataGaName":409,"dataGaLocation":386},"/fr-fr/partners/technology-partners/google-cloud-platform/","GitLab on Google Cloud",{"text":411,"config":412},"Pourquoi utiliser GitLab ?",{"href":70,"dataGaName":413,"dataGaLocation":386},"Why GitLab?",{"freeTrial":415,"mobileIcon":420,"desktopIcon":425},{"text":416,"config":417},"Commencer votre essai gratuit",{"href":418,"dataGaName":33,"dataGaLocation":419},"https://gitlab.com/-/trials/new/","nav",{"altText":421,"config":422},"Icône GitLab",{"src":423,"dataGaName":424,"dataGaLocation":419},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1758203874/jypbw1jx72aexsoohd7x.svg","gitlab icon",{"altText":421,"config":426},{"src":427,"dataGaName":424,"dataGaLocation":419},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1758203875/gs4c8p8opsgvflgkswz9.svg",{"freeTrial":429,"mobileIcon":433,"desktopIcon":435},{"text":430,"config":431},"En savoir plus sur GitLab Duo",{"href":62,"dataGaName":432,"dataGaLocation":419},"gitlab duo",{"altText":421,"config":434},{"src":423,"dataGaName":424,"dataGaLocation":419},{"altText":421,"config":436},{"src":427,"dataGaName":424,"dataGaLocation":419},"content:shared:fr-fr:main-navigation.yml","Main Navigation","shared/fr-fr/main-navigation.yml","shared/fr-fr/main-navigation",{"_path":442,"_dir":22,"_draft":6,"_partial":6,"_locale":7,"title":443,"titleMobile":443,"button":444,"config":449,"_id":451,"_type":14,"_source":16,"_file":452,"_stem":453,"_extension":19},"/shared/fr-fr/banner","La plateforme GitLab Duo Agent est maintenant disponible en version bêta publique !",{"text":445,"config":446},"Essayer la version bêta",{"href":447,"dataGaName":448,"dataGaLocation":28},"/fr-fr/gitlab-duo/agent-platform/","duo banner",{"layout":450},"release","content:shared:fr-fr:banner.yml","shared/fr-fr/banner.yml","shared/fr-fr/banner",{"_path":455,"_dir":22,"_draft":6,"_partial":6,"_locale":7,"data":456,"_id":662,"_type":14,"title":663,"_source":16,"_file":664,"_stem":665,"_extension":19},"/shared/fr-fr/main-footer",{"text":457,"source":458,"edit":464,"contribute":469,"config":474,"items":479,"minimal":653},"Git est une marque déposée de Software Freedom Conservancy et notre utilisation de « GitLab » est sous licence",{"text":459,"config":460},"Afficher le code source de la page",{"href":461,"dataGaName":462,"dataGaLocation":463},"https://gitlab.com/gitlab-com/marketing/digital-experience/about-gitlab-com/","page source","footer",{"text":465,"config":466},"Modifier cette page",{"href":467,"dataGaName":468,"dataGaLocation":463},"https://gitlab.com/gitlab-com/marketing/digital-experience/about-gitlab-com/-/blob/main/content/","web ide",{"text":470,"config":471},"Veuillez contribuer",{"href":472,"dataGaName":473,"dataGaLocation":463},"https://gitlab.com/gitlab-com/marketing/digital-experience/about-gitlab-com/-/blob/main/CONTRIBUTING.md/","please contribute",{"twitter":475,"facebook":476,"youtube":477,"linkedin":478},"https://twitter.com/gitlab","https://www.facebook.com/gitlab","https://www.youtube.com/channel/UCnMGQ8QHMAnVIsI3xJrihhg","https://www.linkedin.com/company/gitlab-com",[480,503,557,590,624],{"title":46,"links":481,"subMenu":486},[482],{"text":483,"config":484},"Plateforme DevSecOps",{"href":55,"dataGaName":485,"dataGaLocation":463},"devsecops platform",[487],{"title":189,"links":488},[489,493,498],{"text":490,"config":491},"Voir les forfaits",{"href":191,"dataGaName":492,"dataGaLocation":463},"view plans",{"text":494,"config":495},"Pourquoi choisir GitLab Premium ?",{"href":496,"dataGaName":497,"dataGaLocation":463},"/fr-fr/pricing/premium/","why premium",{"text":499,"config":500},"Pourquoi choisir GitLab Ultimate ?",{"href":501,"dataGaName":502,"dataGaLocation":463},"/fr-fr/pricing/ultimate/","why ultimate",{"title":504,"links":505},"Solutions",[506,511,514,516,521,526,530,533,536,541,543,545,547,552],{"text":507,"config":508},"Transformation digitale",{"href":509,"dataGaName":510,"dataGaLocation":463},"/fr-fr/topics/digital-transformation/","digital transformation",{"text":512,"config":513},"Sécurité et conformité",{"href":137,"dataGaName":138,"dataGaLocation":463},{"text":122,"config":515},{"href":105,"dataGaName":106,"dataGaLocation":463},{"text":517,"config":518},"Développement agile",{"href":519,"dataGaName":520,"dataGaLocation":463},"/fr-fr/solutions/agile-delivery/","agile delivery",{"text":522,"config":523},"Transformation cloud",{"href":524,"dataGaName":525,"dataGaLocation":463},"/fr-fr/topics/cloud-native/","cloud transformation",{"text":527,"config":528},"SCM",{"href":119,"dataGaName":529,"dataGaLocation":463},"source code management",{"text":109,"config":531},{"href":111,"dataGaName":532,"dataGaLocation":463},"continuous integration & delivery",{"text":161,"config":534},{"href":163,"dataGaName":535,"dataGaLocation":463},"value stream management",{"text":537,"config":538},"GitOps",{"href":539,"dataGaName":540,"dataGaLocation":463},"/fr-fr/solutions/gitops/","gitops",{"text":174,"config":542},{"href":176,"dataGaName":177,"dataGaLocation":463},{"text":179,"config":544},{"href":181,"dataGaName":182,"dataGaLocation":463},{"text":184,"config":546},{"href":186,"dataGaName":187,"dataGaLocation":463},{"text":548,"config":549},"Formation",{"href":550,"dataGaName":551,"dataGaLocation":463},"/fr-fr/solutions/education/","education",{"text":553,"config":554},"Services financiers",{"href":555,"dataGaName":556,"dataGaLocation":463},"/fr-fr/solutions/finance/","financial services",{"title":194,"links":558},[559,561,563,565,568,570,574,576,578,580,582,584,586,588],{"text":206,"config":560},{"href":208,"dataGaName":209,"dataGaLocation":463},{"text":211,"config":562},{"href":213,"dataGaName":214,"dataGaLocation":463},{"text":216,"config":564},{"href":218,"dataGaName":219,"dataGaLocation":463},{"text":221,"config":566},{"href":223,"dataGaName":567,"dataGaLocation":463},"docs",{"text":244,"config":569},{"href":246,"dataGaName":247},{"text":571,"config":572},"Histoires de réussite client",{"href":573,"dataGaLocation":463},"/customers/",{"text":239,"config":575},{"href":241,"dataGaName":242,"dataGaLocation":463},{"text":249,"config":577},{"href":251,"dataGaName":252,"dataGaLocation":463},{"text":262,"config":579},{"href":264,"dataGaName":265,"dataGaLocation":463},{"text":254,"config":581},{"href":256,"dataGaName":257,"dataGaLocation":463},{"text":267,"config":583},{"href":269,"dataGaName":270,"dataGaLocation":463},{"text":272,"config":585},{"href":274,"dataGaName":275,"dataGaLocation":463},{"text":277,"config":587},{"href":279,"dataGaName":280,"dataGaLocation":463},{"text":282,"config":589},{"href":284,"dataGaName":285,"dataGaLocation":463},{"title":300,"links":591},[592,594,596,598,600,602,604,608,613,615,617,619],{"text":307,"config":593},{"href":309,"dataGaName":302,"dataGaLocation":463},{"text":312,"config":595},{"href":314,"dataGaName":315,"dataGaLocation":463},{"text":320,"config":597},{"href":322,"dataGaName":323,"dataGaLocation":463},{"text":325,"config":599},{"href":327,"dataGaName":328,"dataGaLocation":463},{"text":330,"config":601},{"href":332,"dataGaName":333,"dataGaLocation":463},{"text":335,"config":603},{"href":337,"dataGaName":338,"dataGaLocation":463},{"text":605,"config":606},"Sustainability",{"href":607,"dataGaName":605,"dataGaLocation":463},"/sustainability/",{"text":609,"config":610},"Diversité, inclusion et appartenance (DIB)",{"href":611,"dataGaName":612,"dataGaLocation":463},"/fr-fr/diversity-inclusion-belonging/","Diversity, inclusion and belonging",{"text":340,"config":614},{"href":342,"dataGaName":343,"dataGaLocation":463},{"text":350,"config":616},{"href":352,"dataGaName":353,"dataGaLocation":463},{"text":355,"config":618},{"href":357,"dataGaName":358,"dataGaLocation":463},{"text":620,"config":621},"Déclaration de transparence sur l'esclavage moderne",{"href":622,"dataGaName":623,"dataGaLocation":463},"https://handbook.gitlab.com/handbook/legal/modern-slavery-act-transparency-statement/","modern slavery transparency statement",{"title":360,"links":625},[626,629,631,633,638,643,648],{"text":627,"config":628},"Échanger avec un expert",{"href":37,"dataGaName":38,"dataGaLocation":463},{"text":369,"config":630},{"href":371,"dataGaName":372,"dataGaLocation":463},{"text":374,"config":632},{"href":376,"dataGaName":377,"dataGaLocation":463},{"text":634,"config":635},"Statut",{"href":636,"dataGaName":637,"dataGaLocation":463},"https://status.gitlab.com/","status",{"text":639,"config":640},"Conditions d'utilisation",{"href":641,"dataGaName":642},"/terms/","terms of use",{"text":644,"config":645},"Déclaration de confidentialité",{"href":646,"dataGaName":647,"dataGaLocation":463},"/fr-fr/privacy/","privacy statement",{"text":649,"config":650},"Préférences en matière de cookies",{"dataGaName":651,"dataGaLocation":463,"id":652,"isOneTrustButton":91},"cookie preferences","ot-sdk-btn",{"items":654},[655,657,660],{"text":639,"config":656},{"href":641,"dataGaName":642,"dataGaLocation":463},{"text":658,"config":659},"Politique de confidentialité",{"href":646,"dataGaName":647,"dataGaLocation":463},{"text":649,"config":661},{"dataGaName":651,"dataGaLocation":463,"id":652,"isOneTrustButton":91},"content:shared:fr-fr:main-footer.yml","Main Footer","shared/fr-fr/main-footer.yml","shared/fr-fr/main-footer",{"allPosts":667,"featuredPost":944,"totalPagesCount":964,"initialPosts":965},[668,697,720,747,769,792,814,837,861,884,905,925],{"_path":669,"_dir":247,"_draft":6,"_partial":6,"_locale":7,"seo":670,"content":678,"config":690,"_id":693,"_type":14,"title":694,"_source":16,"_file":695,"_stem":696,"_extension":19},"/fr-fr/blog/agile-pairing-sessions",{"ogTitle":671,"schema":672,"ogImage":673,"ogDescription":674,"ogSiteName":675,"noIndex":6,"ogType":676,"ogUrl":677,"title":671,"canonicalUrls":677,"description":674},"Pair programming : apprenez à coder en binôme","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Pair programming : coder en binôme pour progresser et améliorer sa productivité\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Suri Patel\"}],\n        \"datePublished\": \"2019-08-20\",\n      }","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749665897/Blog/Hero%20Images/incrementalcodedevelopment.jpg","Dans cet article, découvrez le pair programming, pourquoi vous devez coder en binôme et comment éviter les erreurs principales lorsqu'on se lance.","https://about.gitlab.com","article","https://about.gitlab.com/blog/agile-pairing-sessions",{"heroImage":673,"body":679,"authors":680,"updatedDate":682,"date":683,"title":684,"tags":685,"description":674,"category":689},"Coder en binôme aide les équipes de développement à progresser plus rapidement et à améliorer la livraison des projets. Découvrez dans cet article le fonctionnement du pair programming, comment coder en binôme et les meilleures astuces pour tirer parti de cette méthode Agile. \n\n## Qu’est-ce que le pair programming ? \n\nLe pair programming (ou programmation en binôme) est une approche Agile du développement logiciel qui implique deux développeurs et/ou développeuses travaillant sur le même poste de travail. L'un, appelé le conducteur (driver), rédige le code pendant que l'autre, appelé le navigateur (navigator) le commente et le révise en temps réel. Les sessions de pair programming peuvent accélérer les projets agiles, car les binômes travaillent ensemble pour trouver les meilleures solutions aux différentes problématiques rencontrées. Plutôt que de travailler en silos, les membres de l'équipe s'associent pour partager leurs connaissances et avancer plus rapidement. \n\n> [Essayez GitLab Ultimate gratuitement.](https://gitlab.com/-/trial_registrations/new?glm_source=about.gitlab.com/blog&glm_content=default-saas-trial \"Essai gratuit de GitLab.\") \n\n## Comment débuter une session de pair programming ?\n\nLa clé d'une session de pair programming réussie repose sur une communication fluide et la création d'un planning afin d'éviter de rencontrer des problèmes lors de la réalisation du projet. \n\nVoici quatre éléments à considérer avant de vous lancer dans une session de programmation en binôme : \n\n- Ayez une compréhension commune sur la notion du « prêt à être lancé » pour le projet en question. Concertez-vous ainsi que toute partie prenante impliquée, comme le Product Owner, afin de déterminer clairement à quel moment donner le feu vert au projet.\n- Planifiez le projet étape par étape. Définissez comment vous allez coder, effectuer la revue de code et tester le projet. Pensez aussi aux potentielles aides extérieures dont vous pourriez avoir besoin pour mener le projet à bien.\n- Faites une liste de tous les obstacles potentiels que vous pourriez rencontrer lors de l'accomplissement du projet et essayez de trouver des solutions potentielles. Vous pouvez le faire ensemble, à l’écrit ou oralement, ou séparément avant de partager vos idées. Quelle que soit la manière, cette étape est importante.\n- Trouvez un accord sur la technologie à utiliser pour le projet. De l’ordinateur idéal en passant par une connexion Wi-Fi fiable, il faut vous doter de tous les outils nécessaires à la réussite du projet.\n\n## 5 astuces pour réussir sa session de pair programming\n\nPour tirer pleinement parti de vos sessions de programmation en binôme, voici cinq bonnes pratiques à suivre : \n\n- __Communiquer sans interruption.__ Dans une session de pair programming, la communication est primordiale, que vous ayez déjà collaboré ou non avec votre binôme. Il est normal que deux personnes aient des idées et des opinions différentes lors d’un projet. Pour éviter que le projet et le binôme n'en pâtissent, gardez une communication ouverte et fréquente. \n- __Alterner les rôles.__ Aucun des deux ne doit être le seul conducteur ou navigateur. Pensez à échanger les rôles régulièrement afin de garder un œil frais et de continuer à produire un travail de qualité.\n- __Prendre des pauses.__ Rome ne s'est pas construite en un jour, le codage non plus. Veillez donc à faire des pauses régulières pour ne pas vous épuiser.\n- __Utiliser les bons outils.__ Souvent, le pair programming se fait à distance. Même si le dialogue reste virtuel, pensez à échanger par visioconférence pour mieux collaborer tout au long du projet. \n- __Demander de l'aide.__ Vous ne comprenez pas une partie du projet ? N'hésitez pas à demander de l'aide. Il vaut mieux en demander au cours de la session de programmation qu'au moment de la validation finale.\n\n## Quels sont les avantages du pair programming ?\n\nCollaborer directement avec un développeur ou une développeuse booste le moral et diversifie la journée de travail de chacun. En travaillant en binôme, il est possible d’apprendre de nouvelles pratiques de codage, de nouveaux workflows ou encore de nouvelles façons d'aborder un problème pour favoriser l’innovation, améliorer l’efficacité et réduire la rétention d'information.\n\nLes développeurs juniors profitent de l’expérience de leurs collègues seniors pour acquérir de solides connaissances. De leur côté, les développeurs expérimentés apprennent à enseigner leurs méthodes et à utiliser leur pensée critique pour trouver des solutions. \n\nQuel que soit le niveau d'expérience, tout le monde peut bénéficier des sessions de pair programming, puisqu'il n'existe pas de bonne ou de mauvaise façon de programmer. Le développement de logiciels est un effort à multiples facettes dans lequel l'imagination et la créativité jouent un rôle fondamental. Les connaissances, l'expérience et les styles d'apprentissage de chacun déterminent la manière d'appréhender les liens entre des éléments de code et un système en place. En binôme, il est possible de discuter de ces perspectives et de déterminer la meilleure approche.\n\n## Quels sont les inconvénients du pair programming ?\n\nCoder en binôme peut sembler être la solution à tous les problèmes, mais ce n’est pas toujours le cas. \n\nLorsqu’il comprend à quel point le pair programming peut les aider, un binôme peut être tenté d’unir ses forces un peu trop souvent. Pour des tâches simples, des changements mineurs et précis, coder en binôme s'avère inutile.\n\nDe plus, si deux développeurs ou développeuses commencent tout juste à coder ensemble, ils doivent faire preuve de patience et persévérer pour former un excellent binôme. Ce qui n'est pas toujours facile, même pour les développeurs expérimentés. Pensez à débriefer après vos sessions de pair programming afin de comprendre ce qui a bien ou moins bien fonctionné et comment vous pouvez vous améliorer lors des prochaines sessions. \n\n## Le pair programming chez GitLab\n\nChez [GitLab](https://about.gitlab.com/fr-fr/ \"Site Web de GitLab\"), nous aimons coder en binôme. La plupart du temps, les sessions de pair programming s'effectuent sur le même poste de travail, mais en tant qu'[entreprise en 100 % télétravail](https://about.gitlab.com/fr-fr/company/all-remote/ \"GitLab est une entreprise en 100% télétravail \"), nous avons trouvé des moyens pour faire en sorte que cela fonctionne.  \n\nAu sein de l'équipe d'ingénierie, [l'équipe Frontend, a par exemple expérimenté la programmation en binôme](https://gitlab.com/gitlab-org/frontend/general/-/issues/12 \"Exemple de pair programming chez GitLab\"). L'équipe a utilisé VSCode Live Share à plusieurs reprises, mais privilégie l'envoi de correctifs et les conversations en groupe.\n\n*« Le meilleur format jusqu'à présent reste le suivant : quelqu'un envoie une demande de binôme dans le canal Slack #frontend_pairs, des personnes manifestent leur intérêt, nous bloquons une plage horaire dans le calendrier, puis nous organisons une session pour programmer en groupe. »* Paul Slaughter, Staff Fullstack Engineer.\n\nToutes les équipes de développement entendent parler de l'importance de l'accélération. Cela peut devenir décourageant, particulièrement lorsque l'équipe est confrontée à des problèmes complexes. La prochaine fois que vous rencontrez des difficultés à rédiger du code, envisagez une session de pair programming pour résoudre les problèmes à deux. \n\n*« Coder en binôme est ressenti différemment par chaque personne. Privilégiez toujours la communication, le partage des informations et la collaboration entre les équipes. »* Paul Slaughter.  \n\nMaintenant que vous en savez plus sur le pair programming, il est temps de vous lancer ! \n\n> [Essayez GitLab Ultimate gratuitement.](https://gitlab.com/-/trial_registrations/new?glm_source=about.gitlab.com/blog&glm_content=default-saas-trial \"Essai gratuit de GitLab. \")",[681],"Suri Patel","2024-09-24","2019-08-20","Pair programming : coder en binôme pour progresser et améliorer sa productivité",[686,687,9,688],"agile","collaboration","workflow","insights",{"slug":691,"featured":6,"template":692},"agile-pairing-sessions","BlogPost","content:fr-fr:blog:agile-pairing-sessions.yml","Agile Pairing Sessions","fr-fr/blog/agile-pairing-sessions.yml","fr-fr/blog/agile-pairing-sessions",{"_path":698,"_dir":247,"_draft":6,"_partial":6,"_locale":7,"seo":699,"content":705,"config":714,"_id":716,"_type":14,"title":717,"_source":16,"_file":718,"_stem":719,"_extension":19},"/fr-fr/blog/beginner-guide-python-programming",{"title":700,"description":701,"ogTitle":700,"ogDescription":701,"noIndex":6,"ogImage":702,"ogUrl":703,"ogSiteName":675,"ogType":676,"canonicalUrls":703,"schema":704},"Apprendre Python : tout savoir sur ce langage de programmation","Python est de plus en plus populaire, et pour de bonnes raisons. Retrouvez toutes les informations essentielles pour faire vos premiers pas avec Python.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749664962/Blog/Hero%20Images/python.jpg","https://about.gitlab.com/blog/beginner-guide-python-programming","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Apprendre Python : tout savoir sur ce langage de programmation\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"GitLab\"}],\n        \"datePublished\": \"2021-10-21\",\n      }",{"title":700,"description":701,"authors":706,"heroImage":702,"date":708,"body":709,"category":710,"tags":711},[707],"GitLab","2021-10-21","Vous vous passionnez pour la programmation informatique et souhaitez en apprendre davantage sur Python ? Vous souhaitez savoir par où commencer pour maîtriser les bases de Python ? Découvrez dans cet article les concepts de base de ce langage. \n\n## Comment débuter sur Python ?\n\nPython est un langage de programmation puissant et facile à apprendre, à utiliser et à déployer, dont l'utilisation est très répandue dans la création d'applications web et de bureau. Python facilite également l'analyse de données et l'exécution de tâches [DevOps](https://about.gitlab.com/fr-fr/solutions/devops-platform/ \"Qu'est-ce que DevOps ? \"). C'est un langage de programmation gratuit, open source et orienté objet, utilisé pour écrire des scripts simples, tout comme des programmes complexes. Parmi les près de 700 langages de programmation, Python se distingue comme l'un des plus accessibles pour les débutants.\n\n### Installer Python\n\nAvant d'aborder les bases de Python, il est essentiel de télécharger et d'installer Python sur votre ordinateur de bureau ou votre ordinateur portable. Python fonctionne sur plusieurs plateformes, dont Linux, Windows et Mac. Il est préinstallé sur la plupart des systèmes Mac et Linux, mais il est préférable de télécharger la dernière version depuis le [site officiel de Python](https://www.python.org/downloads/ \"Site officiel de Python\").\n\nPour vérifier la version actuelle de Python sur votre système, ouvrez la ligne de commande et tapez « python -V ».\n\n![Invite de commande Python](https://about.gitlab.com/images/blogimages/python1.png){: .shadow}\n\nSi votre version est obsolète, téléchargez l'installation 32 ou 64 bits à partir du site Web, selon la configuration de votre système.\n\nIl existe d’autres alternatives pour télécharger le programme d’installation : sur Windows, vous pouvez l'installer directement à partir de Microsoft. Sur Linux, vous pouvez l'installer à l'aide du gestionnaire de paquets. Sur macOS, vous pouvez télécharger Python à partir de [Homebrew](https://brew.sh/ \"Homebrew\").\n\nUne fois le programme téléchargé, exécutez-le et confirmez l'installation du fichier. Vous pouvez dès lors commencer à utiliser Python. \n\nVoici un exemple d'installation de Python pour Windows.\n\n![Installation de Python pour Windows ](https://about.gitlab.com/images/blogimages/python2.png){: .shadow}\n\n### Exécuter Python dans l'invite de commande\n\nPour vérifier que Python est installé et fonctionne correctement sous Windows, ouvrez l'invite de commande et saisissez « python », ce qui lancera l'interpréteur. Vous pouvez y exécuter directement des codes Python. Par exemple, saisissez « 2*5+1 » et appuyez sur « Entrée ». Vous verrez « 11 » comme résultat. Saisissez « Quit () » pour quitter l'interpréteur.\n\n![Interpréteur Python](https://about.gitlab.com/images/blogimages/python3.png){: .shadow}\n\n### Exécuter Python dans l'IDE\n\nMaintenant que la dernière version de Python est installée, vous êtes prêt à commencer à programmer en Python. Pour écrire des scripts ou des programmes longs en Python, utilisez l'environnement de développement et d'apprentissage intégré ([IDLE](https://docs.python.org/fr/3/library/idle.html \"IDLE Python\")) de Python.\n\nLancez l'IDLE puis, dans le menu déroulant sélectionnez « Fichier », puis « Nouveau fichier », ce qui ouvre une nouvelle fenêtre d'édition. Vous avez à présent deux fenêtres sur votre écran : un *shell* Python et un fichier sans titre.\n\n![shell Python et fichier sans titre](https://about.gitlab.com/images/blogimages/python4.png){: .shadow}\n\nLe *shell* Python est un environnement REPL, abréviation de « *read-eval-print-loop* » (boucle de lecture-évaluation-affichage). Il exécute des extraits de code, généralement une instruction à la fois. Par exemple, en répétant le même calcul « 2*5+1 » que nous avons fait dans l'invite de commande, vous pouvez constater qu'un *shell* Python peut fonctionner comme une calculatrice.\n\n![Débuter sur Python avec une opération de calcul](https://about.gitlab.com/images/blogimages/python5.png){: .shadow}\n\nLa fenêtre sans titre est une fenêtre d'édition de texte permettant d'écrire des programmes complets. Le *shell* affiche son résultat. Par exemple, le premier programme conventionnel de Python pour les débutants consiste à afficher le texte « Hello World! ». Veillez à sauvegarder l'éditeur de texte avant de l'exécuter en appuyant sur « F5 ».\n\n![Affichage du texte Hello World! sur Python](https://about.gitlab.com/images/blogimages/python61.png){: .shadow}\n\n## Les bases de Python\n\nNous savons que vous avez hâte de commencer à écrire de longs scripts pour des jeux et des sites Web, mais il vous reste encore un long chemin à parcourir pour y arriver. Comme pour l’apprentissage de tout autre langage, vous devez d'abord comprendre les bases de Python.\n\nLa fonction __print()__, comme nous l’avons vu dans l'exemple « Hello World! », affiche une valeur dans la fenêtre de résultat. Une valeur est la chose la plus élémentaire qu'un programme utilise. Il peut s'agir d'une chaîne de caractères, d'une valeur numérique ou de tout autre objet Python. Tout objet entre guillemets simples ou doubles est appelé chaîne de caractères (string).\n\nPar exemple, le « Hello World! » affiché dans le programme ci-dessus est également une chaîne de caractères. Les valeurs numériques telles que 4 et 4.5 sont respectivement des nombres entiers et des nombres flottants. Vous pouvez transformer un nombre entier ou un nombre flottant en une chaîne de caractères, et vice versa en utilisant les fonctions intégrées __int()__, __float()__ et __str()__.\n\n![Image illustrant les fonctions str(), int() et float() de Python.](https://about.gitlab.com/images/blogimages/python7.png){: .shadow}\n\n## Le vocabulaire de Python\n\nPython est un des langages de programmation les plus simples. Il est facile à lire et à comprendre. Contrairement aux langages humains, Python possède un vocabulaire restreint, et des mots-clés réservés ayant une signification particulière. Les termes ne faisant pas partie de ce vocabulaire réservé n'ont de sens que pour vous et sont appelés variables. Ces 35 mots-clés réservés sont les suivants :\n\n![Les 35 mots-clés réservés à connaître pour apprendre Python](https://about.gitlab.com/images/blogimages/python8.png){: .shadow}\n\nVeillez à utiliser ces mots-clés dans leur but spécifique pour éviter d'induire l'interpréteur Python en erreur et de provoquer une erreur de syntaxe.\n\n### Nommer les variables\n\nVous aurez parfois besoin de stocker des valeurs dans votre code pour les récupérer plus tard, ce que vous pouvez faire en leur donnant des noms symboliques, appelés variables. Comme illustré ci-dessous, nous demandons à Python de stocker 5 et 6 avec les labels respectifs x et y, puis de les récupérer plus tard pour trouver leur somme. \n\n![Stockage des variables dans Python](https://about.gitlab.com/images/blogimages/python9.png){: .shadow}\n\nIl existe des règles pour choisir le nom d'une variable ; le non-respect de ces règles entraînera une erreur de syntaxe. \n\nVoici quelques règles obligatoires :\n- Le nom peut contenir des lettres et des chiffres, mais il ne peut pas commencer par un chiffre.\n- Un tiret bas peut être utilisé dans le nom pour séparer plusieurs mots.\n- Les symboles spéciaux comme @#$ sont interdits et ne doivent pas apparaître dans le nom.\n- Les mots-clés Python ne doivent pas être utilisés comme noms de variables.\n\n### Comprendre les opérateurs et les opérandes \n\nPython utilise des symboles spéciaux appelés « opérateurs » pour représenter les calculs mathématiques de base. Les valeurs auxquelles ces opérateurs sont appliqués sont appelées opérandes. Les symboles utilisés comme opérateurs pour la soustraction, l'addition, la division, la multiplication et l'exponentiation sont respectivement -, +, /, * et **.\n\n![Apprendre à coder en Python : symboles pour les opérateurs](https://about.gitlab.com/images/blogimages/python10.png){: .shadow}\n\nL'opérateur modulo (%) génère le reste du premier opérande divisé par le second opérande. Il est utile pour vérifier si un nombre est divisible par un autre et pour extraire le ou les chiffres les plus à droite d'un nombre.\n\n![Opérateur modulo](https://about.gitlab.com/images/blogimages/python11.png){: .shadow}\n\n### Utiliser les expressions\n\nUne combinaison de valeurs, de variables et d'opérateurs est appelée une expression. Une expression saisie dans le *shell* est évaluée et la réponse est affichée. Cependant, dans un script, une expression ne fait rien par elle-même.\n\nPython utilise la convention mathématique PEMDAS pour les opérateurs, ce qui signifie que P pour Parenthèses a la priorité la plus élevée, puis Exponentiation, Multiplication et Division, qui ont la même priorité. L'Addition et la Soustraction viennent ensuite et ont également la même priorité. Les opérateurs qui ont la même préférence sont également évalués de gauche à droite.\n\n![Apprendre python : PEMDAS](https://about.gitlab.com/images/blogimages/python12.png){: .shadow}\n\nLes opérateurs Addition et Multiplication fonctionnent aussi avec les chaînes de caractères pour la concaténation et la répétition d'une chaîne : \n\n![Opérateurs d'addition et de multiplication](https://about.gitlab.com/images/blogimages/python13.png){: .shadow}\n\nPython permet également d'obtenir la valeur d'une variable de l'utilisateur via son clavier. Cela peut être fait en utilisant une fonction intégrée appelée __input__.\n\n![Les bases de python : fonction input](https://about.gitlab.com/images/blogimages/python14.png){: .shadow}\n\n## Débutez sur Python en écrivant votre premier programme\n\nIl est maintenant temps d'écrire votre premier programme simple en utilisant tout ce que vous avez appris dans cet article. Écrivez un script qui prend deux nombres en entrée (input) et les additionne. Faites-le de vous-même, puis consultez le code ci-dessous pour comparer votre travail.\n\n![Écrire un premier programme sur Python](https://about.gitlab.com/images/blogimages/python15.png){: .shadow}\n\nFélicitations ! Vous venez d'écrire votre premier programme.\n\nApprendre Python est facile. Nous vous avons simplement aidé à acquérir les notions de base nécessaires pour maîtriser les bases de Python. C’est à vous de jouer maintenant ! \n\nPhoto par \u003Ca href=\"https://unsplash.com/@davidclode?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText\">David Clode\u003C/a> sur Unsplash.\n","devsecops",[9,712,713],"careers","tutorial",{"slug":715,"featured":6,"template":692},"beginner-guide-python-programming","content:fr-fr:blog:beginner-guide-python-programming.yml","Beginner Guide Python Programming","fr-fr/blog/beginner-guide-python-programming.yml","fr-fr/blog/beginner-guide-python-programming",{"_path":721,"_dir":247,"_draft":6,"_partial":6,"_locale":7,"seo":722,"content":728,"config":741,"_id":743,"_type":14,"title":744,"_source":16,"_file":745,"_stem":746,"_extension":19},"/fr-fr/blog/gitlab-named-a-leader-in-the-2024-gartner-magic-quadrant-for-devops",{"title":723,"description":724,"ogTitle":723,"ogDescription":724,"noIndex":6,"ogImage":725,"ogUrl":726,"ogSiteName":675,"ogType":676,"canonicalUrls":726,"schema":727},"Magic Quadrant 2024 : GitLab, Leader des plateformes DevOps","GitLab figure en tête du classement pour sa capacité d'exécution et l'exhaustivité de sa vision avec sa plateforme DevOps.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749662523/Blog/Hero%20Images/Gartner_DevOps_Blog_Post_Cover_Image_1800x945__2_.png","https://about.gitlab.com/blog/gitlab-named-a-leader-in-the-2024-gartner-magic-quadrant-for-devops","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"GitLab nommée Leader dans le Magic Quadrant 2024 de Gartner dédié aux plateformes DevOps\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Ashley Kramer\"}],\n        \"datePublished\": \"2024-09-05\",\n      }\n                  ",{"title":729,"description":730,"authors":731,"heroImage":725,"date":733,"body":734,"category":735,"tags":736,"updatedDate":740},"GitLab nommée Leader dans le Magic Quadrant 2024 de Gartner dédié aux plateformes DevOps","Notre approche DevOps innovante et le succès de nos clients ont permis à GitLab de figurer en tête du classement pour sa capacité d'exécution et l'exhaustivité de sa vision.",[732],"Ashley Kramer","2024-09-05","À l'origine, l'approche DevOps n'était qu'un concept, une méthodologie qui permettait de livrer des logiciels plus rapidement en réunissant des équipes traditionnellement disparates. Il s'agissait de répondre aux problèmes causés par la séparation entre les équipes de développement et celles de déploiement.\n\nChez GitLab, nous avons repris ce concept et l'avons développé : au lieu d'assembler des outils pour créer une chaîne d'outils DevOps complexe, nous avons créé une [plateforme DevOps unique](https://about.gitlab.com/fr-fr/platform/) pour encourager une collaboration plus étroite, une automatisation plus poussée et des processus plus évolutifs et standardisés.\n\nNous sommes convaincus de la valeur de cette stratégie, qui est axée sur la réussite de nos clients. À l'occasion de la deuxième édition du [Magic Quadrant de Gartner dédié aux plateformes DevOps](https://about.gitlab.com/fr-fr/gartner-magic-quadrant/), nous avons à nouveau été reconnus comme un des Leaders, cette fois-ci, dans les deux domaines suivants : Capacité d'exécution et Exhaustivité de la vision.\n\n![Image Gartner MQ pour les plateformes DevOps 2024](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749674334/Blog/Content%20Images/figure1.png)\n\n> Téléchargez le [rapport Magic Quadrant™ 2024 de Gartner® dédié aux plateformes DevOps](https://about.gitlab.com/fr-fr/gartner-magic-quadrant/).\n\nLes fournisseurs de logiciels doivent aujourd'hui faire face à des menaces de sécurité croissantes et à des exigences de conformité complexes, tout en adoptant avec discernement les nouvelles technologies comme l'IA générative. Et bien sûr, ils doivent fournir à leurs clients des services évolutifs et toujours plus innovants.\n\nL'objectif de GitLab est d'aider ses clients à surmonter ces défis et à devenir des leaders dans leurs secteurs. Grâce à notre plateforme DevSecOps alimentée par l'IA, ils peuvent anticiper les problèmes de sécurité et améliorer la visibilité tout au long du cycle de développement, tout en rassemblant les acteurs nécessaires pour créer des logiciels indispensables.\n\n## Aller plus loin dans l'approche DevOps\n\nMais l'aventure ne fait que commencer ! Notre objectif ? Continuer à développer la vision DevOps et faire progresser notre plateforme DevSecOps de deux manières.\n\nPour commencer, nous voulons inviter encore plus d'équipes à collaborer sur la même plateforme, avec des fonctionnalités dédiées à celles impliquées dans [la planification Agile](https://about.gitlab.com/fr-fr/blog/categories/agile-planning/), la [science des données](https://about.gitlab.com/fr-fr/topics/devops/the-role-of-ai-in-devops/) et [l'observabilité](https://about.gitlab.com/fr-fr/blog/observability-vs-monitoring-in-devops/) et la surveillance des applications.\n\nDeuxièmement, nous voulons rendre l’adoption de notre plateforme et les options de déploiement encore plus flexibles pour répondre aux divers besoins de nos clients. Pour ce faire, nous enrichissons [GitLab Dedicated](https://about.gitlab.com/dedicated/), notre option hébergée à locataire unique, afin que les entreprises évoluant dans des secteurs hautement réglementés puissent bénéficier de la simplicité du SaaS et des nouvelles fonctionnalités et capacités, tout en respectant les besoins de conformité des infrastructures isolées.\n\n## Aider les entreprises à créer des logiciels sûrs\n\nAu-delà de la création d'une meilleure plateforme de collaboration pour le développement de logiciels, l'un de nos objectifs clés est d'aider les entreprises à produire des logiciels plus sûrs et plus conformes. C'est cet objectif qui nous démarque de nos concurrents, car GitLab intègre le [scanning de sécurité](https://about.gitlab.com/fr-fr/solutions/security-compliance/) au stade de la validation du code, et non lorsque les applications sont prêtes à être publiées. Les équipes peuvent ainsi détecter plus rapidement les vulnérabilités, ce qui accélère les cycles de sortie. GitLab facilite également le respect de la conformité grâce à la présence de garde-fous au niveau des stratégies et à la génération automatique [d'une nomenclature logicielle](https://about.gitlab.com/fr-fr/blog/the-ultimate-guide-to-sboms/ \"Qu'est-ce qu'une nomenclature logicielle (SBOM) ?\").\n\nNous savons que la sécurité est un enjeu de plus en plus important pour nos clients, à mesure que la surface d'attaque de leur logiciel s'étend. C'est pourquoi, au cours des 12 prochains mois, nous prévoyons de continuer à améliorer nos scanners SAST, d'ajouter des contrôles supplémentaires au niveau des stratégies de sécurité et de compiler [un nouveau gestionnaire de secrets natif](https://about.gitlab.com/blog/gitlab-native-secrets-manager-to-give-software-supply-chain-security-a-boost/).\n\n## Accompagner tout le cycle du développement logiciel grâce à l'IA\n\nNotre vision est également d'être leader dans le domaine de l'IA, à la fois en aidant nos clients à créer des logiciels innovants avec l'IA, mais aussi en exploitant les technologies d'IA respectueuses de la confidentialité. L'IA représente en effet une véritable avancée et offre d'innombrables opportunités lorsqu'elle est intégrée tout au long du cycle de développement logiciel. Mais pour nous, l'innovation doit avant tout se faire de manière responsable. Les préoccupations de nos clients sont claires : ils veulent une [IA avec des garde-fous](https://about.gitlab.com/the-source/ai/velocity-with-guardrails-ai-automation/), une [IA transparente](https://about.gitlab.com/fr-fr/ai-transparency-center/) et une IA qui respecte leur code et leur propriété intellectuelle.\n\nNous nous engageons à enrichir [GitLab Duo](https://about.gitlab.com/fr-fr/gitlab-duo/), une suite de fonctionnalités alimentées par l'IA pour notre plateforme DevSecOps qui sont à la fois complètes, respectueuses de la confidentialité et conçues pour prendre en charge l'ensemble du cycle de développement logiciel.\n\nC'est cet engagement et nos fonctionnalités GitLab Duo qui ont encouragé [Gartner® à nous nommer Leader dans son premier Magic Quadrant™ dédié aux assistants IA pour le code](https://about.gitlab.com/fr-fr/blog/gitlab-named-a-leader-in-2024-gartner-magic-quadrant-for-ai-code-assistants/).\n\nNous sommes fiers de cette reconnaissance qui nous encourage à rester à l'écoute de nos clients afin de continuer à développer notre vision, notre roadmap produit et notre engagement à créer la meilleure plateforme DevSecOps.\n\n> Téléchargez le [rapport Magic Quadrant™ 2024 de Gartner® dédié aux plateformes DevOps](https://about.gitlab.com/fr-fr/gartner-magic-quadrant/).\n\n***Source : Gartner, Magic Quadrant dédié aux plateformes DevOps, Keith Mann, Thomas Murphy, Bill Holz, George Spafford, août 2024***\n\n***GARTNER est une marque déposée et une marque de service de Gartner, Inc. et/ou de ses sociétés affiliées aux États-Unis et à l'étranger et MAGIC QUADRANT est une\nmarque déposée de Gartner, Inc. et/ou de ses sociétés affiliées. Elles sont utilisées ici avec autorisation. Tous droits réservés.***\n\n***Gartner ne cautionne aucun fournisseur, produit ou service décrit dans ses publications de recherche, et ne conseille pas aux utilisateurs de la technologie de sélectionner uniquement les fournisseurs ayant les notes les plus élevées ou toute autre désignation. Les publications de recherche de Gartner reflètent les opinions de l'organisation de recherche de Gartner et ne doivent pas être interprétées comme des déclarations de fait. Gartner décline toute garantie, expresse ou implicite, à l'égard de cette recherche, y compris toute garantie de qualité marchande ou d'adéquation à un usage particulier.***\n\n***Ce graphique a été publié par Gartner Inc. dans le cadre d'un rapport plus vaste et doit être évalué dans le contexte de l'ensemble du document. Le document produit par Gartner est disponible sur demande auprès de Gartner.***","news",[735,737,738,9,739],"research","DevSecOps platform","DevSecOps","2024-10-07",{"slug":742,"featured":91,"template":692},"gitlab-named-a-leader-in-the-2024-gartner-magic-quadrant-for-devops","content:fr-fr:blog:gitlab-named-a-leader-in-the-2024-gartner-magic-quadrant-for-devops.yml","Gitlab Named A Leader In The 2024 Gartner Magic Quadrant For Devops","fr-fr/blog/gitlab-named-a-leader-in-the-2024-gartner-magic-quadrant-for-devops.yml","fr-fr/blog/gitlab-named-a-leader-in-the-2024-gartner-magic-quadrant-for-devops",{"_path":748,"_dir":247,"_draft":6,"_partial":6,"_locale":7,"seo":749,"content":755,"config":763,"_id":765,"_type":14,"title":766,"_source":16,"_file":767,"_stem":768,"_extension":19},"/fr-fr/blog/how-to-deploy-react-to-amazon-s3",{"title":750,"description":751,"ogTitle":750,"ogDescription":751,"noIndex":6,"ogImage":752,"ogUrl":753,"ogSiteName":675,"ogType":676,"canonicalUrls":753,"schema":754},"Comment déployer une application React sur Amazon S3 avec GitLab CI/CD","Vous souhaitez déployer une application React sur Amazon S3 avec GitLab CI/CD ? Suivez notre guide étape par étape.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749663291/Blog/Hero%20Images/cover1.jpg","https://about.gitlab.com/blog/how-to-deploy-react-to-amazon-s3","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Comment déployer une application React sur Amazon S3 avec GitLab CI/CD\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Jeremy Wagner\"}],\n        \"datePublished\": \"2023-03-01\",\n      }",{"title":750,"description":751,"authors":756,"heroImage":752,"date":758,"body":759,"category":760,"tags":761,"updatedDate":762},[757],"Jeremy Wagner","2023-03-01","Amazon S3 dispose d'une fonctionnalité d'hébergement qui vous permet\nd'héberger un site Web statique directement à partir d'un bucket S3,\négalement appelé compartiment. Lorsque vous hébergez votre site Web sur\nAmazon S3, son contenu est stocké dans un bucket S3 et servi directement à\nvos utilisateurs, sans besoin de ressources supplémentaires. \n\n\nCombinez cela avec Amazon CloudFront et vous obtiendrez une solution\nrentable et évolutive pour l'hébergement de vos sites Web statiques. Une\nfonctionnalité particulièrement utile pour les applications à page unique.\n\n\nDans cet article, nous vous guidons dans la configuration de votre bucket\nAmazon S3, la configuration d'OpenID Connect\n([OIDC](https://openid.net/developers/how-connect-works/ \"OpenID Connect\"))\ndans AWS et le déploiement de votre application sur Amazon S3 à l'aide d'un\npipeline GitLab [CI/CD](https://about.gitlab.com/fr-fr/topics/ci-cd/\n\"Qu'est-ce que le CI/CD ?\").\n\n\nÀ la fin de cet article, vous disposerez d'un [pipeline\nCI/CD](https://about.gitlab.com/fr-fr/topics/ci-cd/cicd-pipeline/ \"Qu'est-ce\nqu'un pipeline CI/CD ?\") construit dans GitLab qui se déploie\nautomatiquement dans votre bucket Amazon S3. \n\n\n## Prérequis\n\n\nPour ce guide, vous aurez besoin des éléments suivants :\n\n\n- [Node.js](https://nodejs.org/fr) >= 14.0.0 et npm >= 5.6 installés sur\nvotre système\n\n- [Git](https://git-scm.com/) installé sur votre système\n\n- Un [compte GitLab](https://gitlab.com/-/trials/new)\n\n- Un [compte AWS](https://aws.amazon.com/fr/free/)\n\n\nDans un [précédent\ntutoriel](https://about.gitlab.com/blog/how-to-automate-testing-for-a-react-application-with-gitlab/)\nnous vous avons expliqué comment : \n\n- créer une nouvelle application React,\n\n- exécuter des tests unitaires dans le cadre du processus CI dans GitLab,\n\n- générer les résultats des tests ainsi que la couverture de code dans le\npipeline.\n\n\nCet article constitue la [suite de ce\nprojet](https://gitlab.com/guided-explorations/engineering-tutorials/react-unit-testing).\nLibre à vous de le parcourir et de le dupliquer (fork). \n\n\n## Configuration de votre bucket S3 \n\n\nPour commencer, vous devez configurer votre bucket Amazon S3. \n\n\n### Créez votre compartiment\n\n\nAprès vous être connecté à votre compte AWS, recherchez « S3 » à l'aide de\nla barre de recherche et sélectionnez le service S3. Cela ouvrira la page\nd'accueil du service.\n\n\nVous devriez immédiatement voir l'option permettant de créer un bucket\n(compartiment). Ce compartiment est l'endroit où vous allez stocker votre\napplication React une fois créée. Cliquez sur le bouton « Créer un\ncompartiment » pour continuer.\n\n\n![Création d'un bucket\nS3](https://about.gitlab.com/images/blogimages/2023-02-10-how-to-deploy-react-to-amazon-s3/create_bucket.png){:\n.shadow}\n\n\nDonnez un nom à votre compartiment, sélectionnez votre région, laissez le\nreste des paramètres par défaut (nous y reviendrons plus tard) et continuez\nen cliquant sur le bouton « Créer un compartiment ». \n\n\nLorsque vous nommez votre compartiment, il est important de se rappeler que\nle nom doit être unique et suivre les règles de nommage des compartiments.\nNous avons nommé le nôtre `jw-gl-react`.\n\n\nUne fois votre compartiment créé, vous devriez être redirigé vers une liste\nde vos compartiments, comme montré ci-dessous. \n\n\n![Liste bucket S3\nAWS](https://about.gitlab.com/images/blogimages/2023-02-10-how-to-deploy-react-to-amazon-s3/bucket_list.png){:\n.shadow}\n\n\n### Configurez l'hébergement de site web statique \n\n\nL'étape suivante consiste à configurer l'hébergement de site web statique.\nOuvrez votre compartiment en cliquant sur son nom. Sélectionnez l'onglet «\nPropriétés »  et faites défiler vers le bas pour trouver l'option\nd'hébergement de site web statique.\n\n\n![Configuration de l'hébergement de site web\nstatique](https://about.gitlab.com/images/blogimages/2023-02-10-how-to-deploy-react-to-amazon-s3/static_hosting_1.png){:\n.shadow}\n\n\nCliquez sur « Modifier », puis activez l'hébergement de site web statique.\nPour les documents d’index et d’erreur, saisissez `index.html`, puis cliquez\nsur « Enregistrer les modifications ».\n\n\n![Activation de l'hébergement de site web statique sur Amazon\nS3](https://about.gitlab.com/images/blogimages/2023-02-10-how-to-deploy-react-to-amazon-s3/static_hosting_2.png){:\n.shadow}\n\n\n### Configurez les autorisations de votre application React\n\n\nMaintenant que vous avez activé l'hébergement de site web statique, vous\ndevez mettre à jour vos autorisations afin que votre audience puisse accéder\nà votre site web. Revenez à votre compartiment et sélectionnez l'onglet «\nAutorisations ».\n\n\nSous « Bloquer l'accès public » (paramètres du compartiment), cliquez sur «\nModifier », décochez « Bloquer tous les accès publics » et continuez en\ncliquant sur « Enregistrer les modifications ».\n\n\n![Bloquer l'accès\npublic](https://about.gitlab.com/images/blogimages/2023-02-10-how-to-deploy-react-to-amazon-s3/block_access_1.png){:\n.shadow}\n\n\nVotre page devrait maintenant ressembler à ceci : \n\n\n![Configurer permission bucket S3\nAWS](https://about.gitlab.com/images/blogimages/2023-02-10-how-to-deploy-react-to-amazon-s3/block_access_2.png){:\n.shadow}\n\n\nMaintenant, vous devez modifier la stratégie de compartiment. Pour cela,\ncliquez sur le bouton « Modifier » dans la section « Stratégie de\ncompartiment » et collez le code suivant :\n\n\n```javascript\n\n{\n    \"Version\": \"2012-10-17\",\n    \"Statement\": [\n        {\n            \"Sid\": \"PublicReadGetObject\",\n            \"Effect\": \"Allow\",\n            \"Principal\": \"*\",\n            \"Action\": \"s3:GetObject\",\n            \"Resource\": \"arn:aws:s3:::jw-gl-react/*\"\n        }\n    ]\n}\n\n```\n\n\nÀ la ligne « Ressource », remplacez `jw-gl-react`  par le nom de votre\ncompartiment et enregistrez les modifications.\n\n\nVotre compartiment devrait ressembler à ceci : \n\n\n![Bucket S3 accès\npublic](https://about.gitlab.com/images/blogimages/2023-02-10-how-to-deploy-react-to-amazon-s3/block_access_3.png){:\n.shadow}\n\n\n## Chargement de votre application React\n\n\nMaintenant, créons votre application React et publions-la manuellement dans\nvotre bucket S3.\n\n\nPour créer l'application, assurez-vous que votre projet soit cloné sur votre\nmachine locale et exécutez la commande suivante dans votre terminal à\nl'intérieur du répertoire de votre dépôt :\n\n\n```\n\nnpm run build\n\n```\n\nCela créera un dossier `build` à l'intérieur du répertoire de votre dépôt. \n\n\nDans votre compartiment, cliquez sur le bouton « Charger »\n\n\n![Chargement de l'application\nReact](https://about.gitlab.com/images/blogimages/2023-02-10-how-to-deploy-react-to-amazon-s3/upload_1.png){:\n.shadow}\n\n\nFaites glisser le contenu de votre dossier nouvellement créé (et non le\ndossier lui-même) dans la zone de chargement. Cela chargera le contenu de\nvotre application React dans votre compartiment. Assurez-vous de cliquer sur\n« Charger » en bas de la page pour démarrer le chargement.\n\n\nRevenez maintenant à l'onglet « Propriétés » de votre compartiment et faites\ndéfiler vers le bas pour trouver l'URL de votre site web statique.\n\n\n![URL du site web\nstatique](https://about.gitlab.com/images/blogimages/2023-02-10-how-to-deploy-react-to-amazon-s3/upload_2.png){:\n.shadow}\n\n\nCliquez sur le lien et vous devriez voir votre application React\nnouvellement créée s'ouvrir dans votre navigateur.\n\n\n![Application React\ndéployée](https://about.gitlab.com/images/blogimages/2023-02-10-how-to-deploy-react-to-amazon-s3/manual_deploy.png){:\n.shadow}\n\n\n## Configuration d’OpenID Connect dans AWS\n\n\nPour déployer sur votre bucket S3 depuis GitLab, nous allons utiliser un job\nGitLab CI/CD pour  recevoir des informations d'identification temporaires\nd'AWS sans avoir besoin de stocker des secrets. Pour ce faire, nous allons\nconfigurer OpenID Connect pour la fédération d'identité entre GitLab et AWS.\nNous suivrons la [documentation de GitLab\nassociée](https://docs.gitlab.com/ee/ci/cloud_services/aws/).\n\n\n### Ajoutez un fournisseur d'identité \n\n\nLa première étape consiste à ajouter GitLab en tant que fournisseur\nd’identité OpenID Connect (OIDC) dans IAM. AWS fournit des\n[instructions](https://docs.aws.amazon.com/fr_fr/IAM/latest/UserGuide/id_roles_providers_create_oidc.html),\nmais nous allons les parcourir étape par étape dans ce guide.\n\n\nOuvrez tout d'abord la console IAM dans AWS.\n\n\n![Console IAM dans\nAWS](https://about.gitlab.com/images/blogimages/2023-02-10-how-to-deploy-react-to-amazon-s3/iam_1.png){:\n.shadow} \n\n\nDans le volet de navigation de gauche, sous « Gestion des accès »,\nchoisissez « Fournisseurs d'identité », puis « Ajouter un fournisseur ».\nPour le type de fournisseur, sélectionnez « OpenID Connect ».\n\n\nPour l'URL du fournisseur, saisissez l'adresse de votre instance GitLab,\ntelle que `https://gitlab.com` ou `https://gitlab.example.com`.\n\n\nPour « Audience », saisissez quelque chose de générique mais spécifique à\nvotre application React. Dans notre cas, nous allons utiliser `react_s3_gl`.\nVeillez à choisir quelque chose qui ne soit pas facile à deviner et prenez\nnote de cette valeur, car vous l'utiliserez pour définir l'`ID_TOKEN` dans\nvotre fichier `.gitLab-ci.yml`.\n\n\nAprès avoir saisi l'URL du fournisseur, cliquez sur « Obtenir une empreinte\nnumérique »  pour vérifier le certificat du serveur de votre fournisseur\nd'identité. Ensuite, continuez et cliquez sur « Ajouter un fournisseur »\npour terminer.\n\n\n### Créez une politique d’autorisations\n\n\nAprès avoir créé le fournisseur d'identité, vous devez créer une politique\nd’autorisations. \n\n\nDepuis le tableau de bord IAM, sous « Gestion des accès », sélectionnez «\nPolitiques » puis « Créer une politique ». Sélectionnez l'onglet JSON et\ncollez le code suivant en remplaçant `jw-gl-react` par le nom de votre\ncompartiment à la ligne « Ressource ».\n\n\n```javascript\n\n{\n  \"Version\": \"2012-10-17\",\n  \"Statement\": [\n    {\n      \"Effect\": \"Allow\",\n      \"Action\": [\"s3:ListBucket\"],\n      \"Resource\": [\"arn:aws:s3:::jw-gl-react\"]\n    },\n    {\n      \"Effect\": \"Allow\",\n      \"Action\": [\n        \"s3:PutObject\",\n        \"s3:GetObject\",\n        \"s3:DeleteObject\"\n      ],\n      \"Resource\": [\"arn:aws:s3:::jw-gl-react/*\"]\n    }\n  ]\n}\n\n```\n\n\nSélectionnez le bouton « Suivant : Balises » , ajoutez les balises\nsouhaitées, puis sélectionnez le bouton « Suivant : Confirmer ». Entrez un\nnom pour votre politique avant de terminer sa création.\n\n\n### Configurez le rôle\n\n\nIl est maintenant temps d'ajouter le rôle. Depuis le tableau de bord IAM,\nsous « Gestion des accès  », sélectionnez « Rôles », puis cliquez sur «\nCréer un rôle » et choisissez « Identité Web ».\n\n\nDans la section « Identité Web », sélectionnez le fournisseur d'identité que\nvous avez créé précédemment. Pour l'audience, sélectionnez également\nl'audience que vous avez créée précédemment. Cliquez sur le bouton « Suivant\n» pour continuer.\n\n\nSi vous souhaitez limiter l'autorisation à un groupe, un projet, une branche\nou une balise spécifique, vous pouvez créer une « Politique d’approbation\npersonnalisée » (Custom Trust Policy) au lieu d'une « Identité Web ».\n\n\nPour une liste complète des types de filtres qu'il est possible d'appliquer,\n[consultez notre\ndocumentation](https://docs.gitlab.com/ee/ci/cloud_services/index.html#configure-a-conditional-role-with-oidc-claims). \n\n\n![Configuration du rôle dans\nl'IAM](https://about.gitlab.com/images/blogimages/2023-02-10-how-to-deploy-react-to-amazon-s3/iam_2.png){:\n.shadow}\n\n\nAu cours de l'étape « Ajout des autorisations », sélectionnez la politique\nque vous avez créée, puis cliquez sur « Suivant » pour continuer. Donnez un\nnom à votre rôle et cliquez sur « Créer un rôle ».\n\n\nOuvrez le rôle que vous venez de créer. Dans la section « Récapitulatif »,\nrecherchez le nom de ressource Amazon (ARN) et enregistrez-le dans un\nendroit sécurisé. Vous l'utiliserez dans votre pipeline.\n\n\n![Déployer le rôle dans\nl'IAM](https://about.gitlab.com/images/blogimages/2023-02-10-how-to-deploy-react-to-amazon-s3/iam_3.png){:\n.shadow}\n\n\n## Déploiement sur votre compartiment Amazon S3 à l'aide d'un pipeline\nGitLab CI/CD\n\n\nDans votre projet, créez deux [variables\nCI/CD](https://docs.gitlab.com/ci/variables/#define-a-cicd-variable-in-the-ui)\n:\n\n\n- La première variable doit être nommée `ROLE_ARN`. Pour la valeur, collez\nl'ARN du rôle que vous venez de créer.\n\n- La deuxième variable doit être nommée `S3_BUCKET`. Pour la valeur, collez\nle nom du compartiment que vous avez créé plus tôt.\n\n\nPour des raisons de sécurité, dans cet article nous avons choisi de masquer\nnos variables.\n\n\n### Récupérez vos identifiants temporaires\n\n\nDans votre fichier `.gitlab-ci.yml`, collez le code suivant :\n\n\n```\n\n.assume_role: &assume_role\n    - >\n      STS=($(aws sts assume-role-with-web-identity\n      --role-arn ${ROLE_ARN}\n      --role-session-name \"GitLabRunner-${CI_PROJECT_ID}-${CI_PIPELINE_ID}\"\n      --web-identity-token $ID_TOKEN\n      --duration-seconds 3600\n      --query 'Credentials.[AccessKeyId,SecretAccessKey,SessionToken]'\n      --output text))\n    - export AWS_ACCESS_KEY_ID=\"${STS[0]}\"\n    - export AWS_SECRET_ACCESS_KEY=\"${STS[1]}\"\n    - export AWS_SESSION_TOKEN=\"${STS[2]}\"\n```\n\n\nCela va utiliser le service de jeton de sécurité AWS (AWS Security Token\nService) pour générer des identifiants temporaires (3 600 secondes) en\nutilisant le rôle OpenID Connect que vous avez créé précédemment.\n\n\n### Créez le job de déploiement pour votre application React\n\n\nMaintenant, ajoutons un job de compilation et de déploiement pour créer\nvotre application et la déployer sur votre bucket S3.\n\n\nTout d'abord, mettez à jour les étapes dans votre fichier `.gitlab-ci.yml`\npour inclure une étape `build` et `deploy`, comme indiqué ci-dessous :\n\n\n```\n\nstages:\n  - build\n  - test\n  - deploy\n```\n\n\nEnsuite, ajoutons un job pour créer votre application. Collez le code\nsuivant dans votre fichier `.gitLab-ci.yml` :\n\n\n```\n\nbuild artifact:\n  stage: build\n  image: node:latest\n  before_script:\n    - npm install\n  script:\n    - npm run build\n  artifacts:\n    paths:\n      - build/\n    when: always\n  rules:\n    - if: '$CI_COMMIT_REF_NAME == \"main\"'\n      when: always\n```\n\n\nCela va exécuter `npm run build` si le changement se produit sur la branche\n`main` et télécharger le répertoire de compilation (build directory) en tant\nqu'artefact à utiliser lors de l'étape suivante.\n\n\nEnsuite, ajoutons un job qui sera réellement déployé sur votre bucket S3.\nCollez le code suivant dans votre fichier `.gitLab-ci.yml` :\n\n\n```\n\ndeploy s3:\n  stage: deploy\n  image:\n    name: amazon/aws-cli:latest\n    entrypoint: \n      - '/usr/bin/env'\n  id_tokens:\n      ID_TOKEN:\n        aud: react_s3_gl\n  script:\n    - *assume_role\n    - aws s3 sync build/ s3://$S3_BUCKET\n  rules:\n    - if: '$CI_COMMIT_REF_NAME == \"main\"'\n      when: always\n```\n\n\nCela utilise les [ancres\nYAML](https://docs.gitlab.com/ee/ci/yaml/yaml_optimization.html#yaml-anchors-for-scripts)\npour exécuter le script `assume_role`, puis utilise `aws cli` pour\ntélécharger votre artefact de compilation dans le compartiment que vous avez\ndéfini en tant que variable. Ce job ne s'exécute que si le changement se\nproduit sur la branche `main`.\n\n\nAssurez-vous que la valeur `aud` correspond à celle que vous avez saisie\npour votre audience au moment de la configuration du fournisseur d'identité.\nDans notre cas, nous avons saisi `react-s3_gl`.\n\n\nVotre fichier `.gitLab-ci.yml` complet devrait ressembler à ceci :\n\n\n```\n\nstages:\n  - build\n  - test\n  - deploy\n\n.assume_role: &assume_role\n    - >\n      STS=($(aws sts assume-role-with-web-identity\n      --role-arn ${ROLE_ARN}\n      --role-session-name \"GitLabRunner-${CI_PROJECT_ID}-${CI_PIPELINE_ID}\"\n      --web-identity-token $ID_TOKEN\n      --duration-seconds 3600\n      --query 'Credentials.[AccessKeyId,SecretAccessKey,SessionToken]'\n      --output text))\n    - export AWS_ACCESS_KEY_ID=\"${STS[0]}\"\n    - export AWS_SECRET_ACCESS_KEY=\"${STS[1]}\"\n    - export AWS_SESSION_TOKEN=\"${STS[2]}\"\n\nunit test:\n  image: node:latest\n  stage: test\n  before_script:\n    - npm install\n  script:\n    - npm run test:ci\n  coverage: /All files[^|]*\\|[^|]*\\s+([\\d\\.]+)/\n  artifacts:\n    paths:\n      - coverage/\n    when: always\n    reports:\n      junit:\n        - junit.xml\n\nbuild artifact:\n  stage: build\n  image: node:latest\n  before_script:\n    - npm install\n  script:\n    - npm run build\n  artifacts:\n    paths:\n      - build/\n    when: always\n  rules:\n    - if: '$CI_COMMIT_REF_NAME == \"main\"'\n      when: always\n\ndeploy s3:\n  stage: deploy\n  image:\n    name: amazon/aws-cli:latest\n    entrypoint: \n      - '/usr/bin/env'\n  id_tokens:\n      ID_TOKEN:\n        aud: react_s3_gl\n  script:\n    - *assume_role\n    - aws s3 sync build/ s3://$S3_BUCKET\n  rules:\n    - if: '$CI_COMMIT_REF_NAME == \"main\"'\n      when: always\n```\n\n\n### Testez votre pipeline\n\n\nPour tester votre pipeline, dans `App.js`, modifiez cette ligne `Edit\n\u003Ccode>src/App.js\u003C/code> and save to reload.` par ceci :  `This was deployed\nfrom GitLab`. Maintenant, validez vos modifications dans la branche `main`.\nLe pipeline devrait se lancer et une fois terminé avec succès, vous devriez\nvoir votre application mise à jour avec l'URL de votre site web statique.\n\n\n![Application React mise à\njour](https://about.gitlab.com/images/blogimages/2023-02-10-how-to-deploy-react-to-amazon-s3/auto_deploy.png){:\n.shadow}\n\n\nVous disposez désormais d'un pipeline CI/CD construit dans GitLab qui reçoit\ndes informations d'identification temporaires d'AWS à l'aide d'OpenID\nConnect et qui se déploie automatiquement dans votre compartiment Amazon S3.\nPour aller plus loin, vous pouvez [sécuriser votre\napplication](https://docs.gitlab.com/ee/user/application_security/secure_your_application.html)\navec les outils de sécurité intégrés de GitLab.\n\n\nDécouvrez [tout le\ncode](https://gitlab.com/guided-explorations/engineering-tutorials/react-s3)\nde ce projet.\n","engineering",[9,109],"2025-03-27",{"slug":764,"featured":6,"template":692},"how-to-deploy-react-to-amazon-s3","content:fr-fr:blog:how-to-deploy-react-to-amazon-s3.yml","How To Deploy React To Amazon S3","fr-fr/blog/how-to-deploy-react-to-amazon-s3.yml","fr-fr/blog/how-to-deploy-react-to-amazon-s3",{"_path":770,"_dir":247,"_draft":6,"_partial":6,"_locale":7,"seo":771,"content":777,"config":786,"_id":788,"_type":14,"title":789,"_source":16,"_file":790,"_stem":791,"_extension":19},"/fr-fr/blog/how-to-keep-up-with-ci-cd-best-practices",{"title":772,"description":773,"ogTitle":772,"ogDescription":773,"noIndex":6,"ogImage":774,"ogUrl":775,"ogSiteName":675,"ogType":676,"canonicalUrls":775,"schema":776},"Quelles sont les meilleures pratiques CI/CD à connaître ?","Dans cet article, nous vous partageons tous nos conseils pour mettre en oeuvre une approche CI/CD réussie.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749661856/Blog/Hero%20Images/ci-cd-demo.jpg","https://about.gitlab.com/blog/how-to-keep-up-with-ci-cd-best-practices","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Quelles sont les meilleures pratiques CI/CD à connaître ?\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Valerie Silverthorne\"}],\n        \"datePublished\": \"2022-02-03\",\n      }",{"title":772,"description":773,"authors":778,"heroImage":774,"date":780,"body":781,"category":689,"tags":782,"updatedDate":785},[779],"Valerie Silverthorne","2022-02-03","L'intégration continue et la livraison continue sont au cœur de toute pratique DevOps réussie. Pour livrer des logiciels modernes, les équipes doivent se tenir au courant des meilleures pratiques en matière de CI/CD. Que signifie le CI/CD ? Comment mettre en place cette approche au sein de votre entreprise ?  Découvrez tous nos conseils dans cet article. \n\n## Qu’est-ce que le CI/CD ?\n\nLe [CI/CD](https://about.gitlab.com/fr-fr/topics/ci-cd/ \"Qu'est-ce que le CI/CD ?\") (Continuous Integration/Continuous Delivery) est à la fois un processus, une méthodologie et un état d'esprit. En termes simples, l'intégration continue (CI) permet aux [équipes DevOps](https://about.gitlab.com/fr-fr/topics/devops/build-a-devops-team/ \"Equipe DevOps\") de rationaliser le développement de code grâce à l'automatisation. Elle simplifie la création de logiciels et l'intégration du code source, permet le [contrôle de version](https://about.gitlab.com/fr-fr/topics/version-control/ \"Contrôle de version\") et favorise la collaboration entre les équipes. \n\nEnsuite, la livraison continue (CD) prend le relais avec la mise en place de tests et de déploiements automatisés, permettant de faire gagner un temps considérable aux équipes Ops en charge de la livraison et du déploiement, et de [réduire la chaîne d'outils](https://about.gitlab.com/resources/whitepaper-forrester-manage-your-toolchain/ \"Gestion de la chaîne d'outils\") nécessaire au cycle de développement logiciel. Son maître-mot est là encore l'automatisation.\n\n## 10 meilleures pratiques CI/CD à suivre\n\nPour réussir votre approche CI/CD, faites de la notion de continuité le mantra de vos pratiques de développement, de l'intégration jusqu'au déploiement de votre logiciel. Le but du CI/CD dans l’approche DevOps est de livrer des logiciels plus rapidement qu'en suivant les méthodes traditionnelles. \n\nVoici dix conseils éprouvés par les équipes DevOps que vous pouvez suivre :\n\n__1. Ne compilez qu'une seule fois.__ Créer une nouvelle version à chaque étape est source d'incohérences. Utilisez plutôt les mêmes artefacts tout au long du pipeline CI/CD, dont les compilations doivent être indépendantes de l'environnement de développement.\n\n__2. Rationalisez les tests.__ Trouvez un équilibre entre leur portée et leurs performances. Si ces derniers prennent trop de temps, les utilisateurs essaieront de contourner le processus.\n\n__3. Échouez rapidement (*fail fast*).__ Avec l'intégration continue, les équipes de développement cherchent à identifier les problèmes le plus tôt possible, pour corriger le code fraîchement écrit. Limiter les changements de contexte améliore leur confort et la qualité de leur travail.\n\n__4. Faites-le quotidiennement.__ Plus les validations sont régulières, plus les équipes DevOps en bénéficieront. \n\n__5. Corrigez les erreurs.__ L'intégration continue et la livraison continue facilitent la correction d’erreurs de compilation.\n\n__6. Nettoyez les environnements de pré-production.__ Avec le temps, il devient de plus en plus difficile de garder une trace de toutes les modifications de configuration et mises à jour effectuées. C’est pourquoi il est important de nettoyer les environnements de pré-production entre chaque déploiement.\n\n__7. Automatisez en permanence.__ Continuez à ajuster votre pipeline CI/CD pour garantir un état « d’automatisation continue ». \n\n__8. Documentez votre travail.__ Assurez-vous que vos plans de release et de restauration sont bien documentés et compris par toute votre équipe. \n\n__9. Sécurisez votre logiciel.__ L’approche CI/CD implique le contrôle en amont. L’occasion d'intégrer la sécurité plus tôt dans le processus.\n\n__10. Travaillez en boucle.__ Veillez à ce que tous les membres de votre équipe soient impliqués dans les boucles de rétroactions.\n\nPour aller plus loin, consultez notre documentation dédiée à [l’utilisation de l’approche CI/CD avec GitLab](https://docs.gitlab.com/ee/topics/build_your_application.html \"Approche CI/CD avec GitLab\"). \n\n## Quelles sont les meilleures pratiques en matière de livraison continue ?\n\nSi l'intégration continue focalise souvent l'attention des équipes, les meilleures pratiques de livraison continue (CD) méritent, elles aussi, un tour d'horizon. \n\nVoici un résumé des meilleures pratiques en matière de livraison continue (CD) :\n\n- __Démarrez maintenant.__ N’attendez pas l'arrivée d'une nouvelle plateforme. Il est toujours possible d'améliorer la vôtre pour la rendre plus rapide et plus efficace.\n\n- *__Less is more.__* La meilleure livraison continue se fait avec un minimum d'outils.\n\n- __Suivez ce qui se passe.__ La mise en place de jalons peut vous aider à garder le contrôle sur vos tickets et vos merge requests. Ils sont efficaces lors de la mise en place de sprints et de releases agiles.\n\n- __Déployez automatiquement les modifications.__ Rationalisez les tests d'acceptation utilisateur et le staging avec l’automatisation. \n\n- __Gérez le pipeline de release.__ La solution ? L'automatisation.\n\n- __Établissez une surveillance.__ Surveiller de près le processus de production permet d'économiser du temps et de d'argent. La surveillance fournit aussi des données analytiques à l'entreprise.\n\n- __Lancez le déploiement continu.__ Une fois le processus de livraison continue en place, il vous est possible d'automatiser le déploiement, afin de lancer automatiquement vos modifications en production.\n\nTirez parti de tous les avantages de [l'intégration et de la livraison continues](https://about.gitlab.com/fr-fr/solutions/continuous-integration/ \"Intégration et livraison continues\") avec la plateforme [DevSecOps](https://about.gitlab.com/fr-fr/topics/devsecops/ \"DevSecOps\") de GitLab.  \n\n## Comment améliorer son pipeline CI/CD ?\n\nUn pipeline se définit comme la série d'étapes impliquées dans le déploiement d'une nouvelle version d'un logiciel. La surveillance et l'automatisation sont des concepts introduits dans un [pipeline CI/CD](https://about.gitlab.com/fr-fr/topics/ci-cd/cicd-pipeline/ \"Qu'est-ce qu'un pipeline CI/CD ? \") pour améliorer le processus de développement d'applications, aussi bien pendant les phases d'intégration et de test que lors de la livraison et du déploiement du logiciel. \n\nLes étapes d'un pipeline CI/CD comprennent : la planification, l’analyse, la conception, la compilation, les tests, la release, le déploiement, la validation, la conformité et la maintenance. Elles peuvent être réalisées manuellement, mais c'est par leur automatisation qu'un pipeline CI/CD trouve sa valeur. \n\nPour améliorer votre pipeline CI/CD, envisagez les approches suivantes :\n\n- __Variez les stratégies de release.__ Vous pourriez envisager un déploiement Canary, qui permet de déployer de nouvelles fonctionnalités auprès d'un groupe restreint d'utilisateurs.\n\n- __Mettez en place un maximum de [tests automatisés](https://about.gitlab.com/blog/want-faster-releases-your-answer-lies-in-automated-software-testing/ \"Tests automatisés\"),__ car il n'y en a jamais assez.\n\n- __Réduisez le nombre d'outils.__ En minimisant leur nombre, vous limitez les étapes et les interactions nécessaires. L'approche [DevOps](https://about.gitlab.com/fr-fr/topics/devops/ \"DevOps\") requiert la centralisation des outils, y compris CI/CD.\n\n- __Intégrez à votre routine de travail l'analyse de la composition logicielle__ pour anticiper les problèmes critiques liés aux logiciels open source.\n\n## Comment mesurer le succès de votre approche CI/CD ?\n\nIl est impossible de savoir si vos pratiques CI/CD sont efficaces sans les mesurer. Les métriques jouent un rôle important dans l'amélioration des performances et dans l'identification des axes de progrès. Elles servent aussi de base pour mesurer l'impact des changements apportés. \n\nVoici des métriques importantes à utiliser :\n\n### Durée de cycle\n\nIl s'agit du temps nécessaire au déploiement d'une application, à partir du moment où le travail sur le code a commencé. La mesure des différentes phases de ce processus permet de déterminer la durée moyenne du cycle, le temps total de développement, et d'identifier d'éventuels goulots d'étranglement.\n\n### Time to value\n\nLe délai de création de valeur exprime le temps nécessaire à la publication du code. Cela comprend l'intégration, les tests, la livraison et le déploiement, et peut prendre de quelques minutes à quelques heures. Si une compilation nécessite plusieurs jours, alors le processus doit être revu.\n\n### Temps de disponibilité\n\nLe temps de disponibilité (ou *uptime*) est une mesure importante pour les équipes Ops, car il indique si tout fonctionne comme il se doit. Avec une stratégie CI/CD automatisée, les responsables opérationnels peuvent ainsi consacrer plus de temps à la résolution de problèmes liés à la stabilité et moins à ceux liés au workflow.\n\n### Taux d'erreur\n\nMesurer le taux d'erreur des applications fait naturellement partie du travail des équipes de développement. Cela permet de déceler des problèmes de qualité, de performance et de disponibilité. Parfois, un taux d'erreur élevé s'accompagne pourtant d'un uptime performant. Cela illustre la difficulté de fixer des objectifs opérationnels cohérents entre toutes les équipes, un des [challenges reconnus des pratiques CI/CD](https://about.gitlab.com/blog/modernize-your-ci-cd/ \"Challenges des pratiques CI/CD\"). \n\n### Coûts d'infrastructure\n\nDans le cadre d’un développement cloud-natif, les coûts d'infrastructure revêtent une importance stratégique. Le déploiement et la gestion d'une plateforme CI/CD peuvent entraîner des dépenses importantes s’ils ne sont pas contrôlés. Pour les maîtriser, il faut considérer tous les facteurs que représentent les coûts des fournisseurs de solutions cloud computing. Ils comprennent le matériel réseau, mais aussi la maintenance de l'infrastructure et la main-d'œuvre.\n\n### Fidélisation des collaborateurs\n\nCe n'est pas un mystère : un développeur valorisé et satisfait sera moins susceptible de quitter l'entreprise. La fidélisation des employés passe aussi par une collaboration efficace et de qualité. En étudiant le taux de rétention de vos effectifs, vous serez en mesure d’identifier des problèmes potentiels de gestion d'équipe.\n\n## Pourquoi faut-il suivre ces bonnes pratiques CI/CD ?\n\nLorsque les meilleures pratiques en intégration et livraison continues sont respectées, c'est toute l'entreprise qui en profite, des RH aux opérations. La mise en place de métriques de performance CI/CD apporte ainsi des données utiles au développement de nombreux aspects de l'entreprise.\n\nUn pipeline CI/CD efficace peut changer la donne pour vos équipes DevOps. Voici quelques-uns des principaux avantages :\n\n- __Les développeurs et développeuses écrivent du code au lieu de le corriger.__ Avec une chaîne d'outils réduite, le temps de maintenance diminue au profit de celui consacré à la production d'applications logicielles de qualité.\n\n- __Le code est en production.__ Les équipes de développement peuvent rapidement déployer leur code en production, ce qui contribue également à leur satisfaction au travail.\n\n- __Les équipes de développement se concentrent sur les tâches les plus importantes.__ Avec un processus CI/CD rationalisé, les équipes orientent leur travail sur des aspects plus cruciaux pour l’entreprise et ne perdent plus de temps à gérer des tâches à faible valeur ajoutée. \n\n- __L'innovation est facilitée.__ Dans un secteur toujours plus dynamique et concurrentiel, des processus CI/CD bien construits permettent aux entreprises de développer des logiciels plus facilement, plus rapidement et de manière plus sûre. Les équipes DevOps ont ainsi plus de temps et d'énergie pour créer et innover.\n\n- __Il est plus facile d'attirer et de retenir les talents.__ Les talents DevOps peuvent être très difficiles à séduire sur un marché du travail très compétitif. Une organisation faisant preuve d'excellence dans ses processus CI/CD pourra plus facilement démontrer l'importance qu'elle accorde à son équipe DevOps.\n\n- __Chacun fait ce qu’il sait faire de mieux.__ Une démarche CI/CD bien définie favorise une [collaboration optimale](https://about.gitlab.com/fr-fr/teamops/ \"TeamOps\") où chaque équipe peut se consacrer à sa fonction, qu'elle ait trait au développement, à la sécurité, aux tests ou aux opérations.\n\n## Stratégie de déploiement CI/CD\n\nL'objectif de l'approche CI/CD est simple : apporter au client une application logicielle à la fois plus performante et plus rapide. Les entreprises qui l'adoptent constatent une hausse considérable de leur productivité, l'astuce consistant à définir une stratégie de déploiement adaptée à leurs besoins. \n\nVoici quelques stratégies qui contribuent à la réussite d'un déploiement :\n\n- Engagez-vous à respecter la fréquence des livraisons continues.\n- Automatisez le processus de compilation.\n- Exécutez les tests en parallèle, et créez un pipeline de déploiement.\n- Corrigez votre logiciel en amont pour accélérer le rythme de développement sans conséquences néfastes.\n- Utilisez des outils d'intégration continue fournissant un retour d'information rapide.\n\n## Comment mettre en œuvre une approche CI/CD ?\n\nComme pour tout autre logiciel, définissez au préalable les moteurs économiques et stratégiques qui justifient l'adoption de l'approche CI/CD. Impliquez toutes les parties prenantes de l'entreprise dans le processus de décision et de mise en œuvre. Les équipes de développement doivent y participer activement, puisqu'elles seront les principaux utilisateurs du produit.\n\nEffectuez des recherches approfondies pour trouver quels logiciels faciliteront la mise en œuvre des meilleures pratiques CI/CD, et n'hésitez pas à recourir à des essais gratuits au besoin. \n\nEnsuite, démarrez le processus dans un esprit de constance. La patience ne semble pas de mise pour une approche visant à accélérer la livraison de logiciels, mais elle vous évitera de laisser des erreurs se glisser tout au long du cycle de développement de votre logiciel. Votre efficacité n'en sera que plus grande.\n\nEnfin, il est essentiel de conserver un processus d'intégration cohérent. Effectuez des tests unitaires, déclenchez manuellement des releases et consultez les métriques. Vous pourrez alors déterminer ce qui peut et doit être automatisé. \n\nEn suivant ces bonnes pratiques CI/CD, vous permettrez à votre entreprise et à votre équipe DevOps de gagner sur plusieurs tableaux. Non seulement vous profiterez de logiciels de meilleure qualité, développés plus rapidement, mais vous augmenterez par la même occasion la satisfaction et l’engagement de vos équipes de développement.\n",[783,784,9],"CI","CD","2024-10-17",{"slug":787,"featured":6,"template":692},"how-to-keep-up-with-ci-cd-best-practices","content:fr-fr:blog:how-to-keep-up-with-ci-cd-best-practices.yml","How To Keep Up With Ci Cd Best Practices","fr-fr/blog/how-to-keep-up-with-ci-cd-best-practices.yml","fr-fr/blog/how-to-keep-up-with-ci-cd-best-practices",{"_path":793,"_dir":247,"_draft":6,"_partial":6,"_locale":7,"seo":794,"content":800,"config":808,"_id":810,"_type":14,"title":811,"_source":16,"_file":812,"_stem":813,"_extension":19},"/fr-fr/blog/introduction-guide-to-linux-servers",{"ogTitle":795,"schema":796,"ogImage":797,"ogDescription":798,"ogSiteName":675,"noIndex":6,"ogType":676,"ogUrl":799,"title":795,"canonicalUrls":799,"description":798},"Serveur Linux : définition, avantages, usage et installation","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Guide d'introduction aux serveurs Linux : définition, avantages, usage et installation\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"GitLab France Team\"}],\n        \"datePublished\": \"2024-12-04\",\n      }","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749663065/Blog/Hero%20Images/serveur-linux.jpg","Le serveur Linux est couramment utilisé dans les entreprises. Découvrez ses fonctionnalités, ses utilisations et ses avantages.","https://about.gitlab.com/blog/introduction-guide-to-linux-servers",{"title":801,"description":798,"authors":802,"heroImage":797,"date":804,"body":805,"category":710,"tags":806},"Guide d'introduction aux serveurs Linux : définition, avantages, usage et installation",[803],"GitLab France Team","2024-12-04","Lancé en 1991 comme alternative à Minix, il adopte la licence GNU GPL en février 1992. Linux est aujourd’hui le système d'exploitation le plus utilisé pour la gestion des serveurs d'entreprise. Les serveurs Linux répondent aux besoins d'entreprises de toutes tailles, leur fournissant une plateforme performante et économique pour piloter de nombreuses applications informatiques. Qu'est-ce qu'un serveur Linux ? Quels en sont les avantages et les usages ? Comment installer un serveur Linux ? Voici l'essentiel à savoir pour lancer votre projet sous Linux.\n\n## Qu'est-ce qu'un serveur Linux ?\n\nUn serveur Linux est un serveur informatique opéré avec le système d'exploitation Linux. Linux fut créé en 1991 par le Finlandais Linus Torvalds, sous forme de noyau de système d'exploitation de type Unix. Trois décennies plus tard, il se conçoit aujourd'hui comme une suite cohérente de logiciels formant un __système d'exploitation entièrement opérationnel__, appelée une distribution Linux.  \n\nLes distributions GNU/Linux s'utilisent principalement pour gérer des fonctions informatiques côté serveur (backend). Nous pouvons citer l'hébergement Web, la gestion de réseau et le stockage de données. Linux est open source, ainsi les équipes opérationnelles peuvent télécharger gratuitement une distribution Linux et l'adapter à leurs besoins. Le système d'exploitation Linux est disponible sous différentes distributions GNU/Linux, telles que Debian, Ubuntu ou openSUSE offrant aux équipes de développement un surcroît de flexibilité et de personnalisation. \n\n## Quels sont les avantages d’un serveur Linux ?\n\nLe succès des serveurs Linux s'explique en grande partie par leur accessibilité et leur flexibilité. Mais le système d'exploitation Linux est aussi reconnu pour sa stabilité et sa sécurité, des critères cruciaux pour les infrastructures de serveurs d'entreprise. Certifié par la Free Software Fondation, Linux est un logiciel libre dont le code source est ouvert, ce qui facilite la correction des bogues et des failles de sécurité. \n\nSon __écosystème open source__ cimente aussi la popularité de Linux auprès des développeurs et des ingénieurs informatiques. Une communauté très active promeut GNU/Linux et favorise sa sécurisation et son développement. En résumé, gérer un serveur sous Linux comporte de nombreux avantages : \n\n- __Réduction des coûts.__ Vous pouvez télécharger, utiliser et modifier Linux sans frais de licence, ce qui permet de réaliser d'importantes économies sur les dépenses informatiques. De nombreuses applications compatibles avec Linux sont aussi disponibles gratuitement.\n- __Sécurité.__ Linux offre un niveau de protection avancé, avec un logiciel libre, des mises à jour régulières, des correctifs de sécurité rapidement publiés, et un soutien de la communauté des développeurs et développeuses.\n- __Scalabilité.__ Les serveurs Linux peuvent facilement évoluer en fonction des charges de travail et du nombre d'utilisateurs. Cette souplesse est appréciée par les entreprises en croissance, et idéale pour les [projets DevOps des PME](https://about.gitlab.com/fr-fr/small-business/ \"Projets DevOps des PME\").\n- __Flexibilité.__ Linux offre un degré de personnalisation poussé, les équipes de développement pouvant adapter le logiciel aux spécificités de leur architecture et de leurs applications. Ils disposent aussi d'un large choix parmi les nombreuses distributions GNU/Linux disponibles.\n\n## Comment utiliser un serveur Linux ?\n\nPar leur versatilité, les serveurs Linux se révèlent précieux pour un grand nombre d'usages informatiques. Ils excellent dans les applications d'entreprise les plus sensibles et les plus complexes. Voici quelques exemples d'utilisations fréquentes d'un serveur sous Linux : \n\n- __Hébergement Web__, qui nécessite de gérer de fortes charges de trafic. Des outils très performants dans ce domaine comme Apache et Nginx fonctionnent de façon optimale sous Linux.\n- __Administration système et réseau.__ Avec des commandes en ligne puissantes, des fonctionnalités avancées de routage et de contrôle du trafic intégrées dans le noyau, une maintenance simple et un fonctionnement stable et sobre en ressources, Linux est le système d'exploitation de choix des administrateurs réseau. \n- __Gestion de bases de données.__ Linux procure une robustesse et une scalabilité incomparables pour utiliser les solutions de gestion des données les plus performantes, comme PostgreSQL, MongoDB ou MariaDB. \n- __Cloud et virtualisation.__ Les serveurs Linux permettent de maximiser les performances des logiciels et des serveurs virtuels. Ils sont naturellement plébiscités pour les [applications cloud-native des entreprises](https://about.gitlab.com/fr-fr/topics/cloud-native/ \"Applications cloud-natives des entreprises\").  \n\nLe champ d'utilisation des serveurs sous Linux ne se limite pas à ces exemples. Analyse de données, jeux en ligne, transferts de fichier, business intelligence, messagerie… Les équipes choisissent souvent GNU/Linux pour des projets informatiques qui nécessitent un haut degré de contrôle et de sécurisation, et font appel à des applications avancées et exigeantes en ressources.\n\n### Conseils pour administrer un serveur Linux\n\nSi vous souhaitez tirer pleinement parti des capacités offertes par Linux, nous vous conseillons de suivre certaines bonnes pratiques dans l'administration d'un serveur Linux en entreprise. Pour assurer un démarrage réussi, il est essentiel de __former votre équipe IT__ aux commandes en ligne, aux configurations de sécurité et aux techniques de dépannage. Utilisez des __outils de surveillance__ compatibles avec Linux, tels que Prometheus, Nagios ou Zabbix, pour maintenir la fiabilité de votre infrastructure à long terme.\n\nLa __planification des sauvegardes__ est un autre point crucial pour assurer la viabilité de votre projet. Vous pouvez utiliser la règle du 3-2-1. Sauvegardez trois copies des données, stockez deux copies sur des supports différents, dont une sera placée hors site. Enfin, une bonne gestion de serveur Linux requiert une attention particulière aux __mesures de sécurité__. Nous recommandons la mise en place de clés SSH pour les mots de passe, de logiciels pare-feu et de détection des intrusions comme Fail2ban, et d'une authentification à deux facteurs.\n\n## Comment installer un serveur Linux ?\n\nProlongeons ce guide d'introduction sur une note plus pratique. Voici un tutoriel sur le serveur Linux qui vous accompagnera dans l'installation de ce logiciel en entreprise. Suivez les principales étapes pour installer un serveur Linux :\n\n1. Choisissez une __distribution Linux__ adaptée. Optez par exemple pour Ubuntu Server, connu pour sa facilité d'utilisation, ou Debian, réputé pour sa robustesse.\n2. Créez une __ISO bootable__ de la distribution Linux. Téléchargez-la sur le site officiel et placez-la sur une clé USB pour lancer l'installation sur le serveur.\n3. __Installez Linux__ à partir de la clé USB. Procédez à la configuration de base, à la partition du disque, à la configuration de l'utilisateur, au redémarrage et la première connexion.\n4. __Effectuez la configuration initiale__ du serveur Linux : sécurisez l’accès par SSH, créez un utilisateur non-root, configurez le pare-feu et mettez à jour le système.\n5. __Configurez le réseau.__ Choisissez une IP statique ou dynamique, configurez les DNS et la redirection des ports.\n\nEnfin, pour terminer l'installation du serveur Linux, veillez à parfaire la sécurisation du serveur avec installation d'un pare-feu, d'un certificat SSL et d'outils de surveillance du réseau. Une fois ces étapes terminées, votre serveur Linux est prêt à fonctionner. \n\n## Lancez un projet avec GitLab et Linux\n\nSi Linux a toujours dominé le secteur des serveurs d'entreprise, il connaît aussi un regain de popularité du côté du grand public. Au succès relatif des distributions adaptées aux utilisateurs sur PC, telles que Linux Mint et Ubuntu, s'ajoute l'essor des systèmes d'exploitation Android et Chrome OS pour mobiles et tablettes, qui sont basés sur le noyau Linux. Investir dans des applications fonctionnant sous Linux apparaît comme une stratégie gagnante à long terme, tant le succès de ce logiciel ne se dément pas.\n\nGitLab et Linux offrent un environnement idéal pour développer vos activités de façon agile et profiter de tous nos outils de collaboration. La plateforme GitLab prend en charge de nombreux paquets Linux officiels, tels que Debian, Ubuntu, AlmaLinux et CentOS 7. Rendez-vous sur notre page d'information pour [installer GitLab avec un serveur Linux](https://about.gitlab.com/fr-fr/install/#official-linux-package \"Installer GitLab avec un serveur Linux\") et mener à bien votre projet.\n\n## Installer une distribution Linux avec GitLab\n\n- [Paquet Ubuntu](https://about.gitlab.com/fr-fr/install/#ubuntu \"Paquet Ubuntu\")\n- [Paquet Debian](https://about.gitlab.com/fr-fr/install/#debian \"Paquet Debian\")\n- [Paque AlmaLinux](https://about.gitlab.com/fr-fr/install/#almalinux \"Paque AlmaLinux\")\n- [Paquet CentOS 7](https://about.gitlab.com/fr-fr/install/#centos-7 \"Paquet CentOS 7\")\n- [Paquet OpenSUSE Leap](https://about.gitlab.com/fr-fr/install/#opensuse-leap \"Paquet OpenSUSE Leap\")\n- [Paquet Amazon Linux 2](https://about.gitlab.com/fr-fr/install/#amazonlinux-2 \"Paquet Amazon Linux 2\")\n- [Paquet Raspberry Pi](https://about.gitlab.com/fr-fr/install/#raspberry-pi-os \"Paquet Raspberry Pi\")\n",[9,807],"open source",{"slug":809,"featured":6,"template":692},"introduction-guide-to-linux-servers","content:fr-fr:blog:introduction-guide-to-linux-servers.yml","Introduction Guide To Linux Servers","fr-fr/blog/introduction-guide-to-linux-servers.yml","fr-fr/blog/introduction-guide-to-linux-servers",{"_path":815,"_dir":247,"_draft":6,"_partial":6,"_locale":7,"seo":816,"content":822,"config":831,"_id":833,"_type":14,"title":834,"_source":16,"_file":835,"_stem":836,"_extension":19},"/fr-fr/blog/observability-vs-monitoring-in-devops",{"title":817,"description":818,"ogTitle":817,"ogDescription":818,"noIndex":6,"ogImage":819,"ogUrl":820,"ogSiteName":675,"ogType":676,"canonicalUrls":820,"schema":821},"DevOps : de la surveillance à l'observabilité","Vous souhaitez bénéficier d'une visibilité totale sur l'ensemble du cycle de développement de vos logiciels ? La réponse tient en un mot : l'observabilité.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749665484/Blog/Hero%20Images/monitoring-update-feature-image.jpg","https://about.gitlab.com/blog/observability-vs-monitoring-in-devops","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"DevOps : de la surveillance à l'observabilité\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Mike Vanbuskirk\"}],\n        \"datePublished\": \"2022-06-14\",\n      }",{"title":817,"description":818,"authors":823,"heroImage":819,"date":825,"body":826,"category":760,"tags":827,"updatedDate":830},[824],"Mike Vanbuskirk","2022-06-14","Presque toutes les infrastructures logicielles modernes comportent des fonctions de surveillance ou de journalisation. Lancé dans les années 1980, le protocole Syslog pour les systèmes Unix a constitué un premier exemple d'audit et d'analyse des opérations à l'intérieur d'un système. Il illustre l'importance d'un mécanisme de surveillance dédié et distinct sur le plan architectural.\n\nEn dépit de son importance, la surveillance (ou monitoring) est cependant trop souvent envisagée et utilisée après coup. Les informations des systèmes de journalisation ne sont pas agrégées ou analysées pour établir des diagnostics, tandis que les systèmes de surveillance installés des années auparavant ne sont pas mis aux normes.\n\nLe paysage opérationnel a cependant évolué, donnant naissance au concept d'observabilité. Plutôt que de former des hypothèses à partir de mesures statiques, l'observabilité apporte une vue d'ensemble du comportement d'une application, et permet de comprendre comment ses performances sont perçues par les utilisateurs et utilisatrices. \n\n## Qu’est-ce que l'observabilité ?\n\nL’observabilité est la collecte et l'analyse exhaustive des données de l'ensemble des composants d'un système informatique. Elle fournit des informations détaillées sur les applications de l'environnement, qui sont essentielles à la compréhension du fonctionnement des architectures dynamiques modernes, et notamment des plateformes dans le cloud. \n\nPour comprendre l’importance de l'observabilité, commençons par définir la notion de surveillance, ainsi que les informations que cette approche permet ou non de couvrir.\n\nLa surveillance consiste à mesurer certaines données et valeurs au sein d'un système ou d'un logiciel, et à en présenter les résultats. Les mesures les plus courantes sont l'utilisation d’un processeur, d’une mémoire vive, et des temps de réponse ou de latence. De même, les systèmes de journalisation classiques fournissent une information statique sur des événements survenus pendant le fonctionnement du système.\n\nLa surveillance fournit des mesures dans un contexte limité, pouvant indiquer un problème plus important dans le système. Les outils de surveillance traditionnels permettent d'agréger et de corréler les informations. Cependant, une configuration manuelle est souvent nécessaire afin d'obtenir une vue d'ensemble. \n\n### Observabilité ou monitoring\n\nAvec le temps, le concept de surveillance a dépassé les mesures statiques d'éléments tels que l'utilisation du processeur. Dans son célèbre ouvrage *Site Reliability Engineering*, Google souligne l'impératif de se concentrer sur quatre [Golden Signals (ou signaux d'or)](https://sre.google/sre-book/monitoring-distributed-systems/ \"Golden Signals de Google\") : \n- La latence : le temps nécessaire pour traiter une requête\n- Le trafic : la mesure du haut niveau de charge global\n- Les erreurs : le taux d'échec des requêtes\n- La saturation : la mesure de l'utilisation des ressources comme fraction de l'ensemble, consacrée généralement aux ressources limitées.\n\nBien que ces mesures aident à comprendre les performances globales du système, elles nécessitent encore un investissement technique tangible afin de concevoir, mettre en place et configurer un système de surveillance complet. L'énumération des modes de défaillance possible demande un effort considérable, tout comme la définition et l’association manuelle des corrélations, même pour des cas simples. \n\nEn revanche, l'observabilité offre une image beaucoup plus intuitive et complète, interopérable avec l'ensemble des modules du système. Ainsi, vous n'avez pas besoin de concevoir un tableau de bord agrégeant des outils de surveillance disparates. Une plateforme d'observabilité est suffisamment flexible pour présenter automatiquement les informations critiques dans le contexte adéquat. Les outils d'observabilité peuvent ainsi fournir aux équipes de développement un retour sur les performances des exécutions CI/CD et une information sur la qualité de leur code.\n\nEn fin de compte, l'observabilité informatique fournit une forme de débogage et de compréhension des erreurs plus globale. Les données d'observabilité d'un système peuvent mettre en évidence des incidents totalement nouveaux (*unknown unknowns*). Ce qui peut revêtir une importance capitale, comme le montre l'exemple fourni dans la section suivante.\n\n## Pourquoi privilégier l'observabilité ?\n\nL'observabilité aide à réduire le temps moyen de résolution (MTTR). Cela se traduit par des interruptions plus courtes, des applications plus performantes et une amélioration de l'expérience des utilisateurs. Si à première vue la surveillance peut sembler offrir les mêmes avantages, considérez l’anecdote suivante. \n\nUne équipe d'ingénieurs reçoit un message du service comptable. La facture des fournisseurs de service cloud est devenue si onéreuse que le directeur financier s'en est rendu compte. Les ingénieurs DevOps consultent le système de surveillance, mais en vain : chaque partie du système est au vert pour des éléments tels que la mémoire, le processeur et les entrées et sorties de disque. En réalité, la cause profonde provient d'un autre événement totalement inconnu. \n\nUne latence DNS dans les [pipelines CI/CD](https://docs.gitlab.com/ee/ci/pipelines/ \"Pipelines CI/CD de GitLab\") provoque un taux d'échec des compilations élevé, et les nouvelles tentatives consomment fortement les ressources cloud. Cependant, le phénomène ne perdure pas assez longtemps pour être repéré par le système de surveillance. En ajoutant des outils d'observabilité et en collectant tous les types d'événements dans l'environnement, l'équipe a pu enfin identifier la source du problème et y remédier. Avec un système de surveillance traditionnel, l'organisation aurait dû a priori connaître le problème de latence DNS pour pouvoir l'identifier.\n\nL'observabilité d'un système a également de l'importance pour les équipes non techniques et commerciales. La technologie étant de plus en plus prégnante au sein de chaque pilier d'activité d'un groupe, les indicateurs clés de performance de l'infrastructure logicielle se confondent avec ceux de l'entreprise. L'observabilité peut ainsi fournir une meilleure vision des indicateurs clés de performance, et des options utilisables en libre-service pour les différentes équipes.\n\nLa qualité de l'expérience utilisateur (UX) se doit d'être au cœur des logiciels et applications modernes. Comme l'illustre l'histoire précédente, la surveillance des mesures statiques ne suffit pas pour connaître l'ensemble des performances de l'expérience utilisateur ou du système. Des tableaux de bord apparemment sains peuvent cacher de graves problèmes. \n\n## Quelles sont les mesures clés de l'observabilité ?\n\nPour les entreprises qui souhaitent utiliser des outils d'observabilité, leur mise en œuvre passe par l'identification d’objectifs principaux de l'observabilité et de la manière dont elle peut être implémentée au sein de leur structure informatique.\n\nLes trois piliers de l'observabilité constituent un excellent point de départ :\n- Les journaux (ou logs) : le suivi des informations et des événements,\n- Les métriques : la mesure de métriques spécifiques et de données de performance,\n- Le traçage : l'enregistrement des performances des requêtes d'un bout à l'autre de leur exécution.\n\nS'ils ont pu paraître insurmontables au départ, des projets comme [OpenTelemetry](https://opentelemetry.io/ \"OpenTelemetry\") aident à standardiser les normes de journalisation, de métriques et de traçage, créant ainsi un écosystème plus cohérent et un retour sur investissement plus rapide pour les entreprises mettant en œuvre l'observabilité.\n\nDes données et des piliers supplémentaires pour l'observabilité incluent :\n\n- Le suivi des erreurs : des journaux à l'information plus fine et agrégée,\n- Le *Continuous Profiling* : l'évaluation de la performance du code en temps réel dans l'environnement de production\n- Le *Real User Monitoring (RUM)* : la surveillance de l'utilisateur réel pour comprendre les performances de l'application de son point de vue.\n\nUn thème commun émerge de l'examen de ces piliers. Un examen limité dans le temps et dans l'espace ne suffit plus. Les systèmes distribués modernes requièrent une vision globale. Pour comprendre les performances d'une application, il faut d’abord effectuer un échantillonnage au niveau du client réel, et effectuer ensuite une analyse complète de ses interactions avec l'ensemble des composants du logiciel.\n\nAu-delà de la surveillance traditionnelle des applications, l'observabilité contribue à améliorer l'excellence opérationnelle des équipes d'ingénierie. C'est souvent à partir de pannes réelles et des leçons que nous en tirons que nous concevons des programmes de surveillance efficaces. La mise en œuvre de l'ingénierie du chaos permet de tester les outils d'observabilité lors de défaillances réelles, mais dans un environnement contrôlé, avec des résultats connus à l'avance. Cette approche peut apporter des gains significatifs en termes d'équilibre opérationnel, dans des systèmes où des « inconnus inconnus » peuvent se cacher dans n'importe quel workflow de l'infrastructure IT. \n\n## L'observabilité, un élément essentiel de l’approche DevOps\n\nL'observabilité est essentielle pour les [équipes DevOps](https://about.gitlab.com/fr-fr/topics/devops/ \"DevOps\"), mais aussi pour l'ensemble de l'entreprise. En remplaçant les données statiques des solutions de surveillance traditionnelles, l'[observabilité](https://about.gitlab.com/blog/observability-is-key-to-cloud-native-transitions-and-modern-application-development/ \"Observabilité\") offre une vue complète de l'infrastructure applicative.\n\nLes équipes DevOps doivent collaborer avec toutes les parties prenantes pour améliorer la mise en œuvre de l'observabilité au sein de l'entreprise et s'assurer qu'elle profite à l'ensemble des équipes. Il est aussi important de former et de sensibiliser les équipes de développement aux avantages de l'observabilité.\n\nLes équipes DevOps peuvent également aider à identifier plus rapidement la cause première des incidents de production. Une bonne instrumentation du code des applications facilitera aussi la distinction entre problèmes de code et d'infrastructure. Enfin, en déplaçant l'observabilité plus en amont dans le cycle de conception logicielle, de possibles dévers dans les objectifs de niveau de service (SLO) peuvent être détectés plus tôt.\n\nLes équipes DevOps qui souhaitent améliorer significativement les performances des applications et les résultats de l'entreprise peuvent considérer l'observabilité comme un moyen d'atteindre ces deux objectifs.\n",[9,828,829],"security","performance","2024-08-20",{"slug":832,"featured":6,"template":692},"observability-vs-monitoring-in-devops","content:fr-fr:blog:observability-vs-monitoring-in-devops.yml","Observability Vs Monitoring In Devops","fr-fr/blog/observability-vs-monitoring-in-devops.yml","fr-fr/blog/observability-vs-monitoring-in-devops",{"_path":838,"_dir":247,"_draft":6,"_partial":6,"_locale":7,"seo":839,"content":845,"config":855,"_id":857,"_type":14,"title":858,"_source":16,"_file":859,"_stem":860,"_extension":19},"/fr-fr/blog/southwest-looking-to-help-developers-take-flight",{"ogTitle":840,"schema":841,"ogImage":842,"ogDescription":843,"ogSiteName":675,"noIndex":6,"ogType":676,"ogUrl":844,"title":840,"canonicalUrls":844,"description":843},"Southwest Airlines transforme son développement avec GitLab","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Comment Southwest Airlines transforme ses pratiques de développement logiciel avec GitLab\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Sharon Gaudin\"}],\n        \"datePublished\": \"2024-01-30\",\n      }\n                  ","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749665272/Blog/Hero%20Images/AdobeStock_380312133.jpg","Découvrez comment les équipes DevOps de la compagnie aérienne augmentent leur capacité à détecter et à résoudre les problèmes avec GitLab.","https://about.gitlab.com/blog/southwest-looking-to-help-developers-take-flight",{"title":840,"description":843,"authors":846,"heroImage":842,"date":848,"body":849,"category":850,"tags":851},[847],"Sharon Gaudin","2024-01-30","Southwest Airlines Co. met tout en œuvre pour faciliter le travail de ses équipes de développement.  \n\nLes responsables informatiques de la plus grande compagnie aérienne low-cost au monde s'emploient à éliminer les tâches chronophages et répétitives des workflows de leurs équipes. L'objectif vise à leur faire gagner un temps précieux pour qu'elles se consacrent à des projets à forte valeur ajoutée.\n\n*« Notre approche consiste à éliminer les obstacles qui ralentissent le travail de nos équipes »*, déclare Jim Dayton, Vice President et CISO de Southwest Airlines. *« Je suis fermement convaincu que la plupart des développeurs et développeuses choisissent ce métier pour sa part de créativité. Résoudre les problèmes est leur cheval de bataille. Nous souhaitons donc leur faciliter la tâche et supprimer les obstacles qui entravent leur productivité. »*\n\nPour faire de cette idée une réalité, Jim Dayton s'appuie notamment sur la plateforme [DevSecOps](https://about.gitlab.com/fr-fr/topics/devsecops/ \"Qu'est-ce que DevSecOps ?\") de GitLab.\n\nÀ l'occasion de son interview lors du [DevSecOps World Tour de GitLab](https://about.gitlab.com/events/devsecops-world-tour/) à Dallas, Jim Dayton a évoqué les efforts de Southwest Airlines pour soutenir ses équipes de développement et promouvoir leur travail. Lors de son échange avec Reshmi Krishna, Director of Enterprise Solutions Architecture chez GitLab, il a partagé ses réflexions sur les avantages des fonctionnalités d'intelligence artificielle pour enrichir le travail de ses équipes.\n\nSouthwest Airlines a adopté une [approche DevOps](https://about.gitlab.com/fr-fr/topics/devops/ \"Qu'est-ce que DevOps ? \") pour le développement d'applications offrant à ses équipes de développement davantage de fonctionnalités en libre-service et de processus de gestion des connaissances. *« Nous voulons permettre aux développeurs et développeuses d'identifier un problème dès qu'il survient, de trouver rapidement une solution et de limiter les interruptions causées par les changements de contexte »*, expose Jim Dayton. *« Il est essentiel de comprendre ce qui freine leur productivité. »*\n\nDepuis 2019, année où Southwest Airlines a entamé sa collaboration avec GitLab, l'entreprise s'est attachée à assurer la cohérence de ses processus de développement logiciel. Pour cela, elle a choisi de centraliser son code dans un dépôt GitLab partagé. En sachant précisément où l'ensemble du code est stocké, les équipes de développement peuvent évaluer plus facilement les indicateurs de performance et gagner en efficacité grâce à la réutilisation du code. \n\n*« Nous finalisons actuellement nos pipelines d'entreprise et la migration des équipes est imminente »*, annonce Jim Dayton. *« Nous collaborons étroitement avec nos nombreuses équipes de développement d'applications pour bien comprendre leurs attentes en matière de pipelines. La finalisation de ce projet est prévue pour la fin de l'année. »*\n\n### La promesse de l'IA\n\nL'utilisation de l'intelligence artificielle est un levier pour les équipes de développement. Elle leur permet notamment de se concentrer sur des tâches plus importantes et plus innovantes, comme le souligne Jim Dayton.\n\nL'IA générative, que ce soit sous la forme d'explications des vulnérabilités, de suggestions de code ou de complétion de code, a un impact considérable sur les workflows tout au long du cycle de vie du développement logiciel. L'intégration de l'IA dans une plateforme DevSecOps renforce la sécurité et réduit le temps consacré aux revues de code et au développement d'applications.\n\nJim Dayton se réjouit de pouvoir utiliser les fonctionnalités d'IA de GitLab pour accélérer et optimiser les processus de développement et de déploiement.\n\n*« Nous voulons éliminer autant que possible les tâches routinières et administratives »*, insiste Jim Dayton, qui considère que l'IA est extrêmement prometteuse, malgré ce que peut laisser penser le battage médiatique autour de cette technologie. *« L'IA nous aidera peut-être à atteindre cet objectif. Un jour, elle pourra sûrement fournir une solution immédiate à une vulnérabilité qui vient d'être identifiée ou expliquer à quoi sert une portion de code. Elle pourra aussi vous dire à quoi elle s'intègre, à quelles données elle accède et pourquoi. Elle pourra nous indiquer clairement, par exemple, qu'un bloc de code spécifique est responsable de 20 % des incidents survenus dans telle application l'année précédente. C'est en ce sens, je pense, que l'IA peut nous aider. »*, précise-t-il. \n\nJim Dayton estime que même si l'IA ne remplacera pas les équipes de développement, elle facilitera grandement leur travail et la communication entre les équipes, notamment dans un contexte où le télétravail s'est généralisé depuis la pandémie de COVID-19.\n\n*« La suggestion de relecteurs est une des fonctionnalités prévues dans la roadmap de [GitLab] »* mentionne Jim Dayton. *« Auparavant, pour obtenir de l'aide dans le cadre de revues de code, il suffisait de demander aux collègues qui partageaient votre bureau. Ce qui n'est plus aussi simple aujourd'hui. En revanche, l'IA peut désormais suggérer un relecteur ayant déjà contribué au code du projet ou résolu des incidents, et qui possède les compétences nécessaires. Ce qui apporte une réelle valeur ajoutée au processus de revue de code. Je pense que l'automatisation est la clé pour réduire le nombre d'étapes manuelles ou les délais d'attente. »*\n\n\u003C!-- blank line -->\n\u003Cfigure class=\"video_container\">\n  \u003Ciframe src=\"https://www.youtube.com/embed/UnUfp7pKnEQ?si=qcX2Qm3zpgQOV4xy\" frameborder=\"0\" allowfullscreen=\"true\"> \u003C/iframe>\n\u003C/figure>\n\u003C!-- blank line -->\n\n*Southwest Airlines est une société au chiffre d'affaires de près de 24 milliards de dollars basée à Dallas, au Texas. Avec 72 000 employés, elle dessert 120 destinations et effectue 4 000 vols par jour.  Southwest Airlines transporte plus de passagers via des vols nationaux que toute autre compagnie aérienne.*\n\nVous souhaitez en savoir plus sur GitLab ? Consultez nos [témoignages clients](https://about.gitlab.com/fr-fr/customers/).\n","customer-stories",[9,852,853,854],"DevOps platform","AI/ML","customers",{"slug":856,"featured":6,"template":692},"southwest-looking-to-help-developers-take-flight","content:fr-fr:blog:southwest-looking-to-help-developers-take-flight.yml","Southwest Looking To Help Developers Take Flight","fr-fr/blog/southwest-looking-to-help-developers-take-flight.yml","fr-fr/blog/southwest-looking-to-help-developers-take-flight",{"_path":862,"_dir":247,"_draft":6,"_partial":6,"_locale":7,"seo":863,"content":869,"config":878,"_id":880,"_type":14,"title":881,"_source":16,"_file":882,"_stem":883,"_extension":19},"/fr-fr/blog/tutorial-automated-release-and-release-notes-with-gitlab",{"ogTitle":864,"schema":865,"ogImage":866,"ogDescription":867,"ogSiteName":675,"noIndex":6,"ogType":676,"ogUrl":868,"title":864,"canonicalUrls":868,"description":867},"Automatisez vos sorties et notes de version avec GitLab","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Tutoriel : Automatisez vos sorties et notes de version avec GitLab\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Ben Ridley\"}],\n        \"datePublished\": \"2023-11-01\",\n      }","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749659978/Blog/Hero%20Images/automation.png","Découvrez comment automatiser vos livraisons de logiciels avec l'API Changelog de GitLab : créez des artefacts, changelogs complets et notes de version clairs.","https://about.gitlab.com/blog/tutorial-automated-release-and-release-notes-with-gitlab",{"heroImage":866,"body":870,"authors":871,"updatedDate":873,"date":874,"title":864,"tags":875,"description":867,"category":877},"**Mise à jour 2025** : l'API Changelog de GitLab continue d'évoluer et offre\ndésormais de nouvelles fonctionnalités avancées, telles que la génération de\nchangelogs personnalisés basés sur l'historique de vos commits. Ces\nnouveautés ne sont pas détaillées dans cet article, mais vous pouvez les\nconsulter dans notre[ documentation officielle dédiée aux\nchangelogs.](https://docs.gitlab.com/user/project/changelogs/)\n\n\nLorsque vous développez un logiciel dont les utilisateurs se servent au quotidien, il est essentiel de les informer des modifications apportées à chaque nouvelle version (nouvelles fonctionnalités, modifications ou suppressions). Ils peuvent ainsi tirer pleinement parti du logiciel et éviter les mauvaises surprises lors des mises à niveau.\n\n\nMais historiquement, rédiger les notes de version et maintenir un changelog ont toujours été des tâches laborieuses qui obligent les équipes et les Release Managers à passer au crible les modifications et l'historique des merge requests. Désormais, avec l'API Changelog de GitLab, vous pouvez tirer parti de l'historique détaillé des modifications enregistrées dans votre dépôt [Git](https://about.gitlab.com/fr-fr/blog/what-is-git/ \"Qu'est-ce que Git ?\") pour créer automatiquement des notes de version et tenir à jour votre changelog.\n\n\nDécouvrez dans ce tutoriel comment intégrer cette automatisation dans vos [pipelines CI/CD](https://about.gitlab.com/fr-fr/topics/ci-cd/cicd-pipeline/ \"Qu'est-ce qu'un pipeline CI/CD ?\").\n\n\n## Sorties de nouvelles versions dans GitLab\n\n\nDans GitLab, une nouvelle version correspond à une version spécifique de votre code, identifiée par un tag git. Elle regroupe les modifications apportées depuis la dernière version, les notes de version associées, ainsi que tous les artefacts générés à partir de cette version du code, tels que les images Docker, les paquets d'installation et la documentation.\n\n\nVous pouvez créer et suivre les sorties de ces nouvelles versions dans GitLab à l'aide de l'interface utilisateur en appelant notre API Release ou en définissant un job de `release` dans un pipeline CI. Nous utiliserons ce dernier dans ce tutoriel afin de bénéficier de l'automatisation déjà en place pour les tests, les scans du code et les autres étapes de validation, et d'automatiser également les sorties de nouvelles versions.\n\n\nNous devons d'abord disposer d'un historique clair de toutes les modifications apportées. C'est ce que fournit précisément le dépôt Git via les messages de commit et le suivi des merge requests. Ce dernier garantit une génération automatisée et fiable des notes de version et du changelog. \n\n\n## Lignes terminales dans un commit\n\n\nLes [lignes terminales dans un commit Git](https://git-scm.com/docs/git-interpret-trailers/fr) sont des métadonnées structurées ajoutées en fin de vos messages de commit, sous la forme simple `\u003CHEADER>:\u003CBODY>`. L'interface de ligne de commande `git` peut ensuite les analyser et les extraire pour les utiliser dans d'autres systèmes, par exemple via la commande `git commit --sign-off` qui permet de confirmer un commit en y ajoutant une ligne terminale `Signed-off-by: \u003CVotre nom>`. Vous pouvez y ajouter n'importe quelle information structurée. Il s'agit donc d'un emplacement idéal pour stocker des métadonnées, et dans notre exemple, pour générer automatiquement notre changelog.\n\n\nEn ajoutant la ligne terminale `Changelog: \u003Cadded/changed/removed>` à la fin de nos messages de commit, l'API Changelog de GitLab l'analysera et créera automatiquement un changelog.\n\n\nNous allons illustrer ce mécanisme en apportant quelques modifications à un code source existant afin de sortir une nouvelle version et de générer automatiquement ses notes de version et les entrées du changelog correspondant.\n\n\n## Exemple concret avec une application Python\n\n\nPartons d'un dépôt contenant une application web simple écrite en Python. Supposons que la version 1.0.0 de cette application vient de sortir et représente l'état actuel du code, et qu'elle a été créée manuellement dans GitLab, sans pipeline de sortie de nouvelle version automatisé :\n\n\n![Capture d'écran de l'interface utilisateur de GitLab montrant la sortie de la nouvelle version 1.0.0](https://about.gitlab.com/images/blogimages/2023-08-22-automated-release-and-release-notes-with-gitlab/1-0-release.png)\n\n\n## Modifications en vue de la version 2.0.0\n\n\nComme nous sommes en mode de développement rapide, nous allons travailler sur la sortie de la version 2.0.0 de notre application dès aujourd'hui. Celle-ci introduira une fonctionnalité de chatbot et supprimera la fonctionnalité de blockchain quantique, qui servait uniquement à impressionner les investisseurs lors de notre premier cycle de financement par capital-risque. Nous allons également ajouter un job de sortie de nouvelle version automatisé à notre pipeline CI/CD.\n\n\nTout d'abord, nous devons supprimer les fonctionnalités obsolètes à l'aide d'une merge request qui contient les suppressions nécessaires en veillant à ce que le message de commit inclue la ligne terminale `Changelog: removed`. Pour cela, nous pouvons par exemple l'inclure directement dans un commit, ou effectuer un [rebasage interactif](https://about.gitlab.com/fr-fr/blog/keep-git-history-clean-with-interactive-rebase/ \"Qu'est-ce que le rebasage interactif ?\") et l'ajouter à l'aide de l'interface de ligne de commande (CLI). \n\n\nMais dans notre exemple, nous traiterons cette étape en dernier, et utiliserons plutôt le bouton `Modifier le message de commit` dans GitLab pour ajouter la ligne terminale au commit comme suit :\n\n\n![Capture d'écran de l'interface utilisateur de GitLab montrant une merge request supprimant les fonctionnalités inutilisées](https://about.gitlab.com/images/blogimages/2023-08-22-automated-release-and-release-notes-with-gitlab/remove-unused-features-mr.png)\n\n\nVous pouvez également modifier le titre du commit pour qu'il soit plus concis. Nous allons donc renommer notre commit « Supprimer les fonctionnalités inutilisées », pour que ce titre apparaisse dans le changelog.\n\n\nEnsuite, ajoutons de nouvelles fonctionnalités pour la version 2.0.0. Là encore, il suffit d'ouvrir une autre merge request qui inclut nos nouvelles fonctionnalités, de modifier le commit pour inclure la ligne terminale `Changelog: added`, puis de modifier son titre pour qu'il soit plus concis :\n\n\n![Capture d'écran de l'interface utilisateur de GitLab montrant une merge request servant à ajouter de nouvelles fonctionnalités](https://about.gitlab.com/images/blogimages/2023-08-22-automated-release-and-release-notes-with-gitlab/add-chatbot-mr.png)\n\n\nNous sommes maintenant prêts à publier la version 2.0.0. Mais cette fois-ci, au lieu de la créer manuellement, nous allons ajouter les jobs nécessaires à notre fichier `.gitlab-ci.yml` : ils gèreront automatiquement la sortie de la nouvelle version à notre place et généreront les notes de version et les entrées du changelog lorsque nous ajouterons à notre code le tag `2.0.0` en référence à la nouvelle version.\n\n\n**Remarque :** pour ajouter facilement des lignes terminales de changelog, utilisez un outil comme [Danger, qui permet de vérifier automatiquement le respect des conventions dans les merge requests](https://docs.gitlab.com/ee/development/dangerbot.html).\n\n\n## Création d'un pipeline automatisé de sortie de nouvelle version\n\n\nLa première étape consiste à créer un token d'accès au projet qui nous permettra d'appeler l'API de GitLab afin de générer les entrées de notre changelog. [Créons un token d'accès au projet avec la portée de l'API](https://docs.gitlab.com/ee/user/project/settings/project_access_tokens.html#create-a-project-access-token), puis [stockons-le dans les variables CI/CD](https://docs.gitlab.com/ee/ci/variables/#define-a-cicd-variable-in-the-ui) du projet sous le nom `CI_API_JETON`. Nous référencerons cette variable à des fins d'authentification auprès de l'API.\n\n\nEnsuite, ajoutons deux nouveaux jobs à notre fichier `gitlab-ci.yml` :\n\n\n```yaml\n\nprepare_job:\n  stage: prepare\n  image: alpine:latest\n  rules:\n  - if: '$CI_COMMIT_TAG =~ /^v?\\d+\\.\\d+\\.\\d+$/'\n  script:\n    - apk add curl jq\n    - 'curl -H \"PRIVATE-TOKEN: $CI_API_TOKEN\" \"$CI_API_V4_URL/projects/$CI_PROJECT_ID/repository/changelog?version=$CI_COMMIT_TAG\" | jq -r .notes > release_notes.md'\n  artifacts:\n    paths:\n    - release_notes.md\n\nrelease_job:\n  stage: release\n  image: registry.gitlab.com/gitlab-org/release-cli:latest\n  needs:\n    - job: prepare_job\n      artifacts: true\n  rules:\n  - if: '$CI_COMMIT_TAG =~ /^v?\\d+\\.\\d+\\.\\d+$/'\n  script:\n    - echo \"Creating release\"\n  release:\n    name: 'Release $CI_COMMIT_TAG'\n    description: release_notes.md\n    tag_name: '$CI_COMMIT_TAG'\n    ref: '$CI_COMMIT_SHA'\n    assets:\n      links:\n        - name: 'Container Image $CI_COMMIT_TAG'\n          url: \"https://$CI_REGISTRE_IMAGE/$CI_COMMIT_REF_SLUG:$CI_COMMIT_SHA\"\n```\n\n\nDans notre configuration, le job `prepare_job` utilise `curl` et `jq` pour appeler le point de terminaison de l'API Changelog de GitLab, puis transmet le résultat à notre job `release_job` chargé de créer automatiquement la nouvelle version. \n\n\nVoici les principaux éléments à retenir :\n\n\n* Nous utilisons le token d'accès au projet créé précédemment pour appeler l'API Changelog de GitLab, qui génère les notes de version que nous stockons en tant qu'artefact.\n\n* Nous utilisons la variable `$CI_COMMIT_TAG` pour identifier la version. Pour que l'API Changelog fonctionne correctement, nous devons utiliser la gestion sémantique de version pour nos tags (par exemple, `2.0.0`). Nous avons également restreint le job de sortie de nouvelle version à l'aide d'une règle spécifique dans la section `rules`, qui vérifie la présence d'un tag de version sémantique.\n\n  * La gestion sémantique de version est nécessaire pour que l'API Changelog de GitLab déclenche le job. Elle utilise ce format pour trouver la version la plus récente à comparer à notre version actuelle.\n* Nous utilisons l'image `release-cli` officielle de GitLab, indispensable pour exploiter le terme `release` dans un job.\n\n* Nous utilisons le terme `release` pour créer une sortie de nouvelle version dans GitLab et pour le remplissage des champs obligatoires.\n\n* Nous pouvons transmettre un fichier en tant qu'argument pour la `description` de la nouvelle version. Dans notre exemple, il s'agit du fichier que nous avons généré lors du job `prepare_job`, puis transmis à ce job sous forme d'artefact.\n\n* Nous avons également inclus notre image de conteneur, qui a été compilée plus tôt dans le pipeline, en tant que ressource associée à la nouvelle version. Vous pouvez également y joindre les ressources de votre choix, générées lors de votre processus de compilation, telles que des binaires ou de la documentation, à condition de fournir l'URL redirigeant vers l'endroit où vous les avez chargés plus tôt dans le pipeline.\n\n\n## Automatisation d'une sortie de nouvelle version\n\n\nAvec cette configuration, il suffit d'effectuer le push d'un tag respectant notre schéma de gestion des versions vers notre dépôt à l'aide de la CLI ou comme dans notre exemple, directement depuis l'interface utilisateur de GitLab, sur la branche principale, en sélectionnant Code -> Tags -> Nouveau tag dans la barre latérale :\n\n![Capture d'écran de l'interface utilisateur de GitLab montrant comment créer un tag](https://about.gitlab.com/images/blogimages/2023-08-22-automated-release-and-release-notes-with-gitlab/create-2-tag.png)\n\n\nDès la création du tag, nos pipelines commenceront à s'exécuter automatiquement. L'API Changelog de GitLab génère alors des notes de version au format markdown contenant toutes les modifications apportées entre cette version et la version précédente. \n\n\nVoici un extrait du markdown généré dans notre exemple :\n\n\n```md\n\n## 2.0.0 (2023-08-25)\n\n\n### added (1 change)\n\n\n- [Add ChatBot](gl-demo-ultimate-bridley/super-devsecops-incorporated/simply-notes-release-demo@0c3601a45af617c5481322bfce4d71db1f911b02) ([merge request](gl-demo-ultimate-bridley/super-devsecops-incorporated/simply-notes-release-demo!4))\n\n\n### removed (1 change)\n\n\n- [Remove Unused Features](gl-demo-ultimate-bridley/super-devsecops-incorporated/simply-notes-release-demo@463d453c5ae0f4fc611ea969e5442e3298bf0d8a) ([merge request](gl-demo-ultimate-bridley/super-devsecops-incorporated/simply-notes-release-demo!3))\n\n```\n\n\nComme vous pouvez le constater, GitLab a extrait automatiquement les entrées de nos notes de version à l'aide des lignes terminales que nous avons intégrées dans nos messages de commit Git. De plus, des notes incluent des liens vers la merge request associée pour accéder rapidement aux compléments d'information et discussions relatifs aux modifications.\n\n\nVoici notre nouvelle version 2.0.0 :\n\n![Interface utilisateur de la nouvelle version de GitLab montrant la nouvelle version 2.0.0](https://about.gitlab.com/images/blogimages/2023-08-22-automated-release-and-release-notes-with-gitlab/2-0-release.png)\n\n\n## Automatisation de la mise à jour du changelog\n\n\nPour maintenir à jour votre changelog (soit l'historique rassemblant toutes vos notes de version), vous pouvez effectuer une requête `POST` vers le point de terminaison de l'API Changelog utilisé précédemment.\n\n\nSi vous effectuez cette opération dans le cadre de votre pipeline de nouvelle version, intégrez cette étape en ajoutant ce qui suit à la section `script` de votre job de préparation :\n\n\n```sh\n\n'curl -H \"PRIVATE-TOKEN: $CI_API_TOKEN\" -X POST \"$CI_API_V4_URL/projects/$CI_PROJECT_ID/repository/changelog?version=$CI_COMMIT_TAG\"\n\n```\n\n\n**Notez que cette opération modifie le dépôt** en créant un commit qui ajoute les notes de la nouvelle version à un fichier `CHANGELOG.md` :\n\n![Capture d'écran du dépôt montrant une validation mettant à jour le fichier changelog](https://about.gitlab.com/images/blogimages/2023-08-22-automated-release-and-release-notes-with-gitlab/changelog-api-commit.png)\n\n\nEt voilà, nous avons terminé ! En utilisant l'historique détaillé fourni par `git` avec quelques lignes terminales de commit pratiques, nous pouvons tirer parti de la puissante de l'API et des pipelines CI/CD de GitLab pour automatiser notre processus de sortie de nouvelle version et de génération de notes de version.\n\n\n> Pour découvrir le projet utilisé dans ce tutoriel, [consultez ce lien](https://gitlab.com/gitlab-learn-labs/sample-projects/release-automation-demo).\n",[872],"Ben Ridley","2025-07-09","2023-11-01",[783,109,9,739,876],"git","product",{"slug":879,"featured":6,"template":692},"tutorial-automated-release-and-release-notes-with-gitlab","content:fr-fr:blog:tutorial-automated-release-and-release-notes-with-gitlab.yml","Tutorial Automated Release And Release Notes With Gitlab","fr-fr/blog/tutorial-automated-release-and-release-notes-with-gitlab.yml","fr-fr/blog/tutorial-automated-release-and-release-notes-with-gitlab",{"_path":885,"_dir":247,"_draft":6,"_partial":6,"_locale":7,"seo":886,"content":892,"config":899,"_id":901,"_type":14,"title":902,"_source":16,"_file":903,"_stem":904,"_extension":19},"/fr-fr/blog/what-are-the-benefits-of-a-microservices-architecture",{"title":887,"description":888,"ogTitle":887,"ogDescription":888,"noIndex":6,"ogImage":889,"ogUrl":890,"ogSiteName":675,"ogType":676,"canonicalUrls":890,"schema":891},"Architecture de microservices : définition, avantages et bonnes pratiques","Une architecture de microservices permet de moderniser votre approche informatique. Découvrez ses avantages et les bonnes pratiques pour démarrer.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749662898/Blog/Hero%20Images/microservices-explosion.jpg","https://about.gitlab.com/blog/what-are-the-benefits-of-a-microservices-architecture","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Architecture de microservices : définition, avantages et bonnes pratiques\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"GitLab\"}],\n        \"datePublished\": \"2022-09-29\",\n      }",{"title":887,"description":888,"authors":893,"heroImage":889,"date":894,"body":895,"category":710,"tags":896,"updatedDate":898},[707],"2022-09-29","Vous n'avez pas encore d'avis tranché sur les architectures de microservices et sur ce qu'elles peuvent apporter à vos équipes ? Les équipes de développement sont pourtant de plus en plus nombreuses à adopter cette approche pour développer de nouveaux logiciels. Leur objectif ? Profiter de la flexibilité des microservices pour travailler et livrer des logiciels de façon toujours plus agile. Voici ce que vous devez savoir sur les architectures de microservices, et comment vous lancer.\n\n__Sommaire__\n- Architecture de microservices : définition\n- Quels sont les avantages d’une architecture de microservices ?\n- Quels sont les inconvénients d’une architecture de microservices ?\n- Comment construire une architecture de microservices ?\n- Architecture de microservices et DevOps\n\n## Architecture de microservices : définition\n\nUne architecture de microservices est une approche dans laquelle une application est divisée en petits services autonomes, appelés [microservices](https://about.gitlab.com/fr-fr/topics/microservices/ \"Qu'est-ce qu'un microservice ? \"). \n\n### Qu’est-ce qu’un microservice ?\n\nUn microservice est un service qui __exécute un processus unique__ et qui gère sa propre base de données, tout en interagissant avec les autres. Ce qui permet aux équipes de développement de bénéficier d’une meilleure agilité pour développer, mettre à jour ou tester de nouvelles fonctionnalités plus rapidement. \n\n![Microservices vs monolithique](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749687528/Blog/Content%20Images/monolith-vs-microservices.png)\n\n> [Essayez GitLab Ultimate gratuitement.](https://gitlab.com/-/trial_registrations/new?glm_source=about.gitlab.com/blog&glm_content=default-saas-trial \"Essai gratuit de GitLab. \") \n\n## Quels sont les avantages d’une architecture de microservices ?\n\n### Des applications plus évolutives\n\nComme les microservices fonctionnent de manière indépendante, chaque microservice peut donc être facilement ajouté, supprimé, ou mis à jour, sans perturber le fonctionnement des autres microservices. Les entreprises peuvent aussi les faire évoluer en fonction de leurs besoins. Cela permet par exemple d'allouer plus de ressources à un microservice lors d'un pic d'achat saisonnier, et de les économiser en basse saison, pour les réallouer à d'autres domaines. \n\n### Une meilleure isolation des pannes\n\nToute architecture monolithique est susceptible de s'effondrer en cas de défaillance d'un seul élément de l’architecture. Ce risque est moins élevé dans le cas d’une architecture de microservices, où chaque service fonctionne de manière indépendante. Si l'un d'entre eux échoue, il est beaucoup moins probable que les autres cessent de fonctionner. Il faut cependant garder en tête que de grands volumes de trafic peuvent toujours submerger une application.\n\nAvec une architecture de microservices, les équipes de développement peuvent limiter les risques de défaillances en cascade. Divers outils sont disponibles, notamment sur [GitLab](https://about.gitlab.com/fr-fr/ \"Plateforme DevSecOps de GitLab\"), pour créer des microservices résistants aux pannes, et améliorer la résilience de l'infrastructure.\n\n### Une compatibilité avec tous les langages de programmation et toutes les technologies\n\nUne application de microservices peut être programmée dans n'importe quel langage. Les équipes de développement peuvent ainsi choisir le langage de programmation le plus adapté à leur projet et utiliser au mieux leurs compétences, sans avoir besoin d’apprendre un nouveau langage de programmation. En outre, l'utilisation de microservices basés sur le cloud permet aux équipes d'accéder à une application à partir de n'importe quel appareil connecté à Internet, quelle que soit sa plateforme.\n\n### Un déploiement simplifié\n\nUne architecture de microservices permet aux équipes de __déployer des applications indépendantes__ sans affecter les autres services de l'architecture. Cet avantage donne la possibilité aux équipes d'ajouter de nouveaux modules, sans devoir repenser la structure complète du système. L'architecture de microservices permet donc aux entreprises d'intégrer efficacement de nouvelles fonctionnalités en fonction de leurs besoins. \n\n### Une mise sur le marché plus rapide\n\nCette approche permet de minimiser les conflits de langage et les interruptions de service en chaîne sur un site web. Les équipes de développement travaillant sur différents microservices n'ont pas besoin d'attendre que les autres aient terminé pour avancer sur leurs tâches. De cette manière, les entreprises peuvent développer et déployer de nouvelles fonctionnalités rapidement et mettre à niveau les anciens composants au fur et à mesure des avancées technologiques.\n\n### Une expérimentation facilité \n\nUne architecture de microservices facilite les expérimentations. Comme chaque service fonctionne indépendamment, il est plus facile de tester et de déployer de nouvelles fonctionnalités sur l'un d’entre eux, sans impacter l’ensemble de l’application. Ainsi, les architectures de microservices permettent de gagner un temps précieux pour faire évoluer progressivement une application.\n\n### Une sécurité des données renforcée\n\nUne architecture de microservices se définit aussi par une sécurité renforcée. Lorsque l'architecture des systèmes informatiques est divisée en éléments plus petits, les données sensibles sont mieux protégées contre les intrusions provenant d’autres zones. Les équipes de développement peuvent utiliser des __API sécurisées__ pour connecter les microservices entre eux. Les API sécurisées protègent les données en veillant à ce qu’elles ne soient accessibles qu’aux utilisateurs, applications et serveurs spécifiquement autorisés. Les entreprises peuvent ainsi plus aisément se conformer aux normes de sécurité des données, telles que le [Règlement général sur la protection des données (RGPD)](https://www.cnil.fr/fr/reglement-europeen-protection-donnees \"Règlement général sur la protection des données \"). \n\n### Une flexibilité de l’externalisation\n\nLes entreprises doivent parfois confier certaines fonctionnalités à des partenaires tiers, ce qui peut représenter un __risque pour la protection de la propriété intellectuelle__. Avec une architecture de microservices, ces dernières peuvent segmenter les zones réservées aux partenaires, sans compromettre les services principaux et les données sensibles. \n\n### Une optimisation des équipes\n\nAmazon, pionnier des microservices, avait instauré l'idée qu'une équipe chargée d'une application ne devrait pas compter plus d'une poignée de développeurs et de développeuses en son sein. Les experts expliquent que cette approche améliore l'efficacité du travail, permet aux entreprises d’__atteindre leurs objectifs plus rapidement__, facilite la gestion des équipes, et favorise une plus grande concentration au sein du groupe. Adopter une architecture de microservices au moment de dimensionner vos équipes vous aidera à livrer des logiciels de meilleure qualité.\n\n### Un moyen d’attirer de nouveaux talents\n\nLes microservices s'appuient sur les pratiques d'ingénierie et les outils de développement les plus récents. L’occasion pour les entreprises d’attirer de nouveaux talents souhaitant travailler sur ce type d’architecture. \n\n## Quels sont les inconvénients d’une architecture de microservices ?\n\nSi les microservices présentent un grand nombre d'avantages, il faut aussi tenir compte de certains inconvénients avant d’adopter cette approche. \n\n### Des coûts initiaux plus élevés\n\nLes microservices cloud permettent de faire des économies sur le long terme, mais les coûts associés à leur déploiement initial restent élevés. Une entreprise doit disposer d'une infrastructure d'hébergement suffisante, avec une assistance en matière de sécurité et de maintenance. Plus important encore, elle aura besoin d'équipes qualifiées pour gérer tous les services.\n\n### L’importance du contrôle de l’interface\n\nComme chaque microservice possède sa propre API, toute application utilisant ce service sera affectée si vous modifiez l’API. Ce changement __n'étant pas rétrocompatible__. Avec une architecture de microservices, les opérations de grande envergure font appel à des centaines, voire des milliers d'API. Le contrôle de ces interfaces est donc essentiel au bon fonctionnement de l'entreprise, ce qui constitue un challenge possible pour adopter ce type d’architecture.\n\n### Autres types de complexité\n\nLe débogage peut s'avérer plus complexe avec une architecture de microservices, car chaque microservice dispose de son propre ensemble de journaux (logs). Ce qui peut compliquer légèrement la recherche pour remonter à la source d'un problème dans le code. \n\n### Des tests d'intégration\n\nLes tests unitaires sont plus faciles à gérer avec une architecture de microservices, ce qui n’est pas le cas des tests d'intégration. Comme l'architecture de microservices est distribuée en différents microservices, les équipes de développement ne peuvent pas tester l'ensemble du système depuis leur ordinateur.\n\n## Une architecture orientée services (AOS) vs microservices\n\nSi vous travaillez dans le cloud computing, vous avez probablement entendu parler du débat entre les architectures orientées services (Service-Oriented Architecture ou SOA en anglais) et les architectures de microservices. Ces deux architectures sont similaires à bien des égards, car elles impliquent toutes deux le cloud computing, le développement agile, et divisent les grands composants monolithiques en unités plus petites et plus faciles à gérer. \n\nCependant, la plus grande différence entre ces deux architectures réside dans leur champ d’application. L’AOS est une approche à l'échelle de l’entreprise pour développer des composants logiciels. Les microservices, quant à eux, construisent des applications autonomes qui remplissent une fonction spécifique. Cette approche cloud-native du développement et du déploiement les rend plus évolutifs, agiles et résistants. Les architectures de microservices se situent donc à une échelle plus restreinte, celle des applications.\n\n## Comment construire une architecture de microservices ?\n\nPour les équipes [DevOps](https://about.gitlab.com/fr-fr/topics/devops/ \"Que signifie DevOps ?\") prêtes à franchir une nouvelle étape, l'adoption d'une architecture de microservices est un choix judicieux. Voici comment vous lancer. \n\n### Identifier les aspects décomposables de l'application\n\nL’une des principales caractéristiques d’un microservice est son fonctionnement autonome. Il faut donc commencer par identifier quelles parties de l'application peuvent fonctionner de manière indépendante. Une définition erronée des limites d'un service pourrait entraîner des modifications indésirables sur d’autres services. Vous devez donc envisager le système dans sa globalité.\n\nDans de nombreux cas, cette répartition correspond aux domaines d'activité, et se reflète dans l'organisation des équipes de développement.\n\n### Définir les indicateurs à surveiller\n\nAvec une application de microservices, il faut impérativement surveiller l'état de chaque service pour pouvoir réagir à l'évolution des demandes dans l’environnement de production. Parmi les indicateurs courants à surveiller, nous retrouvons : l'utilisation du processeur, le niveau de mémoire de chaque instance, le temps de réponse de l'API ou encore le taux d'erreur. \n\nEn l'absence de surveillance, les équipes peuvent ne pas détecter certains problèmes lorsqu’ils surviennent. Par exemple, lorsqu'un serveur fait face à un pic de trafic, d'autres services peuvent ne pas répondre, car ils essaient de communiquer avec un service surchargé.\n\nEn détectant ces problèmes potentiels au sein de votre architecture de microservices, vous prévenez ainsi les temps d'arrêt. Ces indicateurs doivent être définis au début du projet pour pouvoir être surveillés et faire l’objet d’ajustements en cas d'événement anormal détecté. Cela peut s'avérer difficile, mais il existe heureusement des outils qui simplifient la surveillance, et fournissent une visualisation complète.\n\n### Automatiser l'infrastructure\n\nLorsque le nombre de microservices augmente, une application peut devenir difficile à gérer, puisque chaque microservice a son propre calendrier de déploiement. Certaines fonctionnalités sont cachées derrière des feature flags, d'autres collectent des données d’utilisation via des tests A/B, et certains services utilisent des déploiements Canary dans le cadre d’un déploiement progressif. Il est donc essentiel d'automatiser les tests pour que les équipes puissent stopper ou annuler un déploiement si nécessaire.\n\n### Créer des tests de contrat axés sur le consommateur\n\nIl est recommandé de mettre en œuvre des tests de contrat axés sur le consommateur (Consumer-Driven Contract Tests, ou CDCT) pour garantir la compatibilité entre les versions. Traditionnellement, les équipes de développement créent d'abord les API côté serveur, le point d'entrée du test étant déterminé par les clients. Cela signifie que lorsque la signature d’un API change, cela peut entraîner des dysfonctionnements côté consommateur. \n\nAvec les tests de contrat axés sur le consommateur cette situation ne peut pas se produire, car avant de déployer un microservice en production, les consommateurs déterminent le contrat requis (la signature de l’API) et effectuent des tests pour s’assurer qu’ils sont toujours valides. \n\n## Architecture de microservices et DevOps\n\nEn décomposant un système logiciel en parties autonomes, l'architecture de microservices permet aux entreprises d'appliquer le principe de responsabilité unique (Single Responsibility Principle) aux équipes de développement.\n\nTous les aspects d'un service peuvent ainsi se gérer de façon indépendante : la stack technique de l'équipe, la composition de l'équipe, les stratégies de déploiement, et même les calendriers de release. \n\nAssociée à une livraison continue, l’architecture de microservices permet aux entreprises de prendre des décisions basées sur des données de production en temps réel, accélérant ainsi les boucles de rétroaction et réduisant le délai de mise sur le marché.\n\nVotre équipe est-elle prête à se lancer dans l'architecture de microservices ? Commencez par développer une compréhension fine du découpage possible de votre système, et acquérir de solides connaissances sur les pratiques [CI/CD](https://about.gitlab.com/fr-fr/topics/ci-cd/ \"Qu'est-ce que le CI/CD ?\"). Ces compétences vous seront d'ailleurs utiles quelle que soit l'approche architecturale que vous choisirez.\n\n> [Essayez GitLab Ultimate gratuitement.](https://gitlab.com/-/trial_registrations/new?glm_source=about.gitlab.com/blog&glm_content=default-saas-trial \"Essai gratuit de GitLab. \")\n",[9,9,897],"features","2024-10-01",{"slug":900,"featured":91,"template":692},"what-are-the-benefits-of-a-microservices-architecture","content:fr-fr:blog:what-are-the-benefits-of-a-microservices-architecture.yml","What Are The Benefits Of A Microservices Architecture","fr-fr/blog/what-are-the-benefits-of-a-microservices-architecture.yml","fr-fr/blog/what-are-the-benefits-of-a-microservices-architecture",{"_path":906,"_dir":247,"_draft":6,"_partial":6,"_locale":7,"seo":907,"content":913,"config":919,"_id":921,"_type":14,"title":922,"_source":16,"_file":923,"_stem":924,"_extension":19},"/fr-fr/blog/what-is-open-source",{"title":908,"description":909,"ogTitle":908,"ogDescription":909,"noIndex":6,"ogImage":910,"ogUrl":911,"ogSiteName":675,"ogType":676,"canonicalUrls":911,"schema":912},"Open source : définition, avantages et défis","Qu'est-ce que l'open source ? Apprenez comment ce modèle collaboratif transforme le développement logiciel grâce au libre accès et au partage du code.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749662973/Blog/Hero%20Images/open-source-definition.jpg","https://about.gitlab.com/blog/what-is-open-source","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Open source : définition, avantages et défis\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"GitLab France Team\"}],\n        \"datePublished\": \"2025-04-16\",\n      }",{"title":908,"description":909,"authors":914,"heroImage":910,"date":915,"body":916,"category":917,"tags":918},[803],"2025-04-16","Basé sur des principes fondamentaux tels que l'ouverture, le partage des connaissances et l'amélioration continue, l'open source révolutionne le monde du développement logiciel. En réunissant des développeurs du monde entier, l'open source crée un environnement propice à l'innovation, où les idées et les solutions émergent grâce à la diversité des contributions. \n\nDécouvrez dans cet article les principes fondamentaux du développement [open source](https://about.gitlab.com/fr-fr/solutions/open-source/ \"Solutions GitLab pour les projets open source\"). \n\n## Qu’est-ce que l’open source ? \n\nL'open source est un modèle de développement fondé sur la transparence et la collaboration. Contrairement aux logiciels propriétaires, où seul le détenteur des droits peut modifier le code source ou redistribuer le produit, l'open source rend ce code accessible à tous. Les développeurs du monde entier peuvent ainsi l'examiner, l'améliorer et le partager librement, favorisant l'innovation et le progrès collectif.\n\n> [\nEssayez GitLab Ultimate gratuitement](https://about.gitlab.com/fr-fr/free-trial/devsecops/ \"Essai gratuit de GitLab Ultimate\") et commencez à développer des logiciels open source dès aujourd'hui.\n\n## Quels sont les avantages de l'open source ?\n\nBien plus qu'une alternative technologique, l'open source est un modèle offrant de nombreux avantages. Réduction des coûts, accélération de l'innovation, meilleure sécurité des logiciels, ou encore personnalisation, sont autant d'atouts qui peuvent transformer les projets et stimuler la croissance des entreprises.\n\n### Des coûts réduits \n\nÀ l'opposé des solutions propriétaires parfois onéreuses, les logiciels open source se distinguent souvent par leur faible coût, vous dispensant des dépenses traditionnellement associées aux licences et au support technique. Chez GitLab par exemple, les utilisateurs ont la possibilité d’utiliser gratuitement [GitLab Community Edition (CE)](https://about.gitlab.com/fr-fr/install/ce-or-ee/ \"GitLab Community Edition (CE)\") qui est open source. \n\n### Une meilleure transparence\n\nL'accès au code source permet à qui le souhaite d'examiner, de modifier et d'améliorer les logiciels. Pour les développeurs, cette transparence facilite leur compréhension des logiciels, de la manière dont ils sont construits et des failles de sécurité potentielles qu'ils peuvent contenir. Par exemple, le code source de GitLab est disponible publiquement sur GitLab.com et offre aux utilisateurs l'opportunité d’inspecter le code, de comprendre son fonctionnement et même de contribuer activement à son développement.  \n\n### Des logiciels personnalisables \n\nL'open source offre aux entreprises la possibilité d'adapter leurs logiciels à leurs besoins spécifiques, là où les solutions propriétaires limitent souvent cette liberté. Grâce à leur nature modulable, les logiciels open source permettent d'optimiser l'efficacité opérationnelle en s'adaptant précisément aux besoins des entreprises. GitLab illustre cette flexibilité en offrant à tous la possibilité de contribuer de façon traditionnelle, et en offrant également aux entreprises la possibilité de développer des intégrations et des fonctionnalités sur mesure grâce à son [programme Co-Create](https://about.gitlab.com/community/co-create/ \"Programme Co-Create\").\n\n### Une communauté engagée \n\nLes projets open source reposent sur l'engagement d'une communauté qui partage ses connaissances pour résoudre des problèmes ou proposer des améliorations sur les logiciels. GitLab [tire pleinement parti de cet écosystème](https://about.gitlab.com/community/ \"Communauté de GitLab\") en s'appuyant sur une base d'utilisateurs et de développeurs qui enrichissent activement son développement et [partagent leur expertise](https://forum.gitlab.com/ \"Forum de GitLab\"). GitLab collabore également avec d'autres entreprises sur des projets open source comme Git, renforçant son engagement pour l'innovation collective et la création de solutions évolutives.\n\n### Un accélérateur d’innovations\n\nEn réunissant des talents du monde entier autour de projets communs, l'open source devient un puissant moteur d'innovation. Cette synergie stimule l'amélioration continue et l'enrichissement des logiciels grâce à la diversité des compétences partagées. Ce modèle accélère ainsi le développement technologique en rendant les outils open source accessibles à un large public. GitLab, avec son cycle de release mensuel, [intègre régulièrement de nouvelles fonctionnalités et améliorations](https://about.gitlab.com/releases/ \"Releases GitLab\") fondées sur les retours et contributions de sa communauté d'utilisateurs.\n\n### Des logiciels évolutifs\n\nLes logiciels open source reposent souvent sur des normes ouvertes qui [simplifient leur intégration avec d'autres systèmes](https://about.gitlab.com/fr-fr/integrations/ \"Intégrations GitLab\"). Conçus pour s'adapter à divers environnements, ils offrent aux entreprises la possibilité de créer des solutions sur mesure, performantes et évolutives.\n\n### Une sécurité logicielle renforcée\n\nLa sécurité et la fiabilité sont des piliers essentiels des logiciels open source. Grâce à l'examen continu du code par une large communauté de développeurs, les failles de sécurité sont rapidement identifiées et corrigées. Bien que cette approche ne garantisse pas une sécurité absolue, elle favorise grandement la réactivité des équipes de développement face aux vulnérabilités de toutes sortes. GitLab applique ce principe en [s'appuyant sur sa communauté pour renforcer la sécurité de sa plateforme](https://handbook.gitlab.com/handbook/security/product-security/application-security/runbooks/hackerone-process/).\n\n### Un savoir-faire enrichi\n\nLes logiciels open source représentent une mine d'opportunités d'apprentissage pour les développeurs. En s'impliquant dans ces projets, ils peuvent perfectionner leurs compétences et gagner en expérience auprès d'autres professionnels du domaine, enrichissant leur savoir-faire et accélérant leur développement professionnel.\n\nPar exemple, les développeurs peuvent étudier la base de code de GitLab pour apprendre les meilleures pratiques en matière de développement de plateformes DevSecOps. Les membres de l'équipe GitLab participent par ailleurs à des programmes de mentorat comme [Google Summer of Code](https://about.gitlab.com/blog/google-summer-of-code-2024-contribute-to-gitlab-and-git-to-prepare/ \"Google Summer of Code\") et [Outreachy](https://about.gitlab.com/blog/outreachy-sponsorship-winter-2020/ \"Outreachy\") qui permettent d'apprendre aux nouveaux participants comment contribuer à GitLab ou autres logiciels open source comme Git.\n\n### Des logiciels plus qualitatifs\n\nDe nombreux projets open source bénéficient de la contribution de développeurs talentueux. Grâce à leur expertise, le code des logiciels open source est constamment examiné, amélioré et renforcé, ce qui permet de développer des solutions robustes et performantes.\n\n## Quels sont les défis liés à l’open source\n\nExplorer l'univers des logiciels open source peut être aussi stimulant qu'exigeant. De la création de relations solides avec une communauté au renforcement de la sécurité des projets, chaque étape comporte ses propres défis. Pour réussir, il est essentiel de comprendre ces obstacles et de mettre en place des stratégies adaptées.\n\n### Construire une relation solide avec sa communauté \n\nLe succès du développement open source repose sur la capacité à établir et à maintenir une relation solide avec une communauté de développeurs et d'utilisateurs. Cela nécessite des échanges continus afin de comprendre et de répondre à ses attentes. Puisque la majorité des contributeurs sont bénévoles, il est essentiel de coordonner leurs efforts de manière agile et structurée.\n\nPour maintenir leur motivation sur le long terme, notamment pour les contributeurs œuvrant sans contrepartie financière, il est crucial de reconnaître et de valoriser leur travail. Cela peut passer par des mentions officielles (crédits), des opportunités de formation ou d'autres formes de reconnaissances professionnelles. Sans cette valorisation, les contributeurs risquent de se détourner des projets, voire de créer des initiatives parallèles. Bâtir une communauté engagée et durable est donc au cœur du succès de tout projet open source.\n\n### Trouver un équilibre entre les intérêts de la communauté et celle des entreprises\n\nTrouver un équilibre entre les intérêts des entreprises et ceux de la communauté est un défi central dans le développement open source. Les entreprises impliquées dans ces projets ont généralement des objectifs prioritaires. Ces priorités, souvent commerciales, peuvent entrer en conflit avec les attentes plus larges de la communauté, dont les intérêts sont plutôt axés sur l'innovation libre ou la personnalisation des logiciels.\n\nLorsque les décisions semblent trop axées sur les intérêts de l'entreprise, la communauté risque de se sentir exclue, ce qui peut réduire son engagement et limiter ses contributions. Pour éviter ce désengagement, les entreprises doivent partager clairement leurs objectifs et échanger régulièrement avec leur communauté pour garantir la pérennité et le succès à long terme des projets open source.\n\n### Maintenir la sécurité des logiciels\n\nLes logiciels open source sont exposés à certains défis en matière de sécurité. La transparence du code, bien qu'étant l'un de leurs plus grands atouts, peut aussi les exposer à des attaques ciblées, ce qui peut devenir un risque majeur si l'entreprise à l’origine du projet open source ne corrige pas rapidement les failles identifiées. \n\nLes utilisateurs comptent ainsi sur la réactivité de l'entreprise pour garantir la sécurité de leurs systèmes et de leurs données. \n\n## GitLab : un partenaire incontournable pour les projets open source\n\nLes projets open source sont un moteur d'innovation technologique, et choisir la bonne plateforme pour les héberger est essentiel. Grâce à son système de gestion de versions basé sur [Git](https://about.gitlab.com/fr-fr/blog/what-is-git/ \"Qu'est-ce que Git ? \"), GitLab permet aux équipes de développement de collaborer efficacement, de suivre les modifications de code et de conserver un historique complet de leurs projets. \n\n### Une suite complète de fonctionnalités collaboratives\n\nGitLab met à disposition de ses utilisateurs une suite complète de fonctionnalités adaptées au développement et à la gestion de projets open source. Parmi ces fonctionnalités figurent le [suivi des tickets](https://docs.gitlab.com/ee/user/project/issues/ \"Tickets GitLab\"), les [merge requests](https://docs.gitlab.com/ee/user/project/merge_requests/ \"merge requests\"), la [revue de code](https://about.gitlab.com/fr-fr/topics/version-control/what-is-code-review/ \"Qu'est-ce qu'une revue de code ? \"), les [wikis](https://about.gitlab.com/fr-fr/blog/get-to-know-the-gitlab-wiki-for-effective-knowledge-management/ \"GitLab Wiki\") et les [GitLab Pages](https://about.gitlab.com/fr-fr/blog/build-a-new-website-in-a-few-easy-steps-with-gitlab-pages/ \"GitLab Pages\"). Ces fonctionnalités permettent aux équipes de suivre l'évolution des projets, de collaborer, de proposer des améliorations, de corriger des bogues et de documenter leurs progrès en temps réel. \n\n### Des pratiques CI/CD au service des projets open source\n\nLes fonctionnalités [CI/CD](https://about.gitlab.com/fr-fr/blog/how-to-keep-up-with-ci-cd-best-practices/ \"Meilleures pratiques CI/CD\") de GitLab sont un atout majeur pour les projets open source. Elles automatisent des étapes clés du développement logiciel, comme les [tests](https://docs.gitlab.com/ee/ci/testing/), la validation du code et le déploiement de nouvelles versions, assurant ainsi une meilleure fiabilité des logiciels open source et un développement accéléré. Chaque contribution est automatiquement testée dans un environnement dédié, ce qui permet de détecter rapidement les erreurs et de corriger les bogues. Cela réduit les risques de défaillances tout en assurant la stabilité des projets. \n\n### Un cycle de développement logiciel sécurisé\n\nGitLab propose une suite complète de fonctionnalités conçues pour aider les développeurs de projets open source à sécuriser leurs logiciels. Parmi ces fonctionnalités, nous retrouvons :\n\n- __Le test statique de sécurité des applications ([SAST](https://docs.gitlab.com/ee/user/application_security/sast/ \"SAST\"))__ qui examine le code source à la recherche de failles de sécurité en amont de la mise en service des logiciels. \n- __Le test dynamique de sécurité des applications ([DAST](https://docs.gitlab.com/ee/user/application_security/dast/ \"DAST\"))__* qui teste les applications en cours d'exécution au sein d’un environnement déployé pour détecter d'éventuelles vulnérabilités encore non repérées. \n- __L'[analyse des dépendances](https://docs.gitlab.com/ee/user/application_security/dependency_scanning/ \"Analyse des dépendances\")__* qui envoie des alertes sur les bibliothèques obsolètes ou vulnérables. Des rapports détaillés sont générés à chaque étape du développement, offrant une visibilité claire sur l'état de la sécurité du projet. Grâce à cela, les développeurs peuvent rapidement éviter ou corriger les composants à risque.\n\n** Fonctionnalité disponible uniquement pour les utilisateurs de GitLab Ultimate.*\n\nEn intégrant ces fonctionnalités directement dans le [pipeline CI/CD](https://about.gitlab.com/fr-fr/topics/ci-cd/cicd-pipeline/ \"Pipeline CI/CD\"), GitLab réduit le risque d'erreurs humaines et accélère l’identification et la correction des vulnérabilités. Cette approche permet ainsi aux développeurs de projets open source de maintenir un niveau élevé de sécurité tout au long du cycle du développement logiciel. \n\n### Une gestion de projet Agile\n\nGitLab met à disposition des équipes de développement un certain nombre de fonctionnalités pour faciliter la gestion des projets open source comme les [tableaux de tickets](https://docs.gitlab.com/ee/user/project/issue_board.html \"Tableaux de tickets\"), les [listes des jalons](https://docs.gitlab.com/ee/user/project/milestones/ \"Listes des jalons\") ou encore le [suivi du temps](https://docs.gitlab.com/ee/user/project/time_tracking.html \"Suivi du temps\"). Ces dernières permettent de voir facilement les tâches à réaliser, de suivre l'avancement des projets en fixant des échéances claires, mais aussi d’évaluer la charge de travail en vue d'optimiser l'utilisation des ressources. En combinant ces fonctionnalités, GitLab permet aux équipes de mieux coordonner leurs efforts, de maintenir un processus de travail fluide et de progresser efficacement dans la réalisation de leurs projets open source.\n\n### Des contributions simplifiées\n\nLes équipes de développement peuvent facilement contribuer au développement de projets open source en les dupliquant ([fork](https://docs.gitlab.com/ee/user/project/repository/forking_workflow.html \"fork\")) et en créant des merge requests. Elles peuvent créer leurs propres copies du code, travailler sur des améliorations ou des correctifs dans des branches distinctes, puis soumettre leurs changements via des merge requests. Ce processus permet aux équipes de réviser et de valider chaque modification avant son intégration dans la branche principale, favorisant ainsi une amélioration continue des logiciels, tout en renforçant la qualité et la stabilité du code.\n\n### Une intégration facilité avec d’autres outils\n\nGitLab facilite considérablement son intégration avec d’autres outils et workflows , permettant aux équipes de développement de créer un environnement personnalisé en fonction des exigences spécifiques de leur projet. Pour en savoir plus, [consultez notre documentation](https://docs.gitlab.com/ee/api/). \n\n## Développez des logiciels open source avec GitLab \n\nL’open source continue de s'imposer dans le monde du développement logiciel. Avec des plateformes [DevSecOps](https://about.gitlab.com/fr-fr/topics/devsecops/ \"Qu'est-ce que DevSecOps ?\") comme GitLab, les équipes de développement disposent de tous les outils et ressources nécessaires au bon développement de leurs logiciels open source.\n\nEn plus d’aider les entreprises à développer des logiciels performants et sécurisés, GitLab fait évoluer continuellement sa plateforme grâce aux contributions et aux retours de ses utilisateurs. En écoutant sa communauté en permanence, GitLab s'adapte aux transformations du développement logiciel, renforçant ainsi sa présence au sein de l'écosystème open source.\n\n> [\nEssayez GitLab Ultimate gratuitement](https://about.gitlab.com/fr-fr/free-trial/devsecops/ \"Essai gratuit de GitLab Ultimate\") et commencez à développer des logiciels open source dès aujourd'hui.","open-source",[807,9,739],{"slug":920,"featured":6,"template":692},"what-is-open-source","content:fr-fr:blog:what-is-open-source.yml","What Is Open Source","fr-fr/blog/what-is-open-source.yml","fr-fr/blog/what-is-open-source",{"_path":926,"_dir":247,"_draft":6,"_partial":6,"_locale":7,"seo":927,"content":933,"config":938,"_id":940,"_type":14,"title":941,"_source":16,"_file":942,"_stem":943,"_extension":19},"/fr-fr/blog/what-is-rest-api",{"title":928,"description":929,"ogTitle":928,"ogDescription":929,"noIndex":6,"ogImage":930,"ogUrl":931,"ogSiteName":675,"ogType":676,"canonicalUrls":931,"schema":932},"API REST : définition et présentation complète","Qu'il s'agisse de développer une application de réservation en ligne, une solution de paiement mobile, ou un service de messagerie, il est fort probable que votre équipe se serve d'une API REST.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749662858/Blog/Hero%20Images/API-REST.jpg","https://about.gitlab.com/blog/what-is-rest-api","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"API REST : définition et présentation complète\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"GitLab France Team\"}],\n        \"datePublished\": \"2024-09-04\",\n      }",{"title":928,"description":929,"authors":934,"heroImage":930,"date":935,"body":936,"category":710,"tags":937},[803],"2024-09-04","Qu'est-ce qu'une API REST ? Quels sont ses avantages et comment l'utiliser ? Cet article répond aux questions que vous pourriez vous poser sur l'API REST.\n\n__Sommaire__\n- Qu’est-ce qu’une API REST ?\n- Comment fonctionne une API REST ?\n- Quels sont les principes de l'API REST ?\n- Quels sont les avantages d’une API REST ?\n- Utilisations d'une API REST\n\n## Qu’est-ce qu’une API REST ?\n\nL’API REST est une __API (Interface de Programmation d’Application) qui adhère au standard de l'architecture REST (REpresentational State Transfer)__. D’autres appellations désignent l’API REST : API RESTful ou API Web Restful. \n\nUne API, ou interface de programmation d'application, est un logiciel qui permet à deux applications de communiquer entre elles. En informatique, les APIs sont indispensables pour permettre à diverses applications de fonctionner ensemble. \n\nPour créer une API, les développeurs suivent des méthodes et des principes strictement définis, afin que l'ensemble puisse fonctionner. Avant les années 2000, les développeurs utilisaient SOAP (*Simple Object Access Protocol*), un protocole bâti sur XML, complexe à coordonner et gourmand en ressources. Si SOAP est encore utilisé de nos jours, il a été en grande partie remplacé par l'API REST.\n\nConçu en 2000 par l'informaticien américain __Roy Fielding__ au cours de sa thèse de doctorat, REST (*REpresentational State Transfer*) est devenu le modèle dominant de création des APIs, et un jalon incontournable dans le développement du *World Wide Web*. Aujourd'hui, la grande majorité des APIs sont basées sur REST, particulièrement pour offrir des __services Web, interactifs ou mobiles__. Découvrons le fonctionnement des API RESTful, leurs avantages, et leurs applications très variées.\n\n## Comment fonctionne une API REST ? \n\nDans la pratique, l'API REST fonctionne sur le principe de l'environnement client-serveur. L'API RESTful récupère et transmet d'un côté les requêtes d'un utilisateur ou d'une application, et de l'autre les informations rendues par le serveur (application ou base de données). \n\nQuelques notions clés permettent de saisir le fonctionnement d'une API RESTful. __Le client__ est l'entité effectuant une demande. C'est le cas par exemple d'un utilisateur effectuant une recherche au sein d'un catalogue de produits sur son navigateur. __L'API__ se charge de communiquer au serveur la requête, et de renvoyer vers le client les informations demandées. Les informations qui transitent par l'API sont les ressources. __Le serveur__ traite les requêtes. Dans le cas présent, il renverra la liste des produits correspondant aux critères de recherche.\n\nLes requêtes du client sont formulées à travers le __protocole HTTP__ (*HyperText Transfer Protocol*). Voici les principales méthodes et tâches qu'il permet d'accomplir : \n\n- GET : récupérer des données envoyées par le serveur.\n\n- POST : envoyer et publier des informations vers le serveur (les données d'un formulaire d'inscription par exemple).\n\n- PUT : mettre à jour les informations du serveur.\n\n- PATCH : modifier partiellement une ressource existante.\n\n- DELETE : supprimer des informations du serveur.\n\nLes formats de données pour utiliser une API REST sont divers. Le format JSON (*JavaScript Object Notation*) est un format léger, facile à comprendre, et utilisable par de nombreux langages de programmation. XML (*Extensible Markup Language*) permet de gérer des structures de données complexes, et est compatible avec d'autres standards comme le RSS. YAML et HTML sont d'autres formats souvent utilisés pour communiquer les ressources.\n\n## Quels sont les principes de l'API REST ?\n\nUne API REST suit les principes de REST en termes d'__architecture logicielle__. Ces principes créent une ligne directrice permettant de créer des APIs flexibles et légères, parfaitement adaptées à la transmission de données sur internet. \n\nVoici les six principes architecturaux qui régissent une interface REST : \n\n- __Découplage client-serveur.__ Le client connaît seulement l'URI (Uniform Resource Identifier) de la ressource à récupérer. Le serveur interagit uniquement en transmettant ses données via HTTP.\n\n- __Interface uniforme.__ L'architecture REST uniformise la façon dont les informations sont identifiées, gérées et transmises, et fait appel aux hyperliens pour apporter des ressources supplémentaires au client.\n\n- __Code à la demande.__ Le serveur peut transmettre du code au client pour étendre ses fonctionnalités, par exemple pour aider à repérer les erreurs d'un formulaire.\n\n- __Système en couches.__ Une API RESTful peut s'exécuter sur plusieurs serveurs organisés de façon hiérarchique, pour fournir un service plus stable et performant au client.\n\n- __Mise en cache.__ Le serveur REST peut mettre en cache des données pour mieux servir le client, en stockant par exemple les images d'un site pour les resservir ensuite.\n\n- __Absence d'état (Stateless).__ Chaque requête du client est isolée et traitée indépendamment par le serveur. Ainsi, chaque appel doit contenir tous les éléments nécessaires à son traitement.\n\n## Quels sont les avantages d’une API REST ?\n\nEn respectant les exigences du framework de l'API REST, les développeurs profitent des nombreux avantages des API RESTful pour développer des applications efficaces et puissantes : \n\n- __Polyvalence :__ il n'y a aucune restriction sur le langage de programmation à utiliser, et un grand choix pour le format de données (XML, PYTHON, JSON, HTML, etc.)\n\n- __Légèreté :__ les formats de données légers d'une API REST la rendent idéale pour des applications mobiles ou l'Internet des objets (IoT).\n\n- __Portabilité :__ la séparation client-serveur facilite l'échange de données entre les plateformes.\n\n- __Flexibilité :__ cette API n'a pas les lourdeurs d'un protocole, c'est un style architectural.\n\n- __Indépendance :__ les développeurs peuvent travailler séparément sur la partie client ou serveur. \n\nLes avantages de l'API REST se traduisent en gain de productivité et en évolutivité pour les équipes de développement. La mise à l'échelle des systèmes utilisant API REST est facilitée. Les fonctionnalités sont donc plus à même de soutenir une grande charge d'utilisateurs et d'opérations.\n\n### Des contraintes de sécurité\n\nLa création et la gestion d'une API Web RESTful ne sont pas exemptes de défis. L'__authentification__ des utilisateurs peut devenir complexe lorsqu'elle fait appel à plusieurs méthodes différentes, par HTTP, clés API, ou OAuth (*Open Authorization*). Sur des applications larges et complexes, la __multiplication des points de terminaison__ (*endpoints*) entre le serveur et le client peut nuire à la cohérence d'ensemble, de même que les mises à jour si elles laissent d'anciens points de contact encore actifs. \n\nD'autre part, l'interface REST a une faiblesse, car elle transmet par l'URL des points de terminaison des données potentiellement sensibles, comme les identifiants. Sa sécurisation nécessite des mesures spécifiques comme un chiffrement TLS (*Transport Layer Security*), un modèle d'authentification des utilisateurs robuste, et un système de prise en charge des requêtes abusives et de limitation des débits.\n\n## Utilisations d'une API REST\n\nLes développeurs utilisent des API à l'architecture REST pour créer et maintenir de nombreux services. Ainsi, la plupart des applications web et mobiles utilisent des API REST pour accéder et partager des ressources et des informations. Dans le Cloud, cette API permet de connecter rapidement les services des architectures distribuées et hybrides. Au sein des grandes entreprises, elle facilite l'interopérabilité entre les composants des systèmes d'information. \n\nVoici des exemples d'application d'une API REST au sein de sociétés reconnues : \n\n- __Google Search.__ Cette API fournit en temps réel des millions de résultats de recherche sur Google Web et Google Image.\n\n- __Deezer.__ L'API REST de la plateforme de streaming musical permet de retrouver un album ou un artiste dans la base de données de millions de chansons.\n\nActualiser les prix d'un site e-commerce, modifier un champ dans le code source, automatiser des publications, [orchestrer des clusters Kubernetes](https://about.gitlab.com/fr-fr/blog/kubernetes-the-container-orchestration-solution/ \"Kubernetes, la solution d’orchestration des conteneurs\"), etc. Le champ d'utilisation des APIs RESTful n'a de limites que celle de l'imagination des développeurs et des créateurs d'applications digitales.\n\n### L'API REST de GitLab\n\nGitLab propose une suite complète d'outils et d'APIs pour l'intégration et l'automatisation d'applications externes. Elle comprend GraphQL, les webhooks, des extensions IDE, et naturellement, une API REST. L'authentification de l'API REST GitLab peut se faire de nombreuses manières, par jeton d'accès, OAuth, ou cookies de session par exemple. Les points de terminaisons sont disponibles pour les templates Dockerfile, .gitignore, GitLab CI/CD YAML et Open source. Pour profiter pleinement de toutes les possibilités de développement de vos applications agiles et cloud-natives, consultez la [documentation complète de l'API REST de GitLab](https://docs.gitlab.com/ee/api/rest/index.html \"Documentation sur l'API REST de GitLab\").  \n\n## FAQ sur l'API REST\n\n### REST vs SOAP\n\n__REST et SOAP__ sont deux standards d'API. L'API REST (*REpresentational State Transfer*) reprend les principes architecturaux de REST, qui permettent de faire communiquer un serveur et un client de façon légère et évolutive. L'API REST est le type d'API le plus répandu. Le protocole SOAP (*Simple Object Access Protocol*) est plus ancien, plus rigide et disponible uniquement en format XML. Ce standard historique peut être encore utilisé pour des applications qui requirent un haut niveau de sécurité.\n\n### Quelle est la différence entre REST et API REST ?\n\nREST est un style d'architecture logicielle destiné à faciliter la création de services web et l'échange de données sur internet, en assurant l'interopérabilité entre les ordinateurs et serveurs. L'API Web RESTful est un type d'API qui se base sur les grands principes de REST. \n\n### Quelle est la différence entre REST et RESTful ?\n\nREST est un ensemble de principes architecturaux qui définissent comment les services web doivent être conçus pour être simples, évolutifs et performants. Une API est dite RESTful lorsqu'elle respecte ces principes, notamment l'utilisation des verbes HTTP standard (GET, POST, PUT, DELETE), l'organisation des ressources via des URLs claires et prévisibles, et l'absence d'état côté serveur. En d'autres termes, une API peut être basée sur REST sans être pleinement RESTful si elle ne respecte pas toutes les bonnes pratiques de cette architecture.\n\n### Quels sont les principes d'une API REST ?\n\nUne API REST respecte les six grands principes de l'architecture REST. Ces principes sont l'interface uniforme, le code à la demande, le système en couches, la mise en cache, l'absence d'état et le découplage client-serveur. Ce dernier principe constitue la base de la structure d'une API RESTful ; il est essentiel au succès de cette API dans le monde des applications Web.\n",[9,739],{"slug":939,"featured":6,"template":692},"what-is-rest-api","content:fr-fr:blog:what-is-rest-api.yml","What Is Rest Api","fr-fr/blog/what-is-rest-api.yml","fr-fr/blog/what-is-rest-api",{"_path":945,"_dir":247,"_draft":6,"_partial":6,"_locale":7,"seo":946,"content":952,"config":958,"_id":960,"_type":14,"title":961,"_source":16,"_file":962,"_stem":963,"_extension":19},"/fr-fr/blog/4-must-know-devops-principles",{"title":947,"description":948,"ogTitle":947,"ogDescription":948,"noIndex":6,"ogImage":949,"ogUrl":950,"ogSiteName":675,"ogType":676,"canonicalUrls":950,"schema":951},"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":947,"description":948,"authors":953,"heroImage":949,"date":954,"body":955,"category":689,"tags":956,"updatedDate":957},[707],"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",[9,687,234],"2024-10-22",{"slug":959,"featured":6,"template":692},"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",2,[668,697,720,747,769,792,814,837,861],1758326292346]