Adopter une approche DevSecOps nécessite de bien réfléchir au workflow qui sera utilisé. Si cette étape peut parfois représenter un défi de taille, GitLab Flow et GitLab Duo sont là pour vous simplifier la tâche :
GitLab Flow est l'approche préconisée pour accompagner les entreprises dans la mise en œuvre réussie de leurs processus DevSecOps. GitLab Duo, quant à lui, offre un ensemble de fonctionnalités alimentées par l'IA, intégré à la plateforme DevSecOps de GitLab. Il aide les équipes de développement à coder plus efficacement, optimise le cycle de développement logiciel et garantit une livraison de logiciels plus sécurisés.
En associant GitLab Flow et GitLab Duo, les entreprises peuvent améliorer considérablement l'intégralité de leur workflow, augmenter davantage leur productivité, la fréquence de leurs déploiements, la qualité du code et la sécurité globale, ainsi que la résilience et la disponibilité de l'environnement de production.
Dans cet article, découvrez comment GitLab Flow et GitLab Duo peuvent être utilisés conjointement pour aider les entreprises à réussir leur approche DevSecOps.
Qu'est-ce que GitLab Flow ?
GitLab Flow est un workflow complet et précis destiné au développement d'applications avec GitLab, notre plateforme DevSecOps alimentée par l'IA offrant une interface utilisateur et un modèle de données uniques.
GitLab Flow est basé sur les meilleures pratiques et leçons tirées des retours d'expérience de nos clients ainsi que de l'utilisation de nos propres fonctionnalités en interne. En outre, GitLab Flow couvre chacune des étapes du cycle de vie DevSecOps créant un workflow efficace comprenant deux boucles de rétroaction :
- Une boucle de rétroaction interne qui permet d'examiner et d'évaluer une mise à jour spécifique de l'application pour s'assurer qu'elle répond aux critères de qualité et de sécurité.
- Une boucle de rétroaction externe qui vise à améliorer l'application dans son ensemble, ainsi que le cycle de développement lui-même.
GitLab Flow étant constitué de nombreuses étapes, le développement logiciel ne se limite pas à la simple écriture de code. Découvrez ci-dessous chaque étape du processus DevSecOps dans GitLab Flow ainsi que les avantages d'y ajouter l'utilisation de GitLab Duo.
L'étape de planification
La planification est la première étape de GitLab Flow et fait partie de la boucle de rétroaction externe. Elle inclut les tickets, les merge requests, les epics, les jalons, les itérations, les sorties de nouvelles versions, les preuves de déploiement et bien plus encore. Découvrez le rôle de ces composants dans GitLab Flow et les avantages de les utiliser en parallèle de GitLab Duo.
Les tickets
Les tickets sont des espaces collaboratifs dans lesquels les problèmes relatifs au produit sont traités et les nouvelles fonctionnalités sont définies. Lorsque vous créez un ticket, vous commencez par renseigner son titre. Ensuite, vous pouvez utiliser la fonctionnalité de génération de descriptions de tickets de GitLab Duo pour automatiquement enrichir le champ de description. Cela vous permet ainsi de gagner un temps précieux et de réduire vos efforts.
Comme de nombreuses personnes peuvent être amenées à collaborer sur un même ticket, la fonctionnalité de résumé des discussions alimentée par l'IA de GitLab Duo peut résumer des centaines de commentaires laissés sur un ticket en un paragraphe concis. Ainsi, n'importe quelle partie prenante peut rapidement suivre la conversation, rejoindre la discussion et être immédiatement productive.
Les tickets peuvent être organisés et visualisés dans des tableaux de tickets, qui sont des outils de gestion de projet pouvant être utilisés comme tableaux Kanban ou Scrum. Ces tableaux aident les équipes à planifier, à organiser et à visualiser un workflow relatif à un déploiement d'une fonctionnalité ou d'un produit. Différentes catégories de tableaux peuvent être créées et les tickets peuvent être déplacés d'un tableau à l'autre par simple glisser-déposer.
Les merge requests
C'est à l'aide des merge requests que les solutions logicielles sont développées. En tant que composants associés à la sortie de nouvelles versions, les tickets et les merge requests permettent d'auditer et de suivre les modifications apportées aux applications par les parties prenantes. Ils sont essentiels au travail des ingénieurs DevOps et des ingénieurs de plateforme, aux administrateurs système et aux administrateurs de base de données, tout comme aux ingénieurs sécurité et aux équipes de développement. En outre, les tickets et les merge requests sont des éléments clés du processus de planification pour la sortie des nouvelles versions.
Les merge requests peuvent être créées individuellement ou à partir d'un ticket existant. La création d'une merge request à partir d'un ticket la relie automatiquement à ce dernier, de sorte que lorsqu'elle est fusionnée, le ticket associé est automatiquement fermé. Il est également possible de lier manuellement une merge request à un ticket.
Tout comme les tickets, les merge requests peuvent regrouper une longue liste de mises à jour d'une branche de fonctionnalité réalisées par de nombreuses parties prenantes. Les collaborateurs souhaitant comprendre ou se familiariser avec les mises à jour d'une merge request peuvent utiliser la fonctionnalité de résumé des merge requests de GitLab Duo pour prendre rapidement connaissance des modifications qui ont été apportées. De plus, ils peuvent tirer parti de la fonctionnalité de remplissage automatique d'un modèle de merge request de GitLab Duo, qui s'appuie sur un template de merge request prédéfini, pour remplir automatiquement le contenu des différentes sections. Ces templates de description permettent de standardiser et d'optimiser la collaboration et la communication entre les parties prenantes tout au long du cycle de développement. Et ce processus est encore plus rapide avec GitLab Duo !
Les tickets appartenant au même thème peuvent être regroupés dans des epics pour organiser les tâches à effectuer. Les epics peuvent inclure des tickets enfants et des sous-epics et/ou être liés aux autres epics de l'entreprise. Les itérations permettent de suivre les sprints de travail. Vous pouvez les planifier soit manuellement, soit automatiquement à l'aide des cadences d'itération de GitLab afin de rationaliser les workflows de planification. De plus, elles incluent des graphiques d'avancement burndown et burnup. Les graphiques d'avancement burndown suivent la progression globale d'un projet, tandis que les graphiques d'avancement burnup suivent quotidiennement le nombre total et le poids des tickets ajoutés et terminés dans une timebox donnée.
Les jalons
Les jalons permettent aux équipes DevSecOps d'organiser les tickets et les merge requests dans un groupe cohérent, avec une date de début et une échéance facultatives. Ils sont généralement utilisés pour suivre les nouvelles versions et servent également à suivre les tickets et les merge requests au niveau d'un projet ou d'un groupe. Similaires aux itérations, les jalons fournissent des graphiques d'avancement burndown et burnup montrant l'avancement d'un projet.
Ils peuvent être associés à la sortie d'une nouvelle fonctionnalité, dont la création automatisée génère de nombreux artefacts, y compris des preuves de déploiement. La preuve de déploiement est un instantané automatisé des données liées à la sortie d'une nouvelle fonctionnalité. En complément des artefacts de test et des jalons associés, les artefacts de job peuvent éventuellement être inclus dans les preuves de déploiement. Cette démarche facilite la vérification par des audits externes des processus internes de développement et de déploiement des nouvelles versions.
Les epics, jalons et itérations peuvent être visualisés depuis la page Roadmaps, qui permet de suivre la progression de la sortie d'une nouvelle fonctionnalité et de rationaliser ce processus.
Une fois l'étape de planification terminée, le travail visant à résoudre un problème ou à développer une nouvelle fonctionnalité peut commencer. C'est là que les merge requests entrent en jeu. Examinons plus en détail ce processus dans GitLab Flow.
Les merge requests et le push du code
La deuxième étape dans GitLab Flow concerne les merge requests et le push du code. Comme mentionné précédemment, c'est à l'aide des merge requests que les solutions sont développées de façon collaborative par les parties prenantes de l'entreprise. Cette collaboration peut se faire de manière distribuée et asynchrone.
Les participants peuvent tirer parti des fonctionnalités de collaboration, telles que l'ajout de tags, l'intégration de suggestions et de commentaires à la ligne de code, l'ajout de commentaires au sein des merge requests, la revue des fils de discussion et des demandes. Toutes ces fonctionnalités permettent d'améliorer la qualité du code, sa disponibilité, sa fiabilité et ses performances.
La boucle de rétroaction interne de GitLab Flow intervient directement après la création de la merge request. Elle inclut le push du code et des corrections, l’exécution des scans et des tests, ainsi que la revue à des fins collaboratives et de mise à jour.
Les pipelines
Lorsque des mises à jour sont appliquées à une branche de fonctionnalité via des merge requests, les pipelines (s'ils sont définis) sont automatiquement exécutés. Ils peuvent comporter plusieurs étapes et jobs servant à compiler, à tester puis à déployer l'application ou le microservice dans un environnement de revue. Cet environnement permet de vérifier les mises à jour dynamiquement avant qu'elles ne soient fusionnées dans la branche principale. Cette automatisation rationalise les processus de mise à jour et de revue lors du développement de l'application.
Par ailleurs, lorsqu'elles apportent des mises à jour à l'application via des merge requests, les équipes DevSecOps ont accès à diverses fonctionnalités alimentées par l'IA. Lors de l'écriture ou de la mise à jour du code, la fonctionnalité de suggestions de code de GitLab Duo propose la prochaine portion de code à écrire en fonction du contexte. Le développeur est alors libre de l'accepter ou de l'ignorer.
Les suggestions de code prennent en charge la génération de code via des prompts ainsi que la complétion de code en temps réel. Elles peuvent améliorer l'expérience de programmation en réduisant les erreurs et en aidant les équipes de développement à écrire du code plus rapidement, contribuant ainsi à améliorer la qualité du code de l'environnement de production. Elles peuvent également accroître la productivité des développeurs et développeuses, ainsi qu'accélérer les itérations et les déploiements.
Lorsque les différentes parties prenantes au sein du projet participent au développement ou à la revue d'applications, elles se heurtent parfois à un code peu documenté, complexe, difficile à interpréter ou écrit dans un langage de programmation qui ne leur est pas familier. Avec la fonctionnalité d'explication du code de GitLab Duo, le code est traduit en langage naturel permettant à quiconque au sein de l'équipe de le comprendre facilement et de devenir opérationnel rapidement.
De plus, lorsqu'un développeur ou une développeuse effectue une validation des modifications sur une branche de fonctionnalité, la fonctionnalité de suggestion de relecteurs de GitLab Duo utilise la merge request de ces modifications et le graphique de contributions pour suggérer une liste de relecteurs appropriés dans la liste déroulante des relecteurs située dans la barre latérale de la merge request. Cette liste inclut des utilisateurs qui connaissent un aspect spécifique de l'application et semblent les meilleurs candidats pour effectuer une revue des mises à jour. Ainsi, les développeurs n'ont plus besoin de rechercher ni d'identifier eux-mêmes les relecteurs appropriés, ce qui évite les retards et garantit la qualité des revues.
Lorsque les développeurs modifient le code, il arrive souvent qu'ils n'incluent pas dans la merge request un commentaire sur les modifications apportées. Fort de ce constat, la fonctionnalité de résumé des merge requests de GitLab Duo permet à l'auteur de la merge request d'utiliser l'IA pour générer un commentaire en langage naturel qui résume les modifications apportées au code. Les relecteurs peuvent ainsi mieux comprendre les changements apportés et rationaliser l'ensemble du processus de revue.
Lorsque les relecteurs vérifient les modifications apportées au code dans une merge request et qu'ils détectent des anomalies, ils peuvent créer un bloc de revue pouvant inclure de nombreux commentaires impliquant de nombreux fichiers source. Pour aider l'auteur de la merge request à comprendre l'afflux de commentaires fournis par le relecteur, la fonctionnalité de résumé des revues de code de GitLab Duo génère un résumé en langage naturel des retours du relecteur. Cela permet de meilleurs transferts entre les auteurs et les relecteurs, tout en simplifiant le processus de revue.
En outre, lorsque les développeurs ajoutent du nouveau code par le biais d'une merge request, ils peuvent tirer parti de la fonctionnalité de génération de tests de GitLab Duo qui utilise l'IA pour générer des tests unitaires afin de vérifier le nouveau code. Cela permet d'augmenter la productivité des équipes de développement, d'améliorer la couverture de test et de détecter les bogues en amont du cycle de développement. Elles peuvent également tirer parti de GitLab Duo Chat, qui est toujours accessible, afin de refactoriser le code et de générer de la documentation intégrée à la ligne de code (par exemple des docstrings) pour leur code source.
Bien que les pipelines s'exécutent sur les mises à jour de branches, ils peuvent inclure des tests et des scans automatisés, ce qui permet d'intégrer la sécurité en amont.
L'intégration de la sécurité en amont
L'intégration de la sécurité en amont est la troisième étape de GitLab Flow. Elle fait également partie de la boucle de rétroaction interne.
Les ingénieurs DevOps et ingénieurs de plateforme, les administrateurs système et administrateurs de base de données, les développeurs ainsi que d'autres parties prenantes collaborant à une merge request peuvent avoir des inquiétudes concernant la sécurité et la conformité. C'est là que les scans de sécurité et les tests automatisés entrent en jeu.
Il est possible d'inclure les scans de sécurité dans un pipeline via des templates prêts à l'emploi et/ou de les exécuter automatiquement dans un pipeline de merge requests. GitLab fournit un large éventail de scanners et d'analyseurs de sécurité intégrés qui peuvent être utilisés par GitLab Flow. Mais ce n'est pas tout, notre plateforme DevSecOps peut également accueillir des scanners tiers et personnalisés.
GitLab Flow intègre la sécurité en amont dans le pipeline afin de détecter et de résoudre les failles de sécurité le plus tôt possible dans le cycle de développement logiciel. Il est beaucoup plus simple (et moins coûteux) de corriger les vulnérabilités au début du cycle de développement. En effet, une fois qu'une application est en production, une panne imprévue peut avoir des conséquences sur vos utilisateurs, mais aussi vos revenus. Alors, pourquoi ne pas la résoudre avant qu'elle ne se produise ?
Voici une liste des scanners et analyseurs de sécurité intégrés fournis par GitLab :
- les tests unitaires,
- l'analyse de l'Infrastructure as Code (IaC),
- les scanners SAST (test statique de sécurité des applications),
- l'analyse des dépendances,
- la détection de secrets,
- l'analyse des conteneurs,
- la sécurité des API,
- les tests d'API web par injection de données aléatoires,
- les tests à données aléatoires guidés par la couverture de code.
GitLab fournit par ailleurs un grand nombre de tableaux de bord et de rapports de sécurité permettant de gérer et de visualiser les vulnérabilités (liste des dépendances, tableau de bord de sécurité, rapport sur les vulnérabilités et pages de vulnérabilité).
Pour aider les développeurs et les ingénieurs sécurité à mieux comprendre les vulnérabilités et à les corriger plus efficacement, la fonctionnalité d'explication des vulnérabilités de GitLab Duo fournit des détails sur une vulnérabilité spécifique, en décrivant comment elle peut être exploitée et, surtout, en proposant des recommandations pour la corriger. Les développeurs peuvent également tirer parti de la fonctionnalité de résolution des vulnérabilités de GitLab Duo, qui crée automatiquement une merge request incluant les modifications de code permettant de corriger la vulnérabilité. Ces fonctionnalités alimentées par l'IA rationalisent et optimisent le processus de sécurisation et de renforcement de l'application concernée afin de prévenir les vulnérabilités susceptibles d'être exploitées lors de cyberattaques dans l'environnement de production.
Outre les scanners SAST, GitLab met à disposition de ses utilisateurs des scanners DAST (test dynamique de sécurité des applications) qui nécessitent une application en cours d'exécution pour effectuer les tests. Grâce à ces scanners, GitLab peut provisionner automatiquement un environnement DAST en vue de réaliser des scans DAST, puis effectuer un nettoyage complet de toutes les ressources après les tests DAST. Par ailleurs, pour les conteneurs en cours d'exécution, GitLab fournit une fonctionnalité OCS (Operational Container Scanning) qui analyse les images de conteneurs de votre cluster afin de detecter des failles de sécurité.
Il est possible d'exécuter automatiquement les scans mentionnés ci-dessus dans un pipeline de merge requests ou, dans certains cas, de planifier leur exécution via des stratégies d'exécution de scan et d'approbation des merge requests. Ces stratégies peuvent être définies via l'interface utilisateur de GitLab ou des fichiers YAML. Elles sont configurées dans un projet distinct, ce qui permet de séparer les tâches et ainsi de faciliter la réutilisation, la maintenance et la gestion. Les stratégies d'exécution des scans exigent que les scans de sécurité soient exécutés selon un calendrier précis ou avec le pipeline de projets. Ensuite, les stratégies d'approbation des merge requests prennent des mesures basées sur les résultats des scans. Les équipes ou les ingénieurs sécurité peuvent définir ces stratégies pour appliquer les processus de sécurité dans l'ensemble de l'entreprise, et GitLab Flow peut les détecter ou les exploiter lors de son exécution.
Pour renforcer la sécurité et la conformité des projets menés au sein de votre entreprise, vous pouvez utiliser des pipelines et des labels de conformité. Ceux-ci peuvent être rendus obligatoires avant l’exécution du pipeline d’un projet. Ainsi, vous avez la certitude que l'ensemble de vos équipes respectent vos normes de sécurité et de conformité. Cela vous permet par ailleurs de protéger vos applications contre les cyberattaques, tout en respectant les normes de conformité gouvernementales et de toujours être préparé pour un éventuel audit.
L'objectif principal de toutes ces recommandations de sécurité de GitLab Flow est de corriger les vulnérabilités dès le début du cycle de développement, plutôt qu'en production, car les corrections peuvent s'avérer lourdes de conséquences en termes de réputation et de chiffre d'affaires.
À mesure que les vulnérabilités sont atténuées dans la boucle de rétroaction interne de GitLab Flow et que des mises à jour sont apportées à l'application dans la branche de fonctionnalité, les parties prenantes doivent effectuer une nouvelle revue des mises à jour pour s'assurer de leur application effective et qu'aucune régression n'a été introduite par inadvertance.
La revue continue
La revue des fonctionnalités, quatrième étape de GitLab Flow, repose sur une revue continue des applications. Cette étape nécessite de déployer l'application provisoire (branche de fonctionnalité) dans un environnement de revue prévu à cet effet afin que les parties prenantes puissent la vérifier en temps réel et fournir des retours constructifs. L'application provisoire peut ensuite être ajustée en continu jusqu'à ce qu'elle soit prête à être fusionnée dans la branche principale. GitLab Flow recommande également le nettoyage de toutes les ressources de l'environnement de revue provisionnées au moment où la merge request est fusionnée dans la branche principale.
Ce processus de revue automatisé et itératif fait partie de la boucle de rétroaction interne de GitLab Flow. Comme mentionné ci-dessus, dans la boucle de rétroaction interne, il est recommandé d'utiliser les fonctionnalités de GitLab Duo suivantes : explication du code, suggestions de code, suggestion de relecteurs, résumé des merge requests, remplissage automatique d'un template de merge request, résumé des revues de code, explication des vulnérabilités, résolution des vulnérabilités et analyse des causes profondes. En effet, celles-ci facilitent le transfert entre les auteurs et les relecteurs tout en simplifiant l'ensemble du processus de revue.
La boucle de rétroaction interne de GitLab Flow prend fin lorsque tous les éléments de revue sont traités et que la merge request est approuvée et fusionnée dans la branche principale, ce qui déclenche le déploiement de l'application en production.
Le déploiement des applications et de l'infrastructure
En fonction des besoins de l'entreprise, GitLab Flow recommande la livraison continue ou le déploiement continu.
- La livraison continue consiste à publier fréquemment du code en déclenchant les déploiements manuellement (par exemple, en production).
- Le déploiement continu désigne la publication automatisée de code (par exemple, en production) sans intervention humaine.
Intéressons-nous d'abord à la livraison continue.
Lorsque vous publiez votre logiciel en utilisant la livraison continue, vous disposez de plusieurs options de déploiement. Vous pouvez établir une fenêtre de gel, puis déployer le logiciel à l'aide de techniques de déploiement avancées, telles que les déploiements canari, bleu/vert, programmés et incrémentiels. Les déploiements incrémentiels réduisent le risque de panne dans l'environnement de production et améliorent l'expérience utilisateur ainsi que la satisfaction client. Les techniques de déploiement avancées améliorent également l'efficacité du processus de développement et de livraison en simplifiant le processus de sortie de nouvelles versions.
Lorsque vous publiez votre logiciel en utilisant le déploiement continu, l'intégralité des changements/mises à jour est directement déployée en production. Les approches de livraison progressive telles que les feature flags, qui vous permettent de séparer la livraison de fonctionnalités spécifiques d'un lancement, sont un bon moyen de réduire les risques et de gérer les fonctionnalités à mettre à la disposition des utilisateurs finaux. Les feature flags prennent en charge plusieurs langages de programmation. Ils permettent aux équipes de développement d'expérimenter et d'effectuer des tests contrôlés. Vous pouvez même utiliser des feature flags pour déployer des fonctionnalités auprès d'utilisateurs spécifiques.
Bien que GitLab prenne en charge toutes ces approches de déploiement, GitLab Flow permet d'adopter l'approche qui convient le mieux aux équipes et/ou aux besoins spécifiques du projet.
La surveillance des applications et des processus DevSecOps
Une fois que votre application a été déployée en production, elle doit être surveillée en permanence pour assurer sa stabilité, ses performances et sa disponibilité. En outre, les processus DevSecOps qui s'exécutent sont mesurés en parallèle, ce qui permet d'améliorer leurs performances et leur efficacité. Les fonctionnalités de surveillance sont fournies par GitLab et, en tant que telles, peuvent être exploitées par GitLab Flow.
Pour les conteneurs en cours d'exécution, GitLab fournit une fonctionnalité OCS (Operational Container Scanning) qui analyse les images de conteneurs de votre cluster afin de détecter des failles de sécurité. Il est possible d'automatiser ces scans en planifiant leur exécution. Les vulnérabilités détectées sont automatiquement affichées dans un tableau de bord de sécurité. La fonctionnalité OCS peut vous aider à sécuriser vos applications de cluster et à anticiper toute cyberattaque pouvant entraîner des fuites de données privées et même provoquer des pannes inattendues.
Le suivi des erreurs permet aux équipes de développement de détecter et de visualiser les erreurs générées par leur application. Celles-ci sont affichées dans la liste de suivi des erreurs dans GitLab. Le suivi des erreurs permet d'améliorer la disponibilité et les performances de vos applications en détectant et en résolvant rapidement les conditions d'application inattendues.
GitLab peut accepter les alertes de n'importe quelle source de surveillance, y compris Prometheus, via un récepteur webhook. Dès qu'une alerte arrive, elle est affichée dans la liste des fonctionnalités d'alertes de GitLab, où vous pouvez la gérer manuellement. Les alertes peuvent également déclencher automatiquement la création d'incidents, de ChatOps et d'e-mails à des personnes ou des groupes spécifiques. Toutes ces fonctionnalités rationalisent le processus de résolution et de gestion des alertes.
Dès qu'un incident est créé suite à la détection de problèmes dans l'environnement de production, il apparaît dans la liste des incidents de GitLab, où vous pouvez le gérer facilement. Vous pouvez gérer un ou plusieurs incidents, les trier, effectuer des recherches, les assigner, définir leurs statuts et même voir leur compte à rebours calculant l'échéance de l'accord de niveau de service (SLA). De plus, vous pouvez créer des équipes de garde et des rotations, des politiques d'escalade, ainsi que configurer la remontée d'alertes et les notifications pour gérer les incidents. Vous pouvez également associer un incident à une alerte afin que celle-ci soit automatiquement résolue une fois que l'incident est fermé. Les chronologies d'incident permettent également aux cadres dirigeants et aux utilisateurs externes de voir ce qui s'est passé lors d'un incident et quelles mesures ont été prises pour le résoudre. Toutes ces fonctionnalités rationalisent et accélèrent le processus de gestion et de résolution des incidents.
Les événements d'audit suivent les événements importants, en permettant notamment d'identifier l'intervenant qui a effectué l'action correspondante et le moment de l'intervention dans GitLab. Ces événements sont affichés dans la liste des événements d'audit de GitLab et fournissent, entre autres, l'action qui a été effectuée sur un objet, son auteur, ainsi que sa date et son heure d'occurrence.
L'ensemble des listes et tableaux de bord mentionnés ci-dessus permettent d'anticiper les scénarios de non-conformité afin d'éviter les pénalités et de rationaliser les processus d'audit. Pour vos applications en cours d'exécution, ils génèrent les données et les indicateurs qui peuvent être utilisées dans la boucle de rétroaction externe de GitLab Flow afin de vous aider à améliorer et à optimiser vos applications et à réduire le risque de pannes imprévues dans l'environnement de production.
L'amélioration continue
GitLab Flow permet de tirer parti des tableaux de bord et indicateurs de performance des processus à chaque étape du développement logiciel. Ces tableaux offrent des informations précieuses pour améliorer en continu votre application et vos performances dans ce domaine. Ils sont générés automatiquement par GitLab et sont toujours accessibles.
Le tableau de bord d'analyse des flux de valeur
Vous pouvez suivre et surveiller le cycle de développement de vos applications via le tableau de bord d'analyse des flux de valeur, où vous pouvez consulter les statistiques du projet ou du groupe au fil du temps. Ce tableau de bord est personnalisable, mais vous pouvez commencer rapidement en créant une chaîne de valeur à l'aide d'un modèle par défaut fourni par GitLab. Celui-ci affiche des indicateurs pour chacune des étapes prédéfinies de l'analyse du flux de valeur (Ticket, Planification, Codage, Test, Revue de code et Préproduction), ainsi qu'un graphique montrant le délai moyen d'achèvement de chaque étape. Il affiche également les indicateurs clés de l'analyse du flux de valeur : délai d'exécution, durée de cycle, nouveaux tickets, validations et déploiements. Vous pouvez utiliser ces indicateurs pour identifier des axes d'amélioration des étapes de votre chaîne de valeur.
Le tableau de bord des métriques DORA
Pour afficher les métriques de performance qui mesurent l'efficacité des pratiques de développement et de livraison de votre entreprise, GitLab fournit le tableau de bord des métriques DORA (DevOps Research and Assessment), qui affiche quatre métriques clés : Fréquence de déploiement, Délai d'exécution des modifications, Délai de rétablissement du service et Taux d'échec des modifications. La fréquence de déploiement mesure la fréquence à laquelle votre entreprise déploie du code en production ou le publie à destination des utilisateurs finaux. Le délai d'exécution des modifications mesure le temps nécessaire pour passer du code validé au code exécuté avec succès en production. Le délai de rétablissement du service mesure le temps nécessaire pour rétablir les services au niveau où ils étaient auparavant, en cas d'incident. Enfin, le taux d'échec des modifications correspond au pourcentage de modifications apportées à l'environnement de production ou aux versions destinées aux utilisateurs, qui ont entraîné une dégradation du service (par exemple, une détérioration ou une panne) et ont ensuite nécessité des mesures correctives (solution corrective d'urgence, restauration d'une version antérieure, correctif). Ces quatre métriques clés mesurent l'efficacité de vos processus actuels et vous donnent la possibilité d'améliorer les facteurs et fonctionnalités permettant de soutenir le travail de vos équipes.
La personnalisation de votre tableau de bord
Le tableau de bord des flux de valeur est un autre tableau de bord personnalisable qui permet aux décideurs d'identifier les tendances, les modèles et les opportunités d'amélioration des processus de développement logiciel. Il affiche les métriques DORA suivies des indicateurs d'efficacité du processus d'analyse des flux de valeur et du nombre de vulnérabilités critiques et élevées pour le mois en cours, les deux mois précédents et les six derniers mois.
GitLab Duo peut également vous aider dans vos efforts d'amélioration continue. Par exemple, la fonctionnalité de prédiction de la chaîne de valeur générée par l'IA prend l'historique des données et utilise les tendances de l'ensemble de votre cycle de développement pour prédire le comportement futur de vos indicateurs de chaîne de valeur. Vous pouvez utiliser ces analyses prédictives dans vos efforts d'optimisation.
L'ensemble de ces tableaux de bord et les indicateurs dont ils rendent compte font partie de la boucle de rétroaction externe de GitLab Flow. Ils vous aident à réduire le risque de pannes imprévues dans l'environnement de production, ainsi qu'à améliorer et à optimiser vos applications et vos workflows DevSecOps.
La fonctionnalité d'analyse d'impact de l'IA
Pour mieux comprendre l'impact de l'utilisation de GitLab Duo (ou de l'IA) tout au long du cycle de développement, vous pouvez consulter le tableau de bord d'analyse d'impact de l'IA. Il vous indique comment l'adoption de la fonctionnalité de suggestions de code de GitLab Duo affecte d'autres indicateurs de performance, qualité et sécurité, sur les six derniers mois, tels que la durée de cycle, le délai d'exécution, la fréquence de déploiement, le taux d'échec des modifications et les failles de sécurité critiques au fil du temps.
L'analyse d'impact de l'IA mesure l'adoption, l'optimisation et les avantages que l'IA apporte aux équipes et à l'entreprise dans son ensemble, et permet également d'identifier des axes d'amélioration.
Pourquoi utiliser GitLab Flow ?
GitLab Flow est une approche préconisée, suivie par nos clients et utilisateurs du monde entier, qui offre les avantages suivants :
- Une productivité accrue grâce aux fonctionnalités d'automatisation fournies par GitLab, son interface utilisateur unique et son modèle de données unique, le tout exploité par GitLab Flow
- Des informations précises sur le cycle de vie DevSecOps complet pour soutenir l'amélioration continue
- Des tableaux de bord et indicateurs intégrés qui peuvent vous aider à optimiser vos applications et vos processus DevSecOps
- Une qualité accrue du code et l'amélioration de la fiabilité et de la disponibilité de vos applications
- Une meilleure sécurité des applications grâce à des scanners et des fonctionnalités de sécurité intégrés
- La conformité et la préparation aux audits via des fonctionnalités de conformité intégrées
- Des durées de cycle plus courtes qui peuvent vous aider à augmenter la fréquence de déploiement
- La revue de code en continu activée par la boucle de rétroaction interne de GitLab Flow
- La boucle de rétroaction interne de GitLab Flow peut vous aider à optimiser les mises à jour afin d'améliorer la qualité du code, ainsi que la fiabilité et la disponibilité de vos applications
- La boucle de rétroaction externe de GitLab Flow peut vous aider à améliorer vos applications ainsi que le cycle de développement lui-même
- Des niveaux élevés de collaboration entre les parties prenantes de votre entreprise
- L'intégration de la sécurité en amont pour identifier les vulnérabilités dans les applications avant qu'elles ne passent en production, et ainsi éviter les pannes coûteuses et imprévues
- La réduction des risques lors du déploiement en production grâce aux techniques de déploiement avancées et aux approches de livraisons échelonnées prises en charge par GitLab
- Des fonctionnalités alimentées par l'IA qui couvrent l'ensemble du cycle de développement et peuvent optimiser la productivité, la qualité du code, l'amélioration continue, la sécurité, la conformité et bien plus encore
- La prise en charge des applications cloud-native et autres types d'application
- La prise en charge multi-cloud pour les applications hybrides/multi-cloud
Pour commencer, tirer parti de la fonctionnalité Auto DevOps de GitLab ou de certains de ses composants est un bon point de départ pour appliquer les principes de GitLab Flow à votre cycle de développement d'applications.
GitLab Flow et Auto DevOps
Auto DevOps applique GitLab Flow à l'ensemble des étapes et jobs associés. Vous pouvez le considérer comme un bon exemple pour l'instanciation de GitLab Flow.
Auto DevOps est une collection de modèles CI/CD prédéfinis et prêts à l'emploi qui détectent automatiquement le code source dont vous disposez. Basés sur les bonnes pratiques, ces modèles détectent, compilent, testent, déploient et surveillent automatiquement vos applications.
Le pipeline Auto DevOps intègre la sécurité en amont pour détecter et prévenir les défauts le plus tôt possible dans le processus de livraison de logiciels. Il déploie ensuite l'application en préproduction pour vérification, puis en production de manière incrémentielle/planifiée.
Auto DevOps vous permet de démarrer rapidement, en augmentant la productivité des développeurs. Vous pouvez le personnaliser facilement en fonction de vos besoins, grâce à la prise en charge des frameworks et des langages de programmation les plus courants. Auto DevOps étant modulaire, personnalisable et extensible, vous pouvez utiliser certains de ses composants dans vos pipelines ou l'appliquer en totalité à votre application.
Conclusion
Combinez GitLab Flow et GitLab Duo dès aujourd'hui pour améliorer considérablement l'efficacité de votre workflow, à chaque étape du cycle de développement logiciel. Ce duo améliore la productivité, la fréquence des déploiements, la qualité du code et la sécurité dans son ensemble, ainsi que la résilience et la disponibilité de l'environnement de production.
Pour voir un workflow en action qui combine GitLab Flow et GitLab Duo, et découvrir ses avantages, regardez la vidéo suivante :