Les environnements de cycle de vie gérés de GitLab permettent de résoudre ces défis liés aux tests virtuels. Grâce à l'automatisation des environnements virtuels, GitLab accélère les cycles de développement des systèmes embarqués sans configuration complexe ni augmentation des coûts.

→ Essayez GitLab Ultimate et GitLab Duo Enterprise gratuitement.

Défis posés par les tests virtuels

Les environnements de test virtuels sont des configurations matérielles simulées qui reproduisent le comportement des systèmes embarqués dans des conditions réelles. De plus, ils offrent la possibilité de réduire les goulots d'étranglement matériels. Les équipes peuvent tester un micrologiciel sur des processeurs simulés, exécuter des tests Model-in-the-Loop (MIL) dans MATLAB/Simulink ou vérifier le logiciel sur des systèmes embarqués virtuels sans attendre l'accès au matériel physique.

Cependant, les équipes implémentent souvent les environnements virtuels au moyen de deux approches courantes, qui entraînent des défis non viables.

Première approche : environnements de cycle de vie des pipelines

Les environnements de cycle de vie des pipelines recréent l'ensemble de la configuration de test pour chaque exécution CI/CD. Lorsque des modifications de code déclenchent votre pipeline CI/CD, le système provisionne l'infrastructure, installe les simulations logicielles et configure tout depuis le début avant d'exécuter les tests.

Cette approche fonctionne pour des scénarios simples, mais perd en efficacité à mesure que la complexité augmente. Prenons par exemple les tests Software-in-the-Loop (SIL) dans un environnement virtuel complexe. Chaque exécution de pipeline nécessite une recréation complète de l'environnement avec provisionnement des processeurs virtuels, installations des chaînes d'outils et configurations cibles. Ces processus peuvent prendre un temps considérable.

De plus, à mesure que les systèmes embarqués nécessitent des configurations matérielles virtuelles plus sophistiquées, les coûts de provisionnement augmentent rapidement.

Pour éviter les coûts liés aux configurations et les délais, de nombreuses équipes se tournent vers des environnements avec une longue durée de vie qui persistent entre les exécutions de tests, mais ces derniers présentent des inconvénients.

Seconde approche : environnements avec une longue durée de vie

Les environnements avec une longue durée de vie sont persistants pour éviter une reconstruction constante. Les équipes de développement commencent par demander ces environnements aux équipes informatiques ou DevOps. Ils doivent ensuite attendre leur approbation, puis ont besoin que quelqu'un provisionne manuellement l'infrastructure. Ces environnements sont liés à des développeurs ou équipes plutôt qu'à des modifications de code spécifiques, et ils prennent en charge le travail de développement continu sur plusieurs projets.

Bien que cette approche élimine les coûts de reconstruction, elle multiplie les environnements, qui s'accumulent sans date de fin claire. Les coûts d'infrastructure augmentent à mesure que les environnements consomment des ressources.

Les environnements avec une longue durée de vie souffrent également d'une dégradation de configuration : les environnements conservent des paramètres, des données en cache ou des versions logicielles de tests précédents qui peuvent affecter les résultats ultérieurs. Un test qui devrait échouer finit par réussir en raison des données persistantes issues des tests précédents.

En fin de compte, la gestion des environnements avec une longue durée de vie est un processus manuel qui ralentit la vélocité de développement et augmente les coûts opérationnels.

GitLab propose une troisième approche : les « environnements de cycle de vie gérés », qui offrent les avantages des deux premières approches, sans les inconvénients.

Solution : les environnements de cycle de vie gérés

Les environnements de cycle de vie gérés de GitLab associent les configurations de test virtuelles aux merge requests (MR) plutôt qu'aux exécutions de pipeline ou aux équipes de développement. Ils peuvent être considérés comme des « environnements de test MR gérés ». Lorsque vous créez une merge request pour une nouvelle fonctionnalité, GitLab orchestre automatiquement le provisionnement des environnements de test virtuels nécessaires, qui sont maintenus tout au long du processus de développement de la fonctionnalité.

Avantages clés

• Environnements persistants sans reconstruction : le même environnement virtuel gère plusieurs exécutions de pipeline pendant que vous itérez sur votre fonctionnalité. Que vous exécutiez des tests MIL dans MATLAB/Simulink ou des tests SIL sur des processeurs embarqués spécialisés, l'environnement reste configuré et prêt.

• Nettoyage automatique : lorsque vous fusionnez votre fonctionnalité et supprimez la branche, GitLab déclenche automatiquement le nettoyage de l'environnement pour éliminer la multiplication des environnements.

• Source unique de vérité : la merge request enregistre tous les résultats de compilation, les résultats des tests et les métadonnées des environnements en un seul endroit. Les membres de l'équipe peuvent suivre les progrès et collaborer sans jongler entre différents outils ou feuilles de calcul.

Regardez cette vidéo pour découvrir comment les environnements de cycle de vie gérés fonctionnent en pratique :

<figure class="video_container"> <iframe src="https://www.youtube.com/embed/9tfyVPK5DuI?si=Kj_xXNo02bnFBDhy" frameborder="0" allowfullscreen="true"> </iframe> </figure>

GitLab automatise l'ensemble du workflow de test. Chaque fois que vous exécutez des tests de micrologiciel, GitLab orchestre les tests dans l'environnement virtuel adéquat, enregistre les résultats et fournit une visibilité complète sur chaque exécution de pipeline. Cette approche transforme les tests virtuels complexes d'un processus manuel sujet aux erreurs en workflows automatisés et fiables.

Résultat : les équipes profitent d'environnements réutilisables sans coûts incontrôlés. Elles augmentent l'efficacité et maintiennent des configurations de test propres et isolées pour chaque fonctionnalité.

Découvrez une démonstration des environnements de cycle de vie gérés avec un test de micrologiciel sur du matériel virtuel :

<figure class="video_container"> <iframe src="https://www.youtube.com/embed/iWdY-kTlpH4?si=D6rpoulr9sv6Sl6E" frameborder="0" allowfullscreen="true"> </iframe> </figure>

Impact métier

Les environnements de cycle de vie gérés de GitLab entraînent des améliorations mesurables dans les workflows de développement de systèmes embarqués. Les équipes qui exécutent des tests MIL dans MATLAB/Simulink et des tests SIL sur des processeurs spécialisés comme Infineon AURIX ou les systèmes BlackBerry QNX n'ont plus à gérer des reconstructions constantes d'environnements ou la multiplication incontrôlée des environnements. Ces configurations de test virtuelles complexes persistent tout au long du développement des fonctionnalités et exécutent un nettoyage automatique une fois terminées. Leurs avantages sont nombreux :

• Cycles de développement produit plus rapides
• Délai de mise sur le marché plus court
• Coûts d'infrastructure réduits
• Assurance qualité supérieure

→ Essayez GitLab Ultimate et GitLab Duo Enterprise gratuitement.

Imaginez pouvoir automatiser ce processus dans son intégralité. Dans ce guide pratique, je vous montre précisément comment GitLab Duo Agent Platform peut générer des modèles dbt complets en quelques minutes seulement, avec une structure, des tests et de la documentation.

→ Essayez GitLab Ultimate et GitLab Duo Enterprise gratuitement.

Ce que nous construisons

Notre équipe marketing souhaite gérer et optimiser efficacement ses investissements publicitaires. Reddit étant l'une des plateformes publicitaires utilisées, nous extrayons donc les données de l'API Reddit Ads vers notre plateforme de données d'entreprise Snowflake.

GitLab possède trois couches de stockage :

1. Couche raw : premier emplacement pour les données non traitées issues de sources externes, elles ne sont pas encore prêtes pour une utilisation métier.

2. Couche prep: première couche de transformation avec les modèles sources, les données ne sont toujours pas prêtes pour une utilisation générale.

3. Couche prod : données finales transformées prêtes pour l'utilisation métier et les rapports Tableau.

Dans ce guide, les données sont déjà dans la couche raw grâce à notre solution d'extraction Fivetran, et nous allons générer les modèles dbt qui gèrent les données de la couche prep jusqu'à la couche prod.

Sans avoir à écrire une seule ligne de code dbt nous-mêmes, nous aurons à la fin de ce guide :

• Des modèles sources dans la couche prep

• Des modèles workspace dans la couche prod

• Des configurations dbt complètes pour les 13 tables (soit 112 colonnes) du jeu de données Reddit Ads

• Des requêtes de test pour valider les résultats

Le processus complet prendra moins de 10 minutes, comparé aux heures habituellement nécessaires du processus manuel.

Voici les étapes à suivre :

1. Préparer la structure des données

Avant que GitLab Duo ne puisse générer nos modèles, il doit comprendre la structure complète des tables. La clé est d'exécuter une requête sur le schéma d'informations de Snowflake, car nous étudions actuellement comment connecter GitLab Duo via Model Context Protocol (MCP) à notre instance Snowflake :

SELECT 
    table_name,
    column_name,
    data_type,
    is_nullable,
    CASE 
        WHEN is_nullable = 'NO' THEN 'PRIMARY_KEY'
        ELSE NULL 
    END as key_type
FROM raw.information_schema.columns
WHERE table_schema = 'REDDIT_ADS'
ORDER BY table_name, ordinal_position;

Cette requête contient :

• Tous les noms de tables et colonnes

• Les types de données pour une structure de modèle appropriée

• Les contraintes nullables

• L'identification des clés primaires (colonnes non-nullables dans ce jeu de données)

Conseil de pro : dans le jeu de données Reddit Ads, toutes les colonnes non-nullables servent de clés primaires, il s'agit là d'un modèle récurrent. Nous avons validé ce modèle en vérifiant des tables comme ad_group, qui possèdent deux colonnes non-nullables (account_id et id) toutes deux marquées comme clés primaires. L'exécution de cette requête a renvoyé 112 lignes de métadonnées que j'ai exportées dans un fichier CSV pour la génération de modèles. Bien que cette étape manuelle fonctionne bien aujourd'hui, nous étudions une intégration directe de GitLab Duo avec notre plateforme de données via MCP pour automatiser entièrement ce processus.

2. Configurer GitLab Duo

Il existe deux façons d'interagir avec GitLab Duo :

1. La fonction chat de l'interface web

2. Le plugin Visual Studio Code

Nous avons choisi le plugin VS Code, car nous pouvons exécuter les modèles dbt localement pour les tester.

3. Entrer le prompt « magique »

Voici le prompt exact que nous avons utilisé pour générer tout le code dbt :

Create dbt models for all the tables in the file structure.csv.

I want to have the source models created, with a filter that dedupes the data based on the primary key. Create these in a new folder reddit_ads.
I want to have workspace models created and store these in the workspace_marketing schema.

Take this MR as example: [I've referenced to previous source implementation]. Here is the same done for Source A, but now it needs to be done for Reddit Ads. 

Please check the dbt style guide when creating the code: https://handbook.gitlab.com/handbook/enterprise-data/platform/dbt-guide/

Les éléments essentiels suivants ont garanti l'efficacité du prompt :

• Des spécifications claires pour les modèles sources et workspace

• Un exemple de référence d'une merge request similaire précédente

• Une référence au guide de style pour garantir la qualité et la cohérence du code

• Un ciblage spécifique du schéma pour une organisation correcte

4. Le processus de GitLab Duo

Après avoir soumis le prompt, GitLab Duo s'est mis au travail. Le processus de génération complet a pris quelques minutes, durant lesquelles GitLab Duo a :

1. Lu et analysé le fichier CSV d'intrant.

2. Examiné les structures des tables à partir des métadonnées.

3. Référencé notre guide de style dbt pour les normes de codage.

4. Pris en compte la merge request similaire pour proposer une structure correcte.

5. Généré les modèles sources pour les 13 tables.

6. Créé les modèles workspace pour les 13 tables.

7. Généré les fichiers dbt complémentaires :

   • Configuration sources.yml
   • Fichiers schema.yml avec tests et documentation
   • Mise à jour de dbt_project.yml avec les références de schéma

Les résultats

Les résultats sont remarquables :

• 1 fichier modifié : dbt_project.yml (ajout de la configuration du schéma reddit_ads)

• 29 nouveaux fichiers :

  • 26 modèles dbt (13 sources + 13 workspaces)
  • 3 fichiers YAML

• Près de 900 lignes de code générées automatiquement

• Tests de données intégrés, avec des contraintes uniques sur les colonnes de clé primaire

• Descriptions génériques pour tous les modèles et colonnes

• Logique de déduplication appropriée dans les modèles sources

• Structure de code propre et cohérente conformément au guide de style GitLab dbt

transform/snowflake-dbt/
├── dbt_project.yml                                                    [MODIFIED]
└── models/
    ├── sources/
    │   └── reddit_ads/
    │       ├── reddit_ads_ad_group_source.sql                        [NEW]
    │       ├── reddit_ads_ad_source.sql                              [NEW]
    │       ├── reddit_ads_business_account_source.sql                [NEW]
    │       ├── reddit_ads_campaign_source.sql                        [NEW]
    │       ├── reddit_ads_custom_audience_history_source.sql         [NEW]
    │       ├── reddit_ads_geolocation_source.sql                     [NEW]
    │       ├── reddit_ads_interest_source.sql                        [NEW]
    │       ├── reddit_ads_targeting_community_source.sql             [NEW]
    │       ├── reddit_ads_targeting_custom_audience_source.sql       [NEW]
    │       ├── reddit_ads_targeting_device_source.sql                [NEW]
    │       ├── reddit_ads_targeting_geolocation_source.sql           [NEW]
    │       ├── reddit_ads_targeting_interest_source.sql              [NEW]
    │       ├── reddit_ads_time_zone_source.sql                       [NEW]
    │       ├── schema.yml                                            [NEW]
    │       └── sources.yml                                           [NEW]
    └── workspaces/
        └── workspace_marketing/
            └── reddit_ads/
                ├── schema.yml                                        [NEW]
                ├── wk_reddit_ads_ad.sql                              [NEW]
                ├── wk_reddit_ads_ad_group.sql                        [NEW]
                ├── wk_reddit_ads_business_account.sql                [NEW]
                ├── wk_reddit_ads_campaign.sql                        [NEW]
                ├── wk_reddit_ads_custom_audience_history.sql         [NEW]
                ├── wk_reddit_ads_geolocation.sql                     [NEW]
                ├── wk_reddit_ads_interest.sql                        [NEW]
                ├── wk_reddit_ads_targeting_community.sql             [NEW]
                ├── wk_reddit_ads_targeting_custom_audience.sql       [NEW]
                ├── wk_reddit_ads_targeting_device.sql                [NEW]
                ├── wk_reddit_ads_targeting_geolocation.sql           [NEW]
                ├── wk_reddit_ads_targeting_interest.sql              [NEW]
                └── wk_reddit_ads_time_zone.sql                       [NEW]

Exemple de code généré

Voici un exemple de la qualité du code généré. Pour la table time_zone, GitLab Duo a créé :

Un modèle source de la couche prep

WITH source AS (
  SELECT *
  FROM {{ source('reddit_ads','time_zone') }}
  QUALIFY ROW_NUMBER() OVER (PARTITION BY id ORDER BY _fivetran_synced DESC) = 1
),

renamed AS (
  SELECT
    id::VARCHAR                               AS time_zone_id,
    code::VARCHAR                             AS time_zone_code,
    dst_offset::NUMBER                        AS time_zone_dst_offset,
    is_dst_active::BOOLEAN                    AS is_time_zone_dst_active,
    name::VARCHAR                             AS time_zone_name,
    offset::NUMBER                            AS time_zone_offset,
    _fivetran_synced::TIMESTAMP               AS fivetran_synced_at
  FROM source
)

SELECT * FROM renamed

Schema.yml

models:
  - name: reddit_ads_time_zone_source
    description: Time zone data from Reddit Ads system
    columns:
      - name: time_zone_id
        description: Unique identifier for time zone records
        data_tests:
          - unique
          - not_null
      - name: time_zone_code
        description: Code for the time zone
      - name: time_zone_dst_offset
        description: Daylight saving time offset for the time zone
      - name: is_time_zone_dst_active
        description: Flag indicating if daylight saving time is active
      - name: time_zone_name
        description: Name of the time zone
      - name: time_zone_offset
        description: Offset for the time zone
      - name: fivetran_synced_at
        description: Timestamp when the record was last synced by Fivetran

Source.yml

sources:
  - name: reddit_ads
    database: RAW
    schema: reddit_ads
    loaded_at_field: _fivetran_synced
    loader: fivetran
    description: Reddit Ads data

    quoting:
      database: true
      schema: false
      identifier: false

    tables:
      - name: time_zone

Modèle workspace

WITH source AS (
  SELECT *
  FROM {{ ref('reddit_ads_time_zone_source') }}
)

SELECT * FROM source

5. Valider la qualité

Une fois que le code semblait correct, nous avons effectué un push vers la merge request et exécuté le pipeline de test CI pour tester le code et valider les résultats. Nous avons demandé à GitLab Duo de créer une requête de validation :

Create a test query to test the row counts between the raw layer and the workspace layer. Keep in mind that we do deduplication, so we can compare both using distinct on the primary keys.

L'IA a généré une requête de validation complète qui :

• Compare le nombres de lignes entre les couches raw et workspace.

• Prend en compte la logique de déduplication.

• Teste les 13 tables.

• Calcule les pourcentages de rétention de données.

<details> <summary>Requête SQL de test générée</summary>

-- Reddit Ads Row Count Validation Test
-- Compares distinct counts between RAW layer and WORKSPACE_MARKETING layer
-- Accounts for deduplication logic in source models

WITH raw_counts AS (
  -- Single primary key tables
  SELECT 'ad' AS table_name, COUNT(DISTINCT id) AS raw_count
  FROM RAW.REDDIT_ADS.AD
  
  UNION ALL
  
  SELECT 'business_account' AS table_name, COUNT(DISTINCT id) AS raw_count
  FROM RAW.REDDIT_ADS.BUSINESS_ACCOUNT
  
  UNION ALL
  
  SELECT 'campaign' AS table_name, COUNT(DISTINCT id) AS raw_count
  FROM RAW.REDDIT_ADS.CAMPAIGN
  
  UNION ALL
  
  SELECT 'custom_audience_history' AS table_name, COUNT(DISTINCT id) AS raw_count
  FROM RAW.REDDIT_ADS.CUSTOM_AUDIENCE_HISTORY
  
  UNION ALL
  
  SELECT 'geolocation' AS table_name, COUNT(DISTINCT id) AS raw_count
  FROM RAW.REDDIT_ADS.GEOLOCATION
  
  UNION ALL
  
  SELECT 'interest' AS table_name, COUNT(DISTINCT id) AS raw_count
  FROM RAW.REDDIT_ADS.INTEREST
  
  UNION ALL
  
  SELECT 'time_zone' AS table_name, COUNT(DISTINCT id) AS raw_count
  FROM RAW.REDDIT_ADS.TIME_ZONE
  
  -- Composite primary key tables
  UNION ALL
  
  SELECT 'ad_group' AS table_name, COUNT(DISTINCT CONCAT(account_id, '|', id)) AS raw_count
  FROM RAW.REDDIT_ADS.AD_GROUP
  
  UNION ALL
  
  SELECT 'targeting_community' AS table_name, COUNT(DISTINCT CONCAT(ad_group_id, '|', community_id)) AS raw_count
  FROM RAW.REDDIT_ADS.TARGETING_COMMUNITY
  
  UNION ALL
  
  SELECT 'targeting_custom_audience' AS table_name, COUNT(DISTINCT CONCAT(ad_group_id, '|', custom_audience_id)) AS raw_count
  FROM RAW.REDDIT_ADS.TARGETING_CUSTOM_AUDIENCE
  
  UNION ALL
  
  SELECT 'targeting_device' AS table_name, COUNT(DISTINCT _fivetran_id) AS raw_count
  FROM RAW.REDDIT_ADS.TARGETING_DEVICE
  
  UNION ALL
  
  SELECT 'targeting_geolocation' AS table_name, COUNT(DISTINCT CONCAT(ad_group_id, '|', geolocation_id)) AS raw_count
  FROM RAW.REDDIT_ADS.TARGETING_GEOLOCATION
  
  UNION ALL
  
  SELECT 'targeting_interest' AS table_name, COUNT(DISTINCT CONCAT(ad_group_id, '|', interest_id)) AS raw_count
  FROM RAW.REDDIT_ADS.TARGETING_INTEREST
),

workspace_counts AS (
  -- Workspace layer counts using primary keys from schema.yml
  SELECT 'ad' AS table_name, COUNT(DISTINCT ad_id) AS workspace_count
  FROM REDDIT_DBT_MODEL_GENERATION_PROD.WORKSPACE_MARKETING.WK_REDDIT_ADS_AD
  
  UNION ALL
  
  SELECT 'business_account' AS table_name, COUNT(DISTINCT business_account_id) AS workspace_count
  FROM REDDIT_DBT_MODEL_GENERATION_PROD.WORKSPACE_MARKETING.WK_REDDIT_ADS_BUSINESS_ACCOUNT
  
  UNION ALL
  
  SELECT 'campaign' AS table_name, COUNT(DISTINCT campaign_id) AS workspace_count
  FROM REDDIT_DBT_MODEL_GENERATION_PROD.WORKSPACE_MARKETING.WK_REDDIT_ADS_CAMPAIGN
  
  UNION ALL
  
  SELECT 'custom_audience_history' AS table_name, COUNT(DISTINCT custom_audience_id) AS workspace_count
  FROM REDDIT_DBT_MODEL_GENERATION_PROD.WORKSPACE_MARKETING.WK_REDDIT_ADS_CUSTOM_AUDIENCE_HISTORY
  
  UNION ALL
  
  SELECT 'geolocation' AS table_name, COUNT(DISTINCT geolocation_id) AS workspace_count
  FROM REDDIT_DBT_MODEL_GENERATION_PROD.WORKSPACE_MARKETING.WK_REDDIT_ADS_GEOLOCATION
  
  UNION ALL
  
  SELECT 'interest' AS table_name, COUNT(DISTINCT interest_id) AS workspace_count
  FROM REDDIT_DBT_MODEL_GENERATION_PROD.WORKSPACE_MARKETING.WK_REDDIT_ADS_INTEREST
  
  UNION ALL
  
  SELECT 'time_zone' AS table_name, COUNT(DISTINCT time_zone_id) AS workspace_count
  FROM REDDIT_DBT_MODEL_GENERATION_PROD.WORKSPACE_MARKETING.WK_REDDIT_ADS_TIME_ZONE
  
  -- Composite primary key tables
  UNION ALL
  
  SELECT 'ad_group' AS table_name, COUNT(DISTINCT CONCAT(ad_group_account_id, '|', ad_group_id)) AS workspace_count
  FROM REDDIT_DBT_MODEL_GENERATION_PROD.WORKSPACE_MARKETING.WK_REDDIT_ADS_AD_GROUP
  
  UNION ALL
  
  SELECT 'targeting_community' AS table_name, COUNT(DISTINCT CONCAT(targeting_community_ad_group_id, '|', targeting_community_id)) AS workspace_count
  FROM REDDIT_DBT_MODEL_GENERATION_PROD.WORKSPACE_MARKETING.WK_REDDIT_ADS_TARGETING_COMMUNITY
  
  UNION ALL
  
  SELECT 'targeting_custom_audience' AS table_name, COUNT(DISTINCT CONCAT(targeting_custom_audience_ad_group_id, '|', targeting_custom_audience_id)) AS workspace_count
  FROM REDDIT_DBT_MODEL_GENERATION_PROD.WORKSPACE_MARKETING.WK_REDDIT_ADS_TARGETING_CUSTOM_AUDIENCE
  
  UNION ALL
  
  SELECT 'targeting_device' AS table_name, COUNT(DISTINCT targeting_device_fivetran_id) AS workspace_count
  FROM REDDIT_DBT_MODEL_GENERATION_PROD.WORKSPACE_MARKETING.WK_REDDIT_ADS_TARGETING_DEVICE
  
  UNION ALL
  
  SELECT 'targeting_geolocation' AS table_name, COUNT(DISTINCT CONCAT(targeting_geolocation_ad_group_id, '|', targeting_geolocation_id)) AS workspace_count
  FROM REDDIT_DBT_MODEL_GENERATION_PROD.WORKSPACE_MARKETING.WK_REDDIT_ADS_TARGETING_GEOLOCATION
  
  UNION ALL
  
  SELECT 'targeting_interest' AS table_name, COUNT(DISTINCT CONCAT(targeting_interest_ad_group_id, '|', targeting_interest_id)) AS workspace_count
  FROM REDDIT_DBT_MODEL_GENERATION_PROD.WORKSPACE_MARKETING.WK_REDDIT_ADS_TARGETING_INTEREST
)

-- Final comparison with validation results
SELECT 
  r.table_name,
  r.raw_count,
  w.workspace_count,
  r.raw_count - w.workspace_count AS count_difference,
  CASE 
    WHEN r.raw_count = w.workspace_count THEN '✅ PASS'
    WHEN r.raw_count > w.workspace_count THEN '⚠️ RAW > WORKSPACE (Expected due to deduplication)'
    ELSE '❌ FAIL - WORKSPACE > RAW (Unexpected)'
  END AS validation_status,
  ROUND((w.workspace_count::FLOAT / r.raw_count::FLOAT) * 100, 2) AS data_retention_percentage
FROM raw_counts r
JOIN workspace_counts w ON r.table_name = w.table_name
ORDER BY r.table_name;

</details>

L'exécution de cette requête a montré :

• Aucune différence dans le nombre de lignes après déduplication

• 100% de rétention des données sur toutes les tables

• La réussite de tous les tests

Bilan : gain de temps considérable

• Approche traditionnelle : 6-8 heures de codage manuel, tests et débogage

• Approche avec GitLab Duo : 6-8 minutes de génération et temps de revue

L'efficacité des équipes de développement est bien meilleure (de 6-8 heures à 6-8 minutes), et la qualité du code reste élevée.

Bonnes pratiques

Sur la base de cette expérience, voici nos recommandations clés :

Préparez vos métadonnées

• Extrayez les structures complètes des tables avec les types de données et les contraintes.

• Identifiez les clés primaires et les relations en amont.

• Exportez des fichiers CSV d'intrant propres et bien formatés.

Remarque : en connectant GitLab Duo via MCP à vos (méta)données, vous pourriez éviter cette étape manuelle.

Fournissez un contexte clair

• Indiquez des merge requests existantes à titre d'exemple si possible.

• Précisez vos normes de codage et guides de style.

• Explicitez la structure des dossiers et les conventions de nommage.

Validez minutieusement

• Créez toujours des requêtes de validation pour l'intégrité des données.

• Testez localement avant de fusionner.

• Exécutez votre pipeline CI/CD pour détecter tout problème.

Exploitez l'IA pour les tâches de suivi

• Générez automatiquement des requêtes de test.

• Créez des templates de documentation.

• Construisez des scripts de validation.

Prochaines étapes

Cet article montre comment les outils de développement alimentés par l'IA comme GitLab Duo transforment également les workflows d'ingénierie des données. La capacité de générer des centaines de lignes de code prêtes pour la production en quelques minutes, avec tests complets, documentation et structure appropriée, représente un changement fondamental dans notre approche des tâches répétitives.

En exploitant l'IA pour gérer les aspects répétitifs de la création de modèles dbt, les Data Engineers peuvent se concentrer sur des activités à plus forte valeur ajoutée comme la stratégie de modélisation des données, l'optimisation des performances et l'implémentation de la logique métier.

Prêt à essayer par vous-même ? Commencez avec un petit jeu de données, préparez soigneusement vos métadonnées et observez comment GitLab Duo transforme des heures de travail en seulement quelques minutes.

→ Essayez GitLab Ultimate et GitLab Duo Enterprise gratuitement.

Pour aller plus loin

• GitLab 18.3 : expansion de l'orchestration IA dans l'ingénierie logicielle

• GitLab Duo Agent Platform (bêta) : votre orchestration IA nouvelle génération

L'impact négatif sur la productivité est colossal. Les pipelines CI/CD sont paralysés, en attendant que les clonages de dépôts se terminent. Les coûts d'infrastructure explosent, avec des ressources de calcul inutilisées. La frustration ressentie par les équipes de développement augmente, car le changement de contexte est devenu la norme.

Et s'il était possible de réduire cette attente de 95 minutes à seulement 6 minutes et de diminuer de 93 % les temps de clonage grâce à des techniques éprouvées ?

Git Much Faster est un script complet de benchmarking et d'optimisation qui révolutionne la gestion des dépôts Git volumineux. Né d'une expérience concrète d'optimisation des workflows de développement de systèmes embarqués, il fournit des stratégies concrètes pour améliorer de façon mesurable les performances des clonages Git standard et des configurations Git optimisées, et tirer parti de l'outil Scalar intégré à Git.

Découvrez dans cet article comment réduire drastiquement les temps de clonage Git à l'aide de stratégies d'optimisation et explorez les résultats de benchmarks de performance réels issus de dépôts majeurs (tels que le noyau Linux et Chromium). Vous apprendrez également comment mettre en œuvre ces optimisations en toute sécurité dans vos environnements de développement et CI/CD.

Git Much Faster : présentation du projet

Le script Git Much Faster vous permet d’effectuer un benchmark des différentes approches d'optimisation du clonage sur votre environnement cible, qu'il s'agisse d'un poste de travail classique, d'un outil d'intégration continue, de solutions de développement cloud ou de clonages spécialisés pour GitOps. Il intègre également des paramètres de configuration optimisés pour des clonages ultra-rapides, que vous pouvez utiliser comme point de départ et ajuster selon vos besoins, ou désactiver si certaines configurations ne sont pas adaptées à votre cas d'utilisation.

Git Much Faster répond à une problématique réelle du comportement de clonage par défaut de Git, qui privilégie la sécurité au détriment de la rapidité. Cette approche convient aux dépôts de petite taille, mais elle n'est pas adaptée aux codes sources volumineux ni aux ressources binaires étendues ou aux structures de monorepo complexes.

Cette problématique se manifeste dans des scénarios de plus en plus courants. En effet, les équipes de développement de systèmes embarqués héritent de dépôts avec de nombreux binaires de micrologiciels hérités, bootloaders et SDK de fournisseurs stockés directement dans le contrôle de version. Les applications web accumulent des années de ressources marketing et de fichiers de design. Les projets de développement de jeux vidéo contiennent des modèles 3D et fichiers audio volumineux avec des dépôts qui atteignent alors plusieurs dizaines de gigaoctets.

Les pipelines CI/CD sont particulièrement affectés : chaque job nécessite un nouveau clonage du dépôt, et lorsque cette opération dure entre 20 et 90 minutes, le workflow complet de développement est paralysé. Les coûts d'infrastructure sont également multipliés, car les ressources de calcul restent inutilisées pendant ces longues opérations de clonage.

Git Much Faster apporte la solution grâce à un benchmark complet comparant quatre stratégies distinctes : le clonage Git standard (historique complet comme base de référence), le clonage Git optimisé (configurations personnalisées avec compression désactivée et checkout parcellaire (« sparse »)), le clonage Git avec Scalar (clonage partiel intégré) et l'évaluation du répertoire actuel (analyse des dépôts existants sans nouveau clonage).

Git Much Faster fournit des benchmarks mesurables et reproductibles dans des environnements AWS contrôlés, afin d'éliminer les variables qui rendent habituellement les tests de performance peu fiables. Sa véritable puissance réside dans sa capacité à exécuter tous les benchmarks, quel que soit l'environnement cible. Ainsi, même si certains développeurs souffrent de connexions réseau trop lentes, vous pouvez identifier la meilleure stratégie d'optimisation du clonage adaptée à chaque situation.

→ Essayez GitLab Ultimate et GitLab Duo Enterprise gratuitement.

Stratégies d'optimisation

Git Much Faster est particulièrement efficace, car il s'attaque aux principaux goulots d'étranglement de Git à l'aide d'une approche multicouche qui cible à la fois les transferts réseau, l'utilisation du processeur et les modèles de stockage.

Les gains les plus importants reposent sur deux optimisations majeures. Premièrement, core.compression=0 : cette option désactive la compression, gourmande en ressources CPU lors des transferts réseau. Sur les réseaux modernes à haut débit, les cycles CPU nécessaires pour la compression des données dépasse souvent les économies réalisées sur la bande passante. À elle seule, cette optimisation réduit le temps de clonage de 40 % à 60 %.

Deuxièmement, http.postBuffer=1024M : Git utilise par défaut un tampon HTTP relativement petit. L'augmentation de sa taille permet de traiter des opérations plus importantes sans les fragmenter en plusieurs requêtes, ce qui réduit considérablement la surcharge du protocole, surtout pour les gros dépôts.

Git Much Faster tire également parti des clonages superficiels (« shallow ») (--depth=1) qui ne récupèrent que le dernier commit et des clonages partiels (--filter=blob:none) qui diffèrent le téléchargement du contenu des fichiers jusqu'au checkout. Les clonages superficiels réduisent le volume de données de 70 % à 90 % pour les dépôts matures, tandis que les clonages partiels s'avèrent particulièrement efficaces pour les dépôts contenant des binaires volumineux.

Le checkout parcellaire (« sparse ») offre un contrôle précis des fichiers extraits. Git Much Faster applique une exclusion complète de plus de 30 types de fichiers binaires (images, documents, archives, fichiers multimédias et exécutables), ce qui réduit la taille du répertoire de travail jusqu'à 78 % et maintient un accès complet au code source.

L'outil Scalar, intégré à Git depuis la version 2.38, combine un clonage partiel, un checkout parcellaire et une maintenance en arrière-plan. Cependant, les benchmarks révèlent que Scalar ne met pas en œuvre d'optimisations agressives pour la compression et la gestion de la mémoire tampon, qui génèrent pourtant les gains de performance les plus significatifs. En revanche, les tests montrent que l'approche optimisée personnalisée de Git Much Faster surpasse généralement Scalar de 48 % à 67 % tout en offrant des économies d'espace disque similaires.

Réduction de la charge système

En optimisant le clonage Git, Git Much Faster contribue également à réduire la charge totale du système en diminuant la taille des requêtes. GitLab s'appuie sur Gitaly Cluster pour assurer une mise à l'échelle horizontale spécialisée. Lorsque les clonages avec historique complet et les monorepos volumineux deviennent la norme, la charge sur Gitaly Cluster augmente fortement. En effet, chaque requête de clonage Git est traitée par un binaire côté serveur qui génère les « fichiers d'empaquetage » à transférer via le réseau. Étant donné que ces opérations Git impliquent l'exécution d'utilitaires de compression côté serveur, elles sollicitent simultanément le CPU, la mémoire et les opérations d'E/S.

Lorsque les opérations de clonage Git sont optimisées pour réduire la quantité totale de données transférées, la charge sur l'ensemble de la pile (client, réseau, service Gitaly et stockage) diminue. Résultat : toutes les couches s'accélèrent et leur coût est par conséquent réduit.

Résultats de performance

L'efficacité de Git Much Faster a été démontrée par des benchmarks rigoureux effectués sur différents dépôts à l'aide d'une infrastructure AWS homogène avec des instances ARM et des conditions réseau contrôlées.

Dépôt du noyau Linux (7,5 Go au total) : le clonage standard a duré 6 minutes et 29 secondes. Le clonage optimisé a duré 46,28 secondes, soit une amélioration de 88,1 %, et la taille du répertoire .git est passée de 5,9 Go à 284 Mo. Le clonage Scalar a duré 2 minutes et 21 secondes (soit une amélioration de 63,7 %), mais a été 67,3 % plus lent qu'avec l'approche optimisée.

Dépôt Chromium (60,9 Go au total) : le clonage standard a duré 95 minutes et 12 secondes. Le clonage optimisé a duré 6 minutes et 41 secondes, soit une amélioration spectaculaire de 93 %, et la taille du répertoire .git est passée de 55,7 Go à 850 Mo. Le clonage Scalar a duré 13 minutes et 3 secondes (soit une amélioration de 86,3 %), mais il reste 48,8 % plus lent qu'avec l'approche optimisée.

Dépôt du site web de GitLab (8,9 Go au total) : le clonage standard a duré 6 minutes et 23 secondes. Le clonage optimisé a duré 6,49 secondes, soit une amélioration remarquable de 98,3 %, et la taille du répertoire .git a été réduite à 37 Mo. Le clonage Scalar a duré 33,60 secondes (soit une amélioration de 91,2 %), mais il a été 80,7 % plus lent qu'avec l'approche optimisée.

Ce benchmarking révèle des tendances claires : les dépôts volumineux enregistrent les améliorations les plus spectaculaires, les dépôts lourds en binaires bénéficient particulièrement du filtrage du checkout parcellaire (« sparse ») et l'approche d'optimisation personnalisée surpasse systématiquement à la fois les clonages Git standard et Scalar, quel que soit le type de dépôt.

Mise en œuvre

Pour tirer pleinement parti de Git Much Faster, il est essentiel de choisir la technique adaptée à chaque cas de figure et à la tolérance au risque. Si vos opérations de développement nécessitent un accès à tout le dépôt, privilégiez le clonage Git standard. Pour les workflows à forte intensité de lecture nécessitant un accès rapide au code actuel, déployez le clonage optimisé. Pour les pipelines CI/CD où la rapidité est primordiale, le clonage optimisé offre le gain de performance le plus avantageux.

Pour commencer, téléchargez et exécutez simplement le script suivant :

curl -L https://gitlab.com/gitlab-accelerates-embedded/misc/git-much-faster/-/raw/master/git-much-faster.sh -o ./git-much-faster.sh

# For benchmarking
bash ./git-much-faster.sh --methods=optimized,standard --repo=https://github.com/your-org/your-repo.git

Dans le cadre de tests effectués dans un environnement de production, le projet Git Much Faster inclut une infrastructure Terraform complète pour le déploiement sur AWS, ce qui élimine les variables qui faussent les résultats des tests en environnement local.

Les clonages optimisés nécessitent une attention particulière quant à leurs limites applicables. Les clonages superficiels (« shallow ») empêchent l'accès aux commits historiques, ce qui limite certaines opérations telles que git log sur l'historique des fichiers. Pour les équipes qui adoptent ces optimisations, il est recommandé de créer des configurations spécifiques, adaptées à une utilisation à fort volume. Par exemple, un développeur peut effectuer un clonage optimisé puis, si nécessaire, le convertir en clonage complet via git fetch --unshallow. De même, si un job CI nécessite l'accès à l'historique complet des commits (comme pour GitVersion), disposer de l'historique complet peut être nécessaire, mais un checkout pas forcément.

Cas d'utilisation

Git Much Faster s'avère particulièrement bénéfique dans les situations suivantes. Le développement de systèmes embarqués dont les projets stockent historiquement les fichiers de design de micrologiciels et de matériel compilés directement dans le contrôle de version. Ces dépôts contiennent souvent des flux binaires FPGA, des schémas de circuits imprimés ainsi que des distributions SDK de fournisseurs dont la taille peut atteindre plusieurs dizaines de gigaoctets. Les processus de compilation nécessitent fréquemment de cloner des dizaines de dépôts externes, ce qui multiplie l'impact sur les performances.

Les monorepos d'entreprise rencontrent des contraintes de performances lors des opérations Git, à mesure que les dépôts regroupent plusieurs projets et de très nombreuses données historiques. Les projets multimédias et riches en ressources font face à de nombreuses problématiques, comme déjà mentionné plus haut : les applications web accumulent des ressources marketing au fil des ans, tandis que le développement de jeux vidéo doit gérer d'énormes modèles 3D et fichiers audio qui font grimper la taille des dépôts au-delà de 100 Go. D'autres cas d'utilisation sont présentés directement dans le projet Git Much Faster.

Les pipelines CI/CD constituent le cas de figure le plus critique : chaque job CI basé sur un conteneur nécessite un nouveau clonage du dépôt. Lorsque cette opération prend entre 20 et 90 minutes, le workflow complet de développement devient impraticable.

Enfin, certains membres d'équipes de développement géographiquement dispersées peuvent faire face à des performances réseau extrêmement limitées ou très variables. L'optimisation du clonage Git contribue à réduire radicalement la taille des transferts.

Conclusion

L'optimisation du clonage Git constitue une véritable opportunité de transformation qui offre des améliorations mesurables : jusqu'à 93 % de réduction du temps de clonage et 98 % d'économie d'espace disque utilisé. Celles-ci changent profondément la façon dont les équipes de développement interagissent avec les codes sources.

L'idée clé est que le comportement conservateur par défaut de Git ne permet pas de bénéficier de performances optimales. En identifiant les goulots d'étranglement spécifiques (inefficacité des transferts réseau, compression gourmande en CPU, téléchargements de données superflues), les équipes de développement peuvent mettre en œuvre des optimisations ciblées qui produisent des résultats exceptionnels et transformateurs.

Prêt à transformer vos workflows Git ?

Consultez la documentation disponible dans le dépôt Git Much Faster, puis exécutez des benchmarks sur vos plus grands dépôts. Commencez par l'optimisation en lecture seule dans les pipelines CI/CD où les gains sont immédiats et les risques limités. À mesure que votre équipe gagne en confiance, étendez progressivement ces optimisation aux workflows de développement en vous appuyant sur les résultats mesurés.

L'avenir de l'optimisation des performances Git est ouvert, mais les principes de base restent pertinents : éliminer le travail inutile, optimiser les goulots d'étranglement, mesurer les résultats de manière rigoureuse. Les équipes qui maîtrisent ces concepts dès aujourd'hui seront en mesure de tirer parti de toutes les améliorations à venir dans l'écosystème Git.

→ Essayez GitLab Ultimate et GitLab Duo Enterprise gratuitement.

Cette version offre une amélioration majeure de l'expérience utilisateur globale de GitLab et de l'intégration de l'IA dans vos workflows. Une nouvelle interface avec des panneaux de suivi facilite la visualisation des données en contexte et garantit une visibilité permanente à GitLab Duo Chat sur toute la plateforme, partout où vous en avez besoin. Des agents spécialisés s'attaquent au tri des vulnérabilités et à la gestion des backlogs, tandis que les outils d’IA populaires s'intègrent encore plus harmonieusement dans les workflows agentiques. Nous avons également étendu nos fonctionnalités de sécurité pour vous aider à mieux identifier les vulnérabilités exploitables et les failles théoriques, distinguer les identifiants actifs de ceux expirés et analyser uniquement le code modifié pour favoriser la concentration des équipes de développement.

Les nouveautés de la version GitLab 18.5

La version 18.5 représente notre plus importante release de l'année : visionnez notre présentation en vidéo et découvrez plus de détails dans la suite de l'article.

<div style="padding:56.25% 0 0 0;position:relative;"><iframe src="https://player.vimeo.com/video/1128975773?badge=0&autopause=0&player_id=0&app_id=58479" frameborder="0" allow="autoplay; fullscreen; picture-in-picture; clipboard-write; encrypted-media; web-share" referrerpolicy="strict-origin-when-cross-origin" style="position:absolute;top:0;left:0;width:100%;height:100%;" title="GitLab_18.5 Release_101925_MP_v2"></iframe></div><script src="https://player.vimeo.com/api/player.js"></script>

<p></p>

Une expérience utilisateur moderne avec un accès rapide à GitLab Duo

GitLab 18.5 améliore l'expérience utilisateur GitLab avec une interface plus intuitive et pratique grâce à une nouvelle mise en page avec des panneaux de suivi.

Les panneaux de suivi présentent les informations côte à côte pour vous aider à traiter vos tâches en contexte. Lorsque vous cliquez sur un ticket dans la liste, ses détails s'affichent dans un panneau latéral. Vous pouvez ensuite ouvrir le panneau GitLab Duo Chat sur le côté droit de l'interface et l'utiliser comme un assistant à la demande afin de poser des questions à vos agents et de leur fournir des instructions contextuelles sur n'importe quelle page de GitLab. Nous avons également apporté d'autres améliorations subtiles à des fins d'ergonomie : la barre de recherche globale se trouve désormais dans le centre supérieur pour une meilleure accessibilité, tandis que les éléments de navigation globale (tickets assignés, merge requests, liste des tâches et icône utilisateur) sont affichés en haut à droite. Le menu de navigation gauche peut être réduit et s'étend pour offrir une gestion flexible de la barre latérale.

L'interface avec les panneaux de suivi sera « désactivée par défaut » dans GitLab 18.5 et pourra être activée sous votre icône utilisateur. Pour en savoir plus sur l'activation ou la désactivation de cette fonctionnalité, consultez notre documentation. N'hésitez pas à partager vos retours et à signaler tout problème. Nos équipes sont à l'écoute. Si vous appréciez cette nouvelle expérience, cette option devrait être supprimée dans la version 18.6 afin de standardiser l'interface avec les panneaux de suivi dans toute expérience utilisateur.

Mises à jour de GitLab Duo Agent Platform

GitLab Duo Security Analyst Agent : transformez le tri manuel des vulnérabilités en automatisation intelligente

GitLab Duo Security Analyst Agent automatise les flux de travail de gestion des vulnérabilités grâce à une analyse alimentée par l'IA afin de transformer des heures de tri manuel en automatisation intelligente. Il s'appuie sur les outils de gestion des vulnérabilités disponibles via GitLab Duo Agentic Chat et orchestre plusieurs outils, applique des politiques de sécurité et crée automatiquement des flux personnalisés pour les workflows récurrents.

Les équipes de sécurité peuvent non seulement accéder à des données de vulnérabilité enrichies, notamment les détails concernant les vulnérabilités ou expositions communes (CVE), l'analyse de la fonctionnalité d'atteignabilité statique et les informations de flux de code, mais aussi ignorer les faux positifs, confirmer les menaces, ajuster les niveaux de sévérité et créer des tickets associés pour correction au moyen de l'IA conversationnelle. L'agent réduit les clics répétitifs dans les tableaux de bord de vulnérabilités et remplace les scripts personnalisés par de simples commandes en langage naturel.

Par exemple, lorsqu'une analyse de sécurité révèle des dizaines de vulnérabilités, il suffit d'utiliser le prompte suivant : « Ignore les vulnérabilités avec reachable=FALSE et crée des tickets pour les failles critiques. » GitLab Duo Security Analyst Agent analyse les données de la fonctionnalité d'atteignabilité statique, applique les politiques de sécurité et effectue les opérations groupées en quelques instants : il gère des tâches qui nécessiteraient autrement des heures.

Alors que les outils de gestion des vulnérabilités individuels peuvent être accédés directement via GitLab Duo Agentic Chat pour des tâches spécifiques, GitLab Duo Security Analyst Agent orchestre ces outils de manière intelligente et automatise des workflows complexes en plusieurs étapes. Les outils de gestion des vulnérabilités sont disponibles via GitLab Duo Agentic Chat sur les instances GitLab Self-managed et GitLab.com, et GitLab Duo Security Analyst Agent est disponible uniquement sur GitLab.com pour la version 18.5, tandis que la disponibilité dans les environnements GitLab Duo Self-managed et GitLab Duo Dedicated arrivera avec notre prochaine version.

Découvrez notre démonstration :

<div style="padding:56.25% 0 0 0;position:relative;"><iframe src="https://player.vimeo.com/video/1128975984?badge=0&autopause=0&player_id=0&app_id=58479" frameborder="0" allow="autoplay; fullscreen; picture-in-picture; clipboard-write; encrypted-media; web-share" referrerpolicy="strict-origin-when-cross-origin" style="position:absolute;top:0;left:0;width:100%;height:100%;" title="18.5 Security Demo"></iframe></div><script src="https://player.vimeo.com/api/player.js"></script>

<p></p>

GitLab Duo Planner : transformez un backlog encombré en clarté stratégique

Gérer une livraison logicielle complexe nécessite de constamment changer de contexte entre les tâches de planification. GitLab Duo Planner propose une solution aux défis de planification concrets que les équipes affrontent chaque jour. Il agit comme votre assistant : il connaît le contexte de votre projet, notamment comment vous gérez les tickets, les epics et les merge requests. Contrairement aux assistants IA génériques, il est spécialement conçu avec une connaissance approfondie des workflows de planification de GitLab ainsi que des frameworks Agile et de priorisation pour vous aider à gérer effort, risque et alignement stratégique.

GitLab Duo Planner peut transformer des idées vagues en tâches de planification hiérarchisées et structurées, identifier les éléments obsolètes du backlog et rédiger des mises à jour exécutives. Imaginez que vous souhaitez réorganiser votre backlog, qui contient des centaines de tickets accumulés sur plusieurs mois. Il vous suffit de demander : « Identifie les éléments obsolètes du backlog et suggère des priorités. » En quelques secondes, vous recevrez un résumé structuré avec les tickets sans activité récente, les éléments avec des détails clés manquants, les doublons et les priorités recommandées en fonction des labels et jalons, avec des conseils exploitables.

Pour les équipes avec des roadmaps complexes, GitLab Duo Planner vise à éliminer des heures d'analyse manuelle et de changements de contexte et à accélérer la prise de décisions informées des responsables produit et d'ingénierie. Depuis la version 18.5, GitLab Duo Planner est actuellement en « lecture seule » : il peut analyser, planifier et émettre des suggestions, mais ne peut pas encore agir directement pour modifier quoi que ce soit. Veuillez consulter notre documentation pour plus d'informations.

Large catalogue d'agents : les outils IA populaires comme agents natifs GitLab

Dans GitLab 18.5, les agents IA populaires sont intégrés directement dans le catalogue IA. Par conséquent, des outils externes comme Claude, OpenAI Codex, Google Gemini CLI, Amazon Q Developer et OpenCode sont maintenant disponibles comme agents natifs GitLab. Les utilisateurs peuvent désormais découvrir, configurer et déployer ces agents via la même interface de catalogue unifiée utilisée pour les agents intégrés de GitLab, avec une synchronisation automatique des agents de base dans les catalogues de l'organisation.

Cette approche élimine la complexité de la configuration manuelle des agents : le catalogue est disponible en mode point-and-click, et la sécurité est maintenue à un niveau entreprise via les systèmes d'authentification et d'audit de GitLab. Les abonnements GitLab Duo Enterprise incluent désormais l'utilisation intégrée de Claude et Codex dans GitLab. Vous pouvez ainsi utiliser votre abonnement GitLab existant pour ces outils sans clé API séparée ni facturation supplémentaire. D'autres agents peuvent encore nécessiter des abonnements séparés et une configuration à mesure que nous finalisons nos plans d'intégration.

GitLab Duo Agent Platform sur GitLab Self-hosted (version bêta) : répondez aux exigences de souveraineté des données sans sacrifier la puissance de l'IA

GitLab 18.5 fait passer les capacités auto-hébergées de GitLab Duo Agent Platform de la version expérimentale à bêta pour que les organisations puissent exécuter des agents et flux IA entièrement dans leur propre infrastructure, un critère primordial pour les industries réglementées et les exigences de souveraineté des données. La version bêta inclut des configurations de délai d'attente dépassé améliorées et des paramètres de passerelle IA afin que les équipes puissent utiliser des agents IA pour les revues de code, les corrections de bugs et les implémentations de fonctionnalités avec une sécurité de niveau entreprise pour le code sensible.

Une sécurité plus intelligente et plus rapide : priorisez les risques réels et favorisez la concentration des équipes

GitLab 18.5 introduit de nouvelles fonctionnalités de sécurité applicative qui aident les équipes à se concentrer sur les risques exploitables, réduire le bruit et renforcer la sécurité de la chaîne d'approvisionnement logicielle. Ces mises à jour s'inscrivent dans notre engagement à intégrer la sécurité directement dans le processus de développement afin de garantir précision, vitesse et clarté sans perturber la concentration des équipes de développement.

Analyse de la fonctionnalité d'atteignabilité statique

Avec plus de 37 000 nouvelles CVE émises cette année, les équipes de sécurité font face à un volume écrasant de vulnérabilités et peinent à identifier lesquelles sont réellement exploitables. L'analyse de la fonctionnalité d'atteignabilité statique, désormais en disponibilité limitée, apporte une précision au niveau des bibliothèques et aide à identifier si le code vulnérable est réellement invoqué dans votre application et pas seulement présent dans les dépendances.

Avec notre score EPSS (Exploit Prediction Scoring System) récemment publié et notre base de données des vulnérabilités exploitées connues (Known Exploited Vulnerabilities ou KEV), les équipes de sécurité peuvent accélérer plus efficacement le tri des vulnérabilités et prioriser les risques réels pour renforcer la sécurité globale de la chaîne d'approvisionnement. Dans la version 18.5, nous ajoutons la prise en charge de Java, en plus de la prise en charge existante de Python, JavaScript et TypeScript.

Vérifications de la validité des secrets

Tout comme l'analyse d'atteignabilité statique aide les équipes à prioriser les vulnérabilités exploitables des dépendances open source, les vérifications de validité des secrets apportent le même niveau d'insight aux secrets exposés – actuellement disponible en bêta sur GitLab.com et GitLab Self-Managed. Pour les tokens de sécurité émis par GitLab, au lieu de vérifier manuellement si un identifiant ou une clé API divulgués sont actifs, GitLab distingue automatiquement les secrets actifs de ceux expirés directement dans le Rapport de vulnérabilité. Ceci permet aux équipes de sécurité et de développement de concentrer les efforts de remédiation sur les vrais risques. Le support pour les secrets émis par AWS et GCP est prévu pour les versions futures.

Règles personnalisées pour Advanced SAST

Advanced SAST fonctionne sur des règles informées par notre équipe de recherche en sécurité interne, conçues pour maximiser la précision dès le départ. Cependant, certaines équipes nécessitaient une flexibilité supplémentaire pour ajuster le moteur SAST à leur organisation spécifique. Avec les règles personnalisées pour Advanced SAST, les équipes AppSec peuvent définir une logique de détection atomique basée sur des modèles pour capturer des problèmes de sécurité spécifiques à leur organisation – comme signaler des appels de fonction interdits – tout en utilisant l'ensemble de règles sélectionné par GitLab comme base. Les personnalisations sont gérées via de simples fichiers TOML, tout comme les autres configurations d'ensemble de règles SAST. Bien que ces règles ne supportent pas l'analyse de taint, elles donnent aux organisations une plus grande flexibilité pour obtenir des résultats SAST précis.

Support des langages C et C++ pour Advanced SAST

Nous étendons notre couverture linguistique pour Advanced SAST pour inclure C et C++, qui sont des langages largement utilisés dans le développement de logiciels embarqués. Pour activer l'analyse, les projets doivent générer une base de données de compilation qui capture les commandes du compilateur et inclut les chemins utilisés pendant les builds. Ceci garantit que le scanner peut analyser et parser avec précision les fichiers sources, fournissant des résultats précis et contextuels qui aident les équipes de sécurité à identifier les vraies vulnérabilités dans le processus de développement. Les exigences d'implémentation pour C et C++ nécessitent des configurations spécifiques, qui peuvent être trouvées dans notre documentation. Le support Advanced SAST pour C et C++ est actuellement disponible en bêta.

Analyse SAST basée sur les différences

Les analyses SAST traditionnelles réanalysent des bases de code entières à chaque commit, ralentissant les pipelines et perturbant le flux des développeurs. L'expérience développeur est une considération critique qui peut faire ou défaire l'adoption des tests de sécurité applicative. L'analyse SAST basée sur les différences vise à accélérer les temps d'analyse en se concentrant uniquement sur le code modifié dans une merge request, réduisant l'analyse redondante et faisant remonter des résultats pertinents liés au travail du développeur. En alignant les analyses avec les changements de code réels, GitLab fournit un feedback plus rapide et plus ciblé qui aide à maintenir les développeurs dans leur flux tout en maintenant une couverture de sécurité solide.

Simplifiez les configurations API

Les workflows pilotés par API offrent puissance et flexibilité, mais ils peuvent aussi créer une complexité inutile pour les tâches que les équipes doivent effectuer régulièrement. La nouvelle interface Maven Virtual Registry apporte une couche UI à ces opérations.

Interface Maven Virtual Registry

La nouvelle interface web pour gérer les Maven Virtual Registries transforme les configurations API complexes en simplicité visuelle, offrant une expérience plus intuitive pour les administrateurs de packages et les ingénieurs de plateforme.

Auparavant, les équipes configuraient et maintenaient les registres virtuels uniquement via des appels API, ce qui rendait la maintenance de routine chronophage et nécessitait des connaissances spécialisées de la plateforme. La nouvelle interface supprime cette barrière, contribuant à rendre les tâches quotidiennes plus rapides et plus faciles.

Avec cette mise à jour, vous pouvez désormais :

• Créer des registres virtuels pour simplifier la configuration des dépendances
• Créer et ordonner des upstreams pour améliorer les performances et la conformité
• Parcourir et effacer les entrées de cache obsolètes directement dans l'UI

Cette expérience visuelle aide à réduire la charge opérationnelle et fournit aux équipes de développement un aperçu plus clair de la façon dont les dépendances sont résolues, leur permettant de prendre de meilleures décisions concernant les performances de build et les politiques de sécurité.

Regardez une démonstration :

<!-- blank line -->

<figure class="video_container">

<iframe src="https://www.youtube.com/embed/CiOZJPhAvaI?si=cYaoR_OIgqFKbyM2" frameborder="0" allowfullscreen="true"> </iframe>

</figure>

<!-- blank line -->

<p></p>

Nous invitons les clients entreprise à rejoindre le programme bêta Maven Virtual Registry et à partager leurs retours pour aider à façonner la version finale.

Une IA qui s'adapte à votre workflow

Cette version représente plus que de nouvelles capacités – il s'agit de choix et de contrôle. Regardez la vidéo de présentation ici :

<p></p>

<div style="padding:56.25% 0 0 0;position:relative;"><iframe src="https://player.vimeo.com/video/1128992281?badge=0&autopause=0&player_id=0&app_id=58479" frameborder="0" allow="autoplay; fullscreen; picture-in-picture; clipboard-write; encrypted-media; web-share" referrerpolicy="strict-origin-when-cross-origin" style="position:absolute;top:0;left:0;width:100%;height:100%;" title="18.5-tech-demo"></iframe></div><script src="https://player.vimeo.com/api/player.js"></script>

<p></p>

Les utilisateurs GitLab Premium et Ultimate peuvent commencer à utiliser ces capacités dès aujourd'hui sur GitLab.com et les environnements self-managed, avec une disponibilité pour les clients GitLab Dedicated prévue pour le mois prochain.

GitLab Duo Agent Platform est actuellement en bêta – activez les fonctionnalités bêta et expérimentales pour découvrir comment l'IA avec contexte complet peut transformer la façon dont vos équipes construisent des logiciels. Nouveau sur GitLab ? Commencez votre essai gratuit et découvrez pourquoi l'avenir du développement est alimenté par l'IA, sécurisé et orchestré via la plateforme DevSecOps la plus complète au monde.

Note : Les capacités de plateforme en bêta sont disponibles dans le cadre du programme bêta GitLab. Elles sont gratuites pendant la période bêta, et une fois généralement disponibles, elles seront proposées avec une option d'add-on payant pour GitLab Duo Agent Platform.

Restez à jour avec GitLab

Pour vous assurer d'obtenir les dernières fonctionnalités, mises à jour de sécurité et améliorations de performances, nous recommandons de maintenir votre instance GitLab à jour. Les ressources suivantes peuvent vous aider à planifier et compléter votre mise à niveau :

• Outil de chemin de mise à niveau – entrez votre version actuelle et voyez les étapes exactes de mise à niveau pour votre instance
• Documentation de mise à niveau – guides détaillés pour chaque version supportée, incluant les exigences, instructions étape par étape et meilleures pratiques

En effectuant des mises à niveau régulières, vous garantissez que votre équipe bénéficie des nouvelles capacités GitLab et reste sécurisée et supportée.

Pour les organisations qui souhaitent une approche sans intervention, considérez le service de Maintenance Gérée de GitLab. Avec la Maintenance Gérée, votre équipe reste concentrée sur l'innovation tandis que les experts GitLab maintiennent votre instance Self-Managed mise à niveau de manière fiable, sécurisée et prête à diriger dans DevSecOps. Demandez plus d'informations à votre gestionnaire de compte.

Ce billet de blog contient des « déclarations prospectives » au sens de la Section 27A du Securities Act de 1933, tel que modifié, et de la Section 21E du Securities Exchange Act de 1934. Bien que nous croyions que les attentes reflétées dans ces déclarations sont raisonnables, elles sont soumises à des risques connus et inconnus, des incertitudes, des hypothèses et d'autres facteurs qui peuvent faire que les résultats ou issues réels diffèrent matériellement. De plus amples informations sur ces risques et autres facteurs sont incluses sous la rubrique « Facteurs de risque » dans nos dépôts auprès de la SEC. Nous ne nous engageons pas à mettre à jour ou réviser ces déclarations après la date de ce billet de blog, sauf si la loi l'exige.

Les approches de sécurité traditionnelles, autrefois efficaces dans des environnements retail plus simples, sont à présent inadaptées. Les processus de sécurité sont souvent ajoutés après coup, ce qui ralentit les équipes et augmente les risques. Pourtant, il est possible d'intégrer la sécurité dès la conception.

Les plateformes modernes intègrent la sécurité tout au long du cycle de développement logiciel afin que la protection soit un élément naturel du workflow de développement, et non un frein à la livraison. Avec cette approche, la sécurité devient un levier stratégique qui favorise l'innovation sans compromettre la résilience des systèmes.

Dans cet article, découvrez comment une plateforme DevSecOps unifiée permet aux équipes retail de répondre aux exigences croissantes en matière de sécurité sans ralentir la livraison ni nuire à l'expérience client.

→ Essayez GitLab Ultimate et GitLab Duo Enterprise gratuitement.

La sécurité dans le secteur du retail : un défi à part

Dans le commerce de détail, la sécurité ne se limite pas à la protection des données : elle vise avant tout à préserver l'expérience client, véritable moteur du chiffre d'affaires. La moindre diminution de performances, panne ou vulnérabilité peut entraîner une diminution des ventes et une perte de confiance. Les plateformes d'e-commerce doivent rester opérationnelles, respecter les normes de conformité et résister à des attaques incessantes provenant de l'Internet ouvert. Contrairement aux systèmes d'entreprise, elles sont entièrement exposées au public et leur surface d'attaque est considérablement étendue. Les intégrations tierces, les API et les systèmes hérités viennent encore complexifier le paysage : les approches traditionnelles de sécurité ne suffisent donc plus.

À cela s'ajoutent des défis spécifiques au secteur, qui multiplient les risques et exigent des solutions de sécurité adaptées. En voici les principaux.

Fragilité de la chaîne d'approvisionnement et prolifération des API

Les retards de livraison, l'instabilité mondiale et la complexité des systèmes interconnectés perturbent la logistique du commerce de détail. Selon une enquête Fluent Commerce de 2024, près de la moitié des commerçants rencontrent des problèmes de disponibilité des produits et 25 % d'entre eux manquent de visibilité sur les stocks en temps réel. Même si les prévisions alimentées par l'IA peuvent s'avérer utiles en matière de planification, des API non sécurisées et des intégrations fragiles tout au long de la chaîne d'approvisionnement numérique créent de nouveaux vecteurs d'attaque.

Systèmes hérités inadaptés aux exigences modernes

De nombreux commerçants utilisent des systèmes monolithiques et obsolètes, incapables de prendre en charge les applications mobiles, les appareils IdO et les analyses en temps réel de façon sécurisée. Sans fondations sécurisées et agiles, chaque nouveau point de contact numérique devient une vulnérabilité potentielle.

Utilisation de l'IA et complexité de la conformité

L'IA redéfinit l'expérience client grâce à des recommandations personnalisées et à des technologies de suivi avancées, telles que les balises Bluetooth, la reconnaissance faciale et la géolocalisation via des applications mobiles. Ces systèmes surveillent les mouvements et les comportements des clients dans les magasins pour améliorer à la fois l'expérience client et les capacités de prévision de la demande pour les commerçants. Cependant, le RGPD (Règlement général sur la protection des données de l'Union européenne) et les réglementations mondiales similaires sur la confidentialité imposent un traitement sécurisé des données et une logique d'IA transparente. Toute faille de sécurité peut entraîner des amendes lourdes et nuire durablement à la réputation.

Risques liés à l'automatisation des interactions clients

Les caisses automatiques, les bornes et les chatbots promettent commodité et économies, mais leur sécurité n'est que rarement renforcée. Ces points de contact deviennent des points d'entrée pour les cyberattaquants, mais aussi pour le vol à l'étalage, devenu plus difficile à repérer, en raison d'une faible détection de la fraude, d'une surveillance limitée et de systèmes facilement manipulables.

Surfaces d'attaque disparates

Les commerçants doivent sécuriser de multiples vecteurs, souvent gérés par des équipes réparties dans le monde entier (en fonction de la taille de l'entreprise). Les plateformes d'e-commerce, les applications mobiles, les systèmes de point de vente (PDV) et les appareils IdO en magasin constituent tous un point d'entrée pour les acteurs malveillants, avec des caractéristiques uniques qui nécessitent différentes solutions de sécurité pour garantir la résilience des systèmes.

Le paradoxe du retail est unique en son genre : les commerçants doivent innover plus rapidement que jamais tout en maintenant des normes de sécurité supérieures à celles de la plupart des autres secteurs, et ce, sans compromettre la fluidité de l'expérience client sur l'ensemble des canaux.

La sécurité applicative : les approches classiques face à leurs limites

La plupart des commerçants s'appuient sur des outils de sécurité disparates, tels que des scanners de test statique de sécurité des applications (SAST), des vérificateurs de licences et des évaluations de vulnérabilités. Ils sont déconnectés les uns des autres, ce qui crée des lacunes critiques qui exposent les commerçants à des risques importants :

• Couverture limitée : les outils se concentrent sur certaines phases du développement, sans tenir compte des risques liés à la chaîne d'approvisionnement et à l'environnement d'exécution des applications.
• Problèmes d'intégration : les lacunes des systèmes hérités et le manque de connectivité entre les outils génèrent des zones non protégées, et les vulnérabilités échappent aux équipes et aux solutions de sécurité.
• Processus manuels : les transferts de sécurité ralentissent les équipes, et les problèmes sont souvent découverts trop tardivement, lorsqu'ils deviennent plus coûteux à résoudre.
• Équipes cloisonnées : la sécurité n'est pas intégrée aux workflows de développement quotidiens et les équipes de conformité et informatiques travaillent indépendamment des équipes de sécurité.

Quelle stratégie adopter ?

Dans le paysage moderne du commerce de détail, où tout évolue rapidement, la sécurité ne doit pas freiner l'innovation. En l'intégrant dès le cycle de développement et en rassemblant toutes les équipes sur une seule plateforme DevSecOps unifiée, elle ne constitue plus un goulot d'étranglement, mais bien un avantage stratégique.

Allier innovation et sécurité à grande échelle avec une plateforme DevSecOps

GitLab fournit l'ensemble le plus complet de scanners de sécurité pour maximiser la couverture de sécurité des applications, notamment :

• SAST
• DAST
• Analyse des dépendances
• Analyse des conteneurs
• Détection des secrets
• Analyse de l'Infrastructure as Code
• Tests à données aléatoires

Mais les scans et les analyses ne suffisent pas à garantir la sécurité des applications. Il est nécessaire d'appliquer des politiques pertinentes pour s'assurer que les vulnérabilités sont systématiquement identifiées et corrigées. Avec GitLab, les équipes de sécurité disposent d'un contrôle total qui garantit que les scans adéquats sont exécutés sur chaque application au moment opportun et que les vulnérabilités sont corrigées avant qu'elles n'atteignent l'environnement de production.

<center><i>Les scans de sécurité s'exécutent dans le pipeline CI/CD et offrent un retour immédiat sur les vulnérabilités potentielles.</i></center> <p></p>

<center><i>Le rapport de vulnérabilité affiche toutes les vulnérabilités d'un projet ou groupe spécifique.</i></center> <p></p>

Une seule plateforme pour les équipes Dev, Sec et Ops

Les équipes retail perdent d'innombrables heures à jongler d'un outil à l'autre, à transférer manuellement des données, à subir des pertes d'informations réparties sur différents systèmes en raison du manque d'intégrations et à consolider des rapports contradictoires. Une plateforme unifiée élimine ces points de friction. Elle offre :

• Une source unique de vérité pour le code, les pipelines CI/CD, les vulnérabilités et la conformité
• Des fonctionnalités Dev, Sec et Ops intégrées pour éviter tout problème de compatibilité entre outils
• Des workflows cohérents et homogènes pour toutes les équipes et tous les projets

Résultat ? Les équipes consacrent leur temps à leurs projets plutôt qu'à la gestion des outils.

<center><i>Le Centre de conformité vous permet d'appliquer des frameworks de conformité à tous vos projets.</i></center> <p></p>

<center><i>Dans une merge request, une approbation est nécessaire si des risques sont détectés avant de fusionner le code, conformément aux politiques définies.</i></center> <p></p>

Responsabilité partagée, fin du cloisonnement

Les stratégies de sécurité les plus efficaces dans le secteur du retail font de la sécurité la responsabilité de tous, et pas seulement de l'équipe de sécurité.

Autonomisation des équipes de développement

Les directives de sécurité et de conformité s'affichent directement dans les merge requests. Les équipes de développement ne peuvent donc pas passer à côté de problèmes critiques. Elles reçoivent un retour immédiat sur chaque commit, avec des explications claires sur les risques et les étapes de remédiation. Par exemple, l'explication et la résolution des vulnérabilités alimentées par l'IA les aident à comprendre et à résoudre les failles de sécurité de manière autonome. Cette approche réduit les goulots d'étranglement et renforce l'expertise en sécurité au sein de l'équipe.

<center><i>Page de vulnérabilité avec un bouton pour expliquer ou résoudre les problèmes avec l'IA et combler les lacunes.</i></center> <p></p>

Automatisation de la conformité

Générez des rapports d'audit, suivez l'utilisation des licences et maintenez une nomenclature logicielle (SBOM) sans effort manuel.

<center><i>Le rapport de dépendances automatisé de GitLab fournit une SBOM complète. Il affiche toutes les dépendances du projet avec le statut des vulnérabilités, les détails de la licence et les risques détectés pour une transparence et une conformité totales.</i></center> <p></p>

Avec cette approche, la sécurité n'est plus un frein à la livraison, mais permet d'innover rapidement et en toute confiance.

Comparatif plateforme GitLab vs outils ponctuels

La sécurité, catalyseur du succès

Dans le secteur du retail, la sécurité vise non seulement à protéger les données, mais aussi l'expérience client, source directe de revenus. Lorsque la sécurité ralentit la livraison de nouvelles fonctionnalités ou crée des vulnérabilités, les ventes sont directement impactées, car vos clients attendent des expériences sécurisées et fluides à chaque interaction.

La plateforme DevSecOps intégrée de GitLab offre les avantages suivants aux commerçants :

• Déployez plus rapidement sans compromettre la sécurité avec un scanning de sécurité automatisé qui détecte les problèmes avant qu'ils n'atteignent les clients.
• Respectez facilement les exigences de conformité avec des rapports intégrés qui facilitent le respect du RGPD, de la norme PCI-DSS et des autres réglementations du secteur.
• Réduisez les coûts liés aux outils de sécurité en remplaçant plusieurs solutions ponctuelles par une plateforme unifiée.
• Transformez les équipes de développement en défenseurs de la sécurité grâce à des directives claires et à l'automatisation, sans obstacle.

Découvrez les principales fonctionnalités de sécurité de GitLab :

• Résolution des vulnérabilités de GitLab Duo
• Intégration de scans au pipeline
• Frameworks de conformité
• Analyseur Advanced SAST

→ Essayez GitLab Ultimate et GitLab Duo Enterprise gratuitement.

À mesure que l’usage du cloud s’intensifie, les organisations peinent à maîtriser leurs dépenses, comme en témoigne ce rapport de Gartner qui indique que 69 % des organisations ont dépassé leur budget cloud en 2023.

Cette imprévisibilité fragilise la confiance des directions financières et accroît la pression sur les équipes IT. L’approche FinOps apporte une réponse structurée : rendre les coûts visibles en temps réel, instaurer une culture de responsabilité partagée et aligner chaque dépense sur la valeur métier qu’elle génère.

Plus qu’une simple stratégie de réduction des coûts, le FinOps est un cadre opérationnel et culturel. Il permet aux organisations de reprendre le contrôle de leurs budgets cloud sans sacrifier ni l’agilité ni l’innovation. Une approche d’autant plus pertinente lorsqu’elle s’intègre directement dans les pratiques DevOps et CI/CD disponibles sur la plateforme de GitLab.

→ Essayez GitLab Ultimate et GitLab Duo Enterprise gratuitement.

Définition du FinOps

Le terme FinOps, contraction de Financial Operations, désigne une discipline née d’un constat simple : l’explosion des usages cloud exige une gouvernance financière nouvelle. Les méthodes budgétaires classiques ne suffisent plus, car elles ne tiennent pas compte de la variabilité et de la complexité propres au cloud.

Le FinOps dépasse largement la notion de réduction des coûts. Il ne s’agit pas seulement de traquer le gaspillage ou de négocier des remises avec les fournisseurs. C’est une approche culturelle et organisationnelle qui réunit les équipes financières, technologiques et métiers. Son objectif est de canaliser l’innovation sans la freiner, en donnant à chacun une vision claire des impacts financiers de ses choix d’infrastructure et d’opérations.

Une organisation FinOps ne cherche pas à dépenser moins, mais à dépenser mieux : investir dans les bonnes ressources, au bon moment, avec un retour métier mesurable.

Pourquoi le FinOps est devenu incontournable ?

Le multicloud s’impose dans la plupart des organisations. AWS, Azure, Google Cloud et les solutions privées cohabitent, chacun avec ses modèles tarifaires et ses remises. Cette diversité rend le suivi budgétaire fragmenté et renforce la complexité de gouvernance.

À cette diversité s’ajoute la variabilité des coûts. Dans un système auto-hébergé (on-premise), le budget était fixé à l’avance. Dans le cloud, chaque pic de charge, projet de test ou déploiement accéléré peut alourdir la facture du jour au lendemain. Cette imprévisibilité met à mal les méthodes financières classiques et crée un besoin urgent de nouvelles pratiques de gestion.

Les services financiers exigent désormais plus qu'une facture cloud mensuelle incompréhensible. Ils attendent des prévisions fiables, une répartition claire des dépenses et une logique de gestion comparable à celle des autres investissements de l’entreprise.

C’est pourquoi l’alignement entre coûts et valeur métier est devenu central. Chaque dépense doit pouvoir être reliée à un produit ou une expérience client. L’approche FinOps apporte ce langage commun qui transforme une facture technique en tableau de bord business.

C’est dans ce contexte qu’est né le FinOps, pensé comme un cadre structuré pour maîtriser cette complexité.

Les principes fondamentaux de l’approche FinOps

Le FinOps repose sur une culture partagée, structurée autour de plusieurs principes clés :

• La collaboration entre différentes équipes : aucun acteur ne peut piloter seul. La finance apporte la maîtrise budgétaire, l’ingénierie la réalité technique, et les équipes métiers la perspective de valeur. Ensemble, ils construisent une organisation capable de prendre des décisions équilibrées, mais cette logique de partage ne suffit pas à elle seule.
• La répartition de la responsabilité et de la gouvernance : chaque équipe assume le coût de ses choix techniques (you build it, you run it, you pay it), mais une fonction centrale définit les standards, fixe les indicateurs clés de performance (KPI) et fournit les outils pour maintenir la cohérence globale. Cette gouvernance ne se limite pas aux coûts : elle concerne aussi la gestion des environnements et des ressources.
• La valeur métier comme boussole : une dépense cloud n’a de sens que si elle contribue à un produit, un service ou une expérience client. L’approche FinOps mesure ce lien direct entre coûts et retour sur investissement.
• La transparence et la réactivité grâce à la donnée : les coûts doivent être visibles en temps réel, avec un reporting clair et actionnable, idéalement au sein même des workflows où les équipes travaillent déjà. C’est la condition pour corriger vite et instaurer la confiance.
• La prise de décision décentralisée avec une gouvernance centralisée : les équipes prennent des décisions en temps réel concernant leurs ressources dans le cadre de garde-fous établis, plutôt que d'attendre des chaînes d'approbation.
• Le modèle variable du cloud : plutôt que de subir la variabilité, le FinOps en fait un atout. Adapter les ressources aux besoins, automatiser la scalabilité et anticiper via des réservations permettent de transformer la flexibilité en levier stratégique.
• La culture de l’optimisation continue : FinOps est une pratique permanente, et non un projet ponctuel. Les équipes identifient continuellement le gaspillage, optimisent les ressources et affinent les processus à mesure que l'utilisation du cloud évolue.

Ces principes forment le socle culturel. Pour les mettre en œuvre, il faut un cadre clair et un cycle de vie défini, capable d’accompagner les organisations dans le temps.

Le cadre et cycle de vie FinOps

Pour transformer ces principes en pratiques durables, la FinOps Foundation propose un framework reconnu. Il décrit les domaines d’action, les rôles impliqués et les étapes de maturité.

Les trois domaines du framework FinOp

Le framework de la FinOps Foundation repose sur trois domaines permanents :

• Informer : rendre les coûts visibles et compréhensibles, en partageant la donnée financière en temps réel.
• Optimiser : identifier les inefficiences, ajuster les ressources et introduire une logique d’optimisation continue.
• Opérer : installer une gouvernance durable et piloter sur le long terme.

Ces domaines ne sont pas séquentiels : ils forment un cycle continu. Plus on informe, mieux on optimise, et plus la gouvernance s’ancre dans l’organisation.

Rôles et maturité des organisations

Chaque domaine mobilise des acteurs spécifiques : la finance pour le contrôle budgétaire, l’ingénierie pour la traduction technique, les équipes métiers pour la valeur business, et la gouvernance pour les standards communs.

L’adoption d’une approche FinOps se mesure aussi par des niveaux de maturité (crawl, walk, run) qui traduisent le cheminement progressif d’une organisation vers une gestion cloud pleinement maîtrisée.

Les étapes « crawl, walk, run » pour progresser

Le modèle crawl, walk, run décrit la maturité des organisations de la manière suivante :

• Crawl : premiers pas, reporting basique, quelques KPIs suivis.
• Walk : intégration des pratiques, optimisation régulière, premiers rituels et automatisations.
• Run : maturité avancée, automatisation complète, gouvernance robuste, FinOps intégré à la stratégie d’entreprise.

Ce cadre donne une boussole aux organisations : il permet de savoir où elles se situent et comment progresser vers une maîtrise durable de leurs dépenses cloud.

Pourquoi et comment déployer un modèle FinOps ?

Mettre en place une démarche FinOps, c’est répondre à ces enjeux : variabilité des coûts, pression budgétaire, besoin de transparence et recherche d’efficacité. Pour réussir, le déploiement doit être progressif et ancré dans des usages réels.

Maîtriser la variabilité et l’imprévisibilité des coûts cloud

Le cloud fonctionne à l’usage, ce qui rend ses coûts naturellement fluctuants. Pour éviter que cette instabilité ne devienne un risque budgétaire, le FinOps impose de cartographier les pics de consommation, de fixer des règles de pilotage budgétaire et de modéliser les scénarios d’infrastructure. L’objectif est de transformer une dépense imprévisible en une dépense maîtrisée.

Aligner coûts et valeur métier

Une fois la transparence obtenue, la question devient : chaque dépense crée-t-elle réellement de la valeur ? Le FinOps relie les coûts aux produits et services, et les mesure via des indicateurs unitaires comme le coût par utilisateur ou par transaction. Cette approche permet de prioriser les investissements selon leur ROI métier et de donner du sens aux coûts liés au cloud.

Mettre en place une gouvernance et des règles partagées

Pour que cette logique tienne dans le temps, une gouvernance claire est nécessaire. Standards de tagging, définition de propriétaires pour chaque ressource et attribution de budgets par équipe assurent la traçabilité. Des processus d’arbitrage complètent ce cadre, validé au plus haut niveau de l’entreprise. La gouvernance devient alors la colonne vertébrale du modèle.

S’appuyer sur des outils et métriques dédiés

La gouvernance ne fonctionne pas sans données fiables. Les fournisseurs cloud proposent leurs propres outils de suivi, mais ils restent souvent fragmentés et difficiles à comparer. L’enjeu est de centraliser l’information et de la rendre actionnable dans un même environnement. Des KPIs simples comme le coût par charge de travail, par utilisateur, ou efficacité par équipe permettent déjà de matérialiser le lien entre usage et valeur. Intégrés directement aux workflows existants, ils deviennent des leviers concrets de pilotage quotidien.

Adopter une démarche progressive

Le FinOps n’est pas un big bang. La réussite passe par une adoption incrémentale : lancer un produit minimum viable (MVP) FinOps, comme un projet DevOps, engranger des gains rapides et élargir progressivement le périmètre. Le but n’est pas la perfection immédiate, mais la construction d’une dynamique durable qui s’installe dans la culture.

Exemples d’actions rapides pour développer une stratégie FinOps

Une stratégie FinOps doit démontrer sa valeur rapidement. Trois actions simples suffisent souvent à générer des économies visibles et à crédibiliser la démarche :

• Éliminer les ressources orphelines : volumes de stockage oubliés, IP inutilisées ou environnements de test inactifs. Ces fuites discrètes représentent souvent plusieurs points de la facture mensuelle.
• Redimensionner les instances surprovisionnées : beaucoup de ressources tournent à une fraction de leur capacité. Ajuster leur taille réduit les coûts immédiatement, sans perte de performance de l’infrastructure.
• Automatiser l’arrêt des environnements non critiques : couper la nuit et le week-end ce qui n’a pas besoin de tourner en continu génère des économies récurrentes, simples et durables.

Ces gestes rapides donnent un signal clair : le FinOps produit des résultats immédiats et prépare le terrain à une adoption durable.

La FinOps Foundation : Créée en 2019 et rattachée à la Linux Foundation, la FinOps Foundation définit les standards de la discipline et fédère une communauté mondiale. Elle diffuse un framework reconnu (informer, optimiser, opérer), propose des formations et certifications, et organise des échanges entre praticiens. C'est aujourd'hui la référence pour structurer et faire progresser les pratiques FinOps.

Les défis et limites du FinOps

Adopter une démarche FinOps n’est pas un long fleuve tranquille. Si la discipline séduit par sa promesse de transparence et de maîtrise, sa mise en œuvre confronte les organisations à plusieurs obstacles récurrents.

Un changement culturel difficile à impulser

Le premier défi est culturel. Le FinOps ne se réduit pas à déployer un outil ou un tableau de bord : c’est avant tout une nouvelle façon de travailler ensemble. Les équipes financières, technologiques et métiers doivent partager leurs responsabilités, ce qui bouscule les habitudes. Comme dans toute transformation, la résistance au changement est souvent le premier obstacle.

Cette difficulté culturelle en entraîne une autre.

Les silos organisationnels qui freinent la collaboration

Dans beaucoup d’organisations, les équipes restent enfermées dans leurs silos : finance d’un côté, IT de l’autre, équipes métier à part. Sans communication fluide, impossible d’aligner coûts et valeur métier. La gouvernance FinOps cherche justement à briser ces cloisons, mais cela suppose un soutien fort de la direction pour changer les réflexes organisationnels.

Et même quand les équipes coopèrent, un autre frein apparaît : la donnée elle-même.

Une visibilité partielle et des données complexes à exploiter

Les coûts liés au cloud sont notoirement difficiles à lire, surtout en environnement multi-cloud. La donnée existe, mais elle reste souvent dispersée, brute et difficile à interpréter. Les équipes n’ont pas toujours les bons outils pour la centraliser et la rendre actionnable. La transparence promise par le FinOps peut donc se heurter à des limites techniques et analytiques.

Ce manque de clarté se double d’un manque de compétences spécialisées.

Le manque de compétences et d’outils adaptés

Le FinOps est encore une discipline jeune, et les profils expérimentés sont rares. Beaucoup d’organisations doivent former leurs équipes en interne, ce qui rend l’adoption progressive mais parfois lente. Cette montée en compétence est essentielle, car la réussite repose autant sur la culture que sur la technique.

Les outils représentent un autre défi. Les organisations disposent de nombreux outils pour analyser leurs coûts cloud, mais ces solutions sont souvent dispersées et difficiles à intégrer dans une vision unique. Le résultat est paradoxal : plus de données, mais pas nécessairement plus de clarté.

Le véritable enjeu est donc de bâtir une approche outillée qui reste simple et alignée sur la maturité de l’organisation. Avancer par étapes, en privilégiant la lisibilité et l’efficacité, permet d’éviter de transformer un problème de gouvernance en un problème d’outils.

Un budget cloud par nature instable

Même avec une gouvernance solide et des outils performants, les coûts liés au cloud restent par nature instable. Les pics de charge, les environnements hybrides ou les workloads liés à l’IA créent des fluctuations difficiles à anticiper. Les prévisions budgétaires doivent donc être révisées en permanence, car une consommation inattendue peut faire dérailler les estimations les plus rigoureuses.

Ces obstacles n’invalident pas le FinOps, ils montrent pourquoi la discipline doit continuer à évoluer.

Les tendances et perspectives FinOps

L’approche FinOps n’en est qu’au début de son histoire. La discipline continue d’évoluer pour répondre à de nouveaux enjeux, qui dépassent largement la seule question des coûts.

La première tendance est la durabilité. De plus en plus d’organisations veulent optimiser leurs dépenses cloud tout en réduisant leur empreinte carbone. Le FinOps s’ouvre ainsi au GreenOps, où performance économique et responsabilité environnementale avancent de concert.

La deuxième évolution est l’automatisation. La complexité croissante du cloud rend impossible un pilotage manuel. Les pratiques de type FinOps as Code et l’usage de l’IA pour analyser les consommations ou ajuster automatiquement les ressources vont devenir la norme.

Troisième transformation : l’impact de la charge de travail liée à IA. Ces charges massives et imprévisibles redéfinissent la gouvernance financière du cloud. Elles imposent de nouvelles méthodes de prévision, de nouveaux indicateurs et une collaboration encore plus étroite entre finance et ingénierie.

Le quatrième changement est la convergence avec l'ingénierie de plateforme. Alors que les organisations construisent des plateformes de développement internes pour standardiser et accélérer la livraison logicielle, le FinOps trouve son canal d'implémentation le plus efficace. Les équipes de plateforme intègrent l'intelligence des coûts directement dans la structure même de la façon dont les logiciels sont construits et déployés. Grâce aux portails en libre-service, aux « Golden Paths » et aux modèles d'infrastructure, elles font de l'optimisation des coûts un comportement par défaut plutôt qu'une réflexion après coup. Les équipes reçoivent un retour sur les coûts en temps réel dans leurs workflows, les limites de ressources sont appliquées par le biais de Policy as Code, et les garde-fous financiers deviennent des fonctionnalités invisibles de la plateforme elle-même. Il ne s'agit pas seulement d'ajouter des tableaux de bord de coûts, il s'agit de repenser fondamentalement la façon dont le FinOps fonctionne à grande échelle.

Enfin, la maturité reste encore faible. Beaucoup d’organisations en sont à leurs premiers pas, souvent au stade du “crawl”. Le défi des prochaines années sera de monter collectivement en maturité, pour que le FinOps devienne non pas une initiative ponctuelle, mais une compétence organisationnelle intégrée.

Le FinOps n’est donc pas une fin en soi, mais une démarche évolutive. Il permet de transformer le cloud d’un centre de coûts imprévisible en un levier stratégique. Intégré directement aux pratiques DevSecOps et CI/CD, il rapproche encore plus les équipes financières, technologiques et métiers autour d’objectifs communs.

Le FinOps n’est donc pas une fin en soi, mais une démarche évolutive. Il permet de transformer le cloud d’un centre de coûts imprévisible en un levier stratégique. Intégré directement aux pratiques DevSecOps et CI/CD, il rapproche encore plus les équipes financières, technologiques et métiers autour d’objectifs communs.

Ce parcours commence par l'intégration des pratiques FinOps directement dans les workflows de développement existants. C'est là que des plateformes comme GitLab entrent en jeu.

GitLab et l’approche FinOps

GitLab contribue à l’approche FinOps en offrant une visibilité sur l'utilisation des ressources de développement. La plateforme permet de suivre la consommation des minutes de calcul par projet et espace de nommage, facilitant ainsi l'attribution des coûts aux équipes. Par ailleurs, les administrateurs peuvent configurer des quotas d'utilisation et surveiller les tendances de consommation via les tableaux de bord d'usage. Cette approche aide les organisations à mieux comprendre leurs dépenses liées aux pipelines CI/CD et à optimiser l'utilisation de leurs runners. En intégrant ces métriques dans les workflows de développement, GitLab sensibilise les équipes techniques à l'impact de leurs pratiques sur les coûts opérationnels.

→ Essayez GitLab Ultimate et GitLab Duo Enterprise gratuitement.

Dans ce guide complet, découvrez tout ce qu'il faut savoir sur Docker : sa définition, son fonctionnement, ses avantages et son application dans un environnement DevSecOps avec la plateforme de GitLab.

Essayez GitLab Ultimate gratuitement.

Docker : définition

Docker est une plateforme de conteneurisation open source qui permet aux équipes de développement d'empaqueter leurs applications et toutes leurs dépendances dans des conteneurs légers et portables. Lancé en 2013, Docker a démocratisé l'utilisation des conteneurs en proposant une solution simple et accessible pour créer des environnements d'exécution isolés.

Qu’est-ce qu’un conteneur Docker ?

Un conteneur Docker représente un environnement d'exécution léger qui encapsule une application avec l'ensemble de ses composants : code source, bibliothèques, dépendances système, variables d'environnement et fichiers de configuration. Il peut parfois être comparé à une machine virtuelle dans le sens où il permet d’héberger des services sur un même serveur physique tout en les isolant les uns des autres. Néanmoins, le fonctionnement d’un conteneur diffère légèrement d’une simple machine virtuelle.

Moins figés qu'une machine virtuelle, en matière de taille de disque et de ressources allouées, les conteneurs partagent le noyau de la machine hôte et isolent les processus, les utilisateurs, etc. Cela les rend très légers et leur permet de fonctionner comme s'ils étaient des machines distinctes. Par conséquent, les applications peuvent être démarrées et arrêtées rapidement.

Comment fonctionne Docker ?

Docker révolutionne la virtualisation en exploitant les capacités natives du noyau Linux pour créer des environnements d'exécution légers et isolés. Contrairement à la virtualisation traditionnelle qui nécessite des machines virtuelles complètes avec leur propre système d'exploitation, Docker utilise la conteneurisation pour partager le noyau de l'hôte tout en maintenant une isolation parfaite entre les applications.

La philosophie de Docker repose sur des technologies Linux avancées telles que les namespaces (qui isolent les processus, le réseau et le système de fichiers) et les cgroups (qui limitent et contrôlent l'utilisation des ressources). Docker encapsule ces fonctionnalités complexes dans une interface simple et portable, permettant aux équipes de développement de créer des environnements cohérents sur n'importe quelle plateforme.

Le processus de conteneurisation avec Docker suit un cheminement précis :

1. Création d'un Dockerfile : ce fichier texte contient les instructions pour construire l'environnement
2. Construction d’une image docker : Docker assemble les composants selon les spécifications du Dockerfile
3. Instanciation du conteneur : l'image devient un conteneur exécutable
4. Gestion du cycle de vie : démarrage, arrêt, surveillance et mise à jour des conteneurs

Pour comprendre pleinement le fonctionnement de Docker, il est essentiel de maîtriser les quatre composants fondamentaux suivants, qui contribuent à créer un écosystème de conteneurisation complet et efficace.

Docker Engine : le cœur du système

Docker Engine est le moteur qui orchestre toutes les opérations de conteneurisation. Cette architecture client-serveur se compose de trois éléments interconnectés qui travaillent en harmonie :

Docker Daemon (dockerd) constitue le service central qui s'exécute en permanence sur le système hôte et gère l'ensemble du cycle de vie des conteneurs. Il supervise la création, l'exécution, la surveillance et la destruction des conteneurs, tout en gérant les images, les réseaux virtuels et les volumes de stockage. Ce daemon écoute en permanence les requêtes et exécute les opérations demandées.

L'API REST Docker est le mode de communication principal avec Docker Daemon. Concrètement, quand vous lancez docker run ou docker build, votre commande est transformée en requête HTTP qui est envoyée au daemon. Cette API permet également aux équipes de développement de créer leurs propres outils ou d'automatiser Docker dans leurs scripts et applications.

Le client Docker CLI représente l'interface en ligne de commande que les utilisateurs emploient quotidiennement. Chaque commande docker (run, build, push, pull) transite par ce client qui communique avec le daemon via l'API REST.

Images Docker : les modèles d'exécution

Une image Docker constitue un modèle immuable et en lecture seule qui encapsule l'ensemble des éléments nécessaires à l'exécution d'une application. Cette image contient le système de fichiers complet, incluant le code source, les bibliothèques système, les dépendances, les variables d'environnement et les métadonnées de configuration.

L'architecture en couches des images Docker représente l'une des innovations les plus importantes de cette technologie. Chaque instruction dans un Dockerfile crée une nouvelle couche et Docker utilise un système de cache intelligent pour réutiliser les couches communes entre différentes images. Cette approche optimise considérablement l'espace de stockage et accélère les processus de construction et de téléchargement.

Les images sont identifiées par des tags qui combinent un nom et une version (comme nginx:latest, ubuntu:20.04 ou node:18-alpine). Ces tags permettent aux équipes de développement de spécifier précisément quelle version d'une image utiliser dans leurs déploiements.

Dockerfile : automatiser la construction

Le Dockerfile représente bien plus qu'un simple script d'instructions : il constitue la recette complète pour reproduire fidèlement un environnement d'exécution. Ce fichier texte utilise une syntaxe déclarative simple pour définir chaque étape de la construction d'une image.

Un Dockerfile typique commence par spécifier une image de base (instruction FROM), puis enchaîne les opérations : installation de dépendances (RUN), copie de fichiers (COPY ou ADD), configuration d'environnement (ENV), exposition de ports (EXPOSE), et définition de la commande par défaut (CMD ou ENTRYPOINT).

Cette approche Infrastructure as Code garantit la reproductibilité parfaite des environnements et s'inscrit parfaitement dans les pratiques DevOps actuelles. En documentant explicitement toutes les étapes de configuration dans un fichier versionable, le Dockerfile facilite la collaboration entre les équipes de développement et les opérateurs.

Docker Registry : partager et distribuer

Les registres Docker fonctionnent comme des dépôts centralisés qui permettent de stocker, versioner et distribuer des images Docker de manière sécurisée. Ils constituent l'épine dorsale de l'écosystème Docker en facilitant la collaboration et le partage d'images.

Docker Hub demeure le registre public officiel, hébergeant des millions d'images communautaires et officielles. Les équipes de développement peuvent y trouver des images prêtes à l'emploi : bases de données, serveurs web, etc.

Les entreprises peuvent également déposer leurs images dans des registres privés garantissant la sécurité et le contrôle des accès. Ces registres privés peuvent être auto hébergés (on-premise) ou dans le cloud.

Pourquoi utiliser Docker ?

Le développement d'applications fait face à des défis croissants : multiplication des environnements de déploiement, diversité des technologies utilisées, cycles de livraison accélérés et exigences de fiabilité toujours plus élevées. Les équipes de développement jonglent quotidiennement avec des problématiques complexes qui ralentissent leur productivité et augmentent les risques d'erreur.

En ce sens, Docker répond directement ou indirectement à ces problématiques récurrentes dans le développement logiciel.

Uniformisation des environnements : Docker élimine le fameux « ça marche sur ma machine » en garantissant que l'application s'exécute de manière identique sur tous les environnements, du poste de développement à la production.

Simplification des déploiements : l'empaquetage de l'application et de ses dépendances dans un conteneur unique simplifie considérablement les processus de déploiement et réduit les risques d'erreur.

Isolation des applications : chaque conteneur dispose de son propre espace d'exécution, évitant les conflits entre différentes versions de bibliothèques ou de dépendances.

Accélération du développement : les équipes de développement peuvent rapidement lancer des environnements complexes sans configuration manuelle fastidieuse.

Optimisation des ressources informatiques : Docker permet une utilisation plus efficace des ressources serveur comparé aux machines virtuelles traditionnelles. Plusieurs conteneurs peuvent partager le même noyau système tout en maintenant leur isolation, réduisant ainsi l'empreinte mémoire et CPU.

Cette efficacité se traduit par :

• Des temps de démarrage considérablement réduits
• Une densité d'applications plus élevée par serveur
• Une consommation énergétique optimisée
• Des coûts d'infrastructure réduits

Quels sont les avantages de Docker ?

Maintenant que nous avons vu pourquoi Docker est si populaire, intéressons-nous davantage aux avantages qu'il apporte concrètement aux équipes de développement.

Portabilité et cohérence

Docker garantit que les applications fonctionnent de manière identique quel que soit l'environnement d'exécution. Cette portabilité facilite :

• La migration d'applications entre différents fournisseurs cloud
• Le déploiement sur des architectures hybrides (on-premise et cloud)
• La création d'environnements de test fidèles à la production
• La distribution d'applications complexes

Scalabilité et performance

Les conteneurs Docker offrent une flexibilité exceptionnelle pour adapter les ressources aux besoins applicatifs :

• Montée en charge horizontale : ajout rapide de nouvelles instances de conteneurs selon la demande
• Optimisation des ressources : allocation précise des ressources CPU et mémoire par conteneur
• Démarrage instantané : les conteneurs se lancent en quelques secondes contre plusieurs minutes pour les machines virtuelles
• Efficacité réseau : gestion sophistiquée des réseaux virtuels entre conteneurs

Facilitation du DevOps

Docker s'intègre naturellement dans les pratiques DevOps en :

• Automatisant les processus de compilation et de déploiement
• Facilitant l'intégration et le déploiement continus (CI/CD)
• Permettant des tests reproductibles dans des environnements isolés
• Accélérant les cycles de développement et de livraison

Écosystème et communauté

L'écosystème Docker bénéficie d'une communauté active qui développe :

• Des milliers d'images officielles et communautaires sur Docker Hub
• Des outils d'orchestration de conteneurs comme Docker Swarm (natif à Docker) et Kubernetes
• Des solutions de monitoring et de logging adaptées aux conteneurs
• Des intégrations avec les principales plateformes cloud

Quelles sont les limites de Docker ?

Comme nous venons de le voir, Docker présente de nombreux avantages, mais aussi certains inconvénients, dont il convient de prendre connaissance avec de plonger dans l’écosystème Docker.

Limitation à un seul système d'exploitation

Docker crée plusieurs conteneurs sur un seul système d'exploitation. Si cette approche offre des avantages en termes de vitesse de démarrage et de traitement, elle peut également présenter des inconvénients. Par exemple, si vous souhaitez tester votre application dans un environnement Windows alors que votre machine hôte fonctionne sous Linux, vous devrez préparer une machine ou une machine virtuelle séparée.

Surcharge lors du développement à grande échelle

Docker est léger en lui-même, mais lorsqu'il est étendu à un système de grande envergure, la charge de gestion de Docker entre en jeu. Docker peut faire fonctionner de nombreux conteneurs sur un seul serveur, mais d'un autre côté, cela nécessite une gestion et une orchestration qui peuvent générer une surcharge. Il peut également devenir difficile de tout gérer en utilisant Docker seul sans recourir à des outils d’orchestration comme Docker Swarm ou encore Kubernetes.

Courbe d'apprentissage exigeante

Docker utilise une méthode différente pour créer des environnements virtuels par rapport aux autres machines virtuelles. Cela signifie que les équipes de développement doivent apprendre et appréhender tous ces nouveaux concepts. Utiliser Docker sans bien comprendre son fonctionnement peut entraîner des problèmes par la suite. Il est important d'étudier Docker de manière approfondie avant de commencer à l'utiliser.

Vulnérabilités de sécurité potentielles

Docker utilise une architecture basée sur les conteneurs. Comme plusieurs conteneurs fonctionnent sur une seule machine, il faut faire attention aux vulnérabilités qui peuvent en découler. Par exemple, s'il y a une vulnérabilité dans un conteneur, elle pourrait affecter tous les autres conteneurs qui partagent les ressources du système d'exploitation hôte et le noyau.

Difficultés dans la coopération entre conteneurs

Lorsque vous envisagez l'intégration entre plusieurs conteneurs, diverses configurations peuvent être difficiles, ce qui peut conduire à des problèmes opérationnels. Par exemple, si vous créez une application et une base de données dans des conteneurs séparés et souhaitez les faire fonctionner ensemble, vous devez configurer les paramètres de communication au sein du même hôte. L'ouverture de ports et de sockets pose des risques de sécurité. Si vous rendez les paramètres trop compliqués pour éviter cela, vous risquez alors de rencontrer des problèmes en production. Lors de l'intégration de conteneurs, il est important de bien réfléchir dès la phase de conception.

Comment GitLab résout les défis de Docker ?

GitLab transforme Docker d'un simple outil de conteneurisation en une solution DevSecOps complète et sécurisée. Cette plateforme intégrée résout les principaux défis auxquels font face les organisations utilisant Docker à grande échelle.

L'approche "shift-left" de GitLab intègre les contrôles de sécurité directement dans le pipeline de développement. Plutôt que de traiter la sécurité comme une étape finale, GitLab analyse automatiquement les images Docker dès leur construction, détectant les vulnérabilités, les configurations dangereuses et les dépendances obsolètes avant le déploiement. Cette détection précoce réduit considérablement les coûts de remédiation et élimine les risques de sécurité en production.

GitLab Runner et ses pipelines CI/CD transforment la gestion des conteneurs Docker en automatisant l'ensemble du cycle de vie DevSecOps. Cette infrastructure d'exécution permet la construction automatisée d'images Docker optimisées, la validation automatique de la sécurité et des performances et l'orchestration sécurisée vers différents environnements.

Le rôle de Docker dans l’approche DevSecOps de GitLab

Docker joue également un rôle très important dans l'intégration DevSecOps avec GitLab.

Conteneurisation des jobs CI/CD

GitLab CI/CD vous permet d'utiliser des conteneurs Docker dans vos pipelines CI/CD, vous apportant :

• Cohérence : les jobs CI/CD s'exécutent dans des conteneurs, éliminant les erreurs dues aux différences de dépendances et d'environnements
• Scalabilité : les conteneurs sont légers, rapides à démarrer et efficaces pour exécuter de larges pipelines
• Flexibilité d'environnement : vous pouvez spécifier différentes images Docker pour chaque job, facilitant la mise à disposition de l'environnement requis

L'image Docker GitLab Runner est basée sur Ubuntu ou Alpine Linux et inclut les commandes standard gitlab-runner qui la font fonctionner comme si vous aviez installé GitLab Runner directement sur l'hôte.

Scanning de sécurité automatisé

La sécurité est un composant clé de l’approche DevSecOps. GitLab la prend en charge dans les applications conteneurisées avec Docker à l’aide des scannings suivants :

• Scanning de sécurité des images de conteneurs : fournit la capacité de scanner les images Docker dans vos pipelines CI/CD, vérifiant les vulnérabilités des packages OS afin d'évaluer la sûreté des images avant qu’elles n’atteignent l’environnement de production
• Scanning en continue des vulnérabilités de conteneurs : recherche les failles de sécurité dans les dépendances existantes des applications en se basant sur leur SBOM et en comparant les noms et les versions des composants aux informations contenues dans les derniers avis de sécurité.
• Scanning opérationnel de conteneurs : exécute les analyses de vulnérabilités sur les conteneurs déployés dans un environnement Kubernetes. Cela comprend l'analyse régulière des images à la recherche de nouvelles vulnérabilités découvertes et le suivi des environnements dans lesquels ces vulnérabilités sont déployées.

Infrastructure as Code (IaC) et gestion d'environnement

• Reproductibilité : l’utilisation de Docker dans les jobs GitLab CI/CD assure la cohérence entre les environnements de développement et de production.
• Création instantanée d'environnements de staging et de test : en s'intégrant avec Docker Compose et Kubernetes, GitLab vous permet de créer des environnements isolés pour des branches spécifiques ou des merge requests, permettant des tests efficaces et un scanning de sécurité.

Déploiement rationalisé

GitLab supporte les modèles de déploiement suivants avec Docker :

• Compilation et push d'images Docker : construisez votre application sous forme d’image de conteneur et effectuez un push vers le registre de conteneurs de GitLab ou d'autres registres Docker.
• Livraison continue : utilisez des images Docker et déployez vers des outils d'orchestration de conteneurs pour des releases rapides et sécurisées.

Prise en charge de l'architecture de microservices

GitLab et Docker ensemble facilitent la construction d'architectures de microservices, où les microservices s'exécutent comme des conteneurs Docker séparés.

Avec les pipelines GitLab CI/CD, vous pouvez gérer :

• La configuration des dépendances entre services
• Les scans de sécurité individuels
• Le contrôle de version (facilite les retours à une version précédente)

Conclusion

Docker a transformé le paysage du développement logiciel en démocratisant la conteneurisation et en simplifiant la gestion des environnements d'exécution. Sa capacité à créer des applications portables, légères et facilement déployables en fait aujourd’hui un outil incontournable pour les équipes de développement.

L'intégration native avec GitLab renforce encore davantage sa valeur en proposant une plateforme DevSecOps complète. Cette synergie permet aux entreprises d'accélérer leurs cycles de développement logiciel tout en maintenant des standards élevés de sécurité et de qualité.

Pour les équipes souhaitant moderniser leurs pratiques de développement, l'adoption de Docker représente un investissement stratégique qui se traduit par une productivité accrue, des déploiements plus fiables, une meilleure évolutivité et un environnement flexible.

Vous souhaitez installer GitLab dans un conteneur Docker ? Consultez notre documentation pour en savoir plus.

FAQ sur Docker

Que peut-on faire avec Docker ?

Docker est une technologie de virtualisation légère et autonome qui empaquette le code d'application, ses dépendances et ses bibliothèques. Docker vous permet de créer plusieurs conteneurs (environnements virtuels) sur une seule machine, vous permettant d'unifier vos environnements de développement et de test.

À quoi sert Docker ?

Docker est utilisé par les équipes de développement pour découpler les applications et leurs dépendances du reste du système. Les conteneurs regroupent les applications et leurs dépendances ensemble et fournissent un environnement d'exécution léger.

Docker peut-il remplacer les machines virtuelles ?

Docker ne remplace pas complètement les machines virtuelles, mais offre une alternative plus légère pour de nombreux cas d'usage. Les conteneurs partagent le noyau du système hôte, tandis que les machines virtuelles émulent un système complet. Le choix dépend de vos besoins en isolation, performance et compatibilité système.

Note : certaines parties de cet article proviennent de l'article japonais Dockerとは：超入門編.

Alors que d'autres fournisseurs imposent des migrations vers des architectures exclusivement cloud, GitLab reste déterminée à prendre en charge les choix de déploiement qui correspondent à vos besoins métier. Que vous gériez des données gouvernementales sensibles, que vous opériez dans des environnements air-gapped ou que vous préfériez simplement le contrôle des déploiements self-managed, nous savons qu'une solution unique ne vous convient pas forcément.

Le cloud n'est pas toujours la solution

Pour les nombreuses entreprises qui ont investi des millions de dollars dans des déploiements Data Center, y compris celles qui ont migré vers Data Center après l'arrêt des produits Server, cette annonce représente bien plus qu'un simple arrêt de produit. Elle marque un changement fondamental dans l'approche des choix d'architecture centrés sur le client et place les entreprises face à un dilemme difficile : accepter un modèle de déploiement qui ne correspond pas à leurs besoins, ou trouver un fournisseur qui respecte leurs exigences.

Bon nombre d'organisations qui ont besoin de déploiements self-managed comptent parmi les plus importantes au monde : il s'agit de systèmes de santé protégeant les données des patients, d'institutions financières gérant des milliers de milliards d'actifs, d'agences gouvernementales chargées de la sécurité nationale et de sous-traitants de la défense opérant dans des environnements air-gapped.

Ces organisations ne choisissent pas les déploiements self-managed par commodité. Elles les choisissent pour répondre à des exigences de conformité, de sécurité et de souveraineté auxquelles les architectures exclusivement basées sur le cloud ne peuvent tout simplement pas satisfaire. Les organisations opérant dans des environnements fermés avec un accès Internet restreint ou inexistant ne font pas exception. Elles représentent une part importante des entreprises clientes dans divers secteurs.

→ Essayez GitLab Ultimate et GitLab Duo Enterprise gratuitement.

Le coût réel d'une migration forcée vers le cloud dépasse le simple aspect financier

Alors que les fournisseurs cloud présentent les migrations obligatoires comme des « mises à niveau », les organisations sont confrontées à des défis considérables qui vont bien au-delà des simples coûts financiers :

• Perte des capacités d'intégration : des années d'intégrations personnalisées avec des systèmes hérités, des workflows soigneusement élaborés et des automatisations spécifiques à l'organisation deviennent obsolètes. Les organisations fortement intégrées à des systèmes hérités estiment souvent que la migration vers le cloud est irréalisable d'un point de vue technique.

• Contraintes réglementaires : pour les organisations des secteurs réglementés, la migration vers le cloud n'est pas seulement complexe, elle est souvent interdite. Les exigences en matière de résidence des données, les environnements air-gapped et les frameworks réglementaires stricts ne s'adaptent pas aux préférences des fournisseurs. L'absence de solutions monolocataires dans de nombreuses approches exclusivement basées sur le cloud crée des obstacles insurmontables en matière de conformité.

• Impact sur la productivité : les architectures exclusivement cloud nécessitent souvent de jongler entre plusieurs produits : des outils distincts pour la planification, la gestion du code, le CI/CD et la documentation. Chaque outil implique un nouveau changement de contexte, une nouvelle intégration à maintenir, ou encore un nouveau point de défaillance potentiel. Les recherches menées par GitLab montrent que 30 % des équipes de développement consacrent au moins 50 % de leur temps à maintenir et/ou intégrer leur chaîne d'outils DevSecOps. Les architectures fragmentées exacerbent ce problème au lieu de le résoudre.

GitLab offre choix, engagement et consolidation

Les entreprises méritent un partenaire technologique fiable. C'est pourquoi nous nous sommes engagés à prendre en charge toute une gamme d'options de déploiement. Que vous ayez besoin d'une solution sur site pour la conformité, d'une solution hybride pour la flexibilité ou d'une solution cloud pour la commodité, le choix vous appartient. Cet engagement se reflète également dans GitLab Duo, notre solution d'IA qui accompagne les équipes de développement à chaque étape de leur workflow.

Mais nous offrons plus qu'une simple flexibilité de déploiement. Alors que d'autres fournisseurs peuvent vous obliger à combiner leurs produits pour former une chaîne d'outils fragmentée, GitLab fournit tout ce dont vous avez besoin dans une plateforme DevSecOps complète avec l'IA native. La gestion du code source, le CI/CD, le scanning de sécurité, la planification Agile et la documentation sont tous gérés au sein d'une seule application et d'une seule relation fournisseur.

Lorsque Airbus et Iron Mountain ont évalué leurs chaînes d'outils fragmentées existantes, ils ont systématiquement identifié les défis suivants : mauvaise expérience utilisateur, fonctionnalités manquantes comme le scanning de sécurité intégré et les environnements de test temporaires, et complexité de gestion liée au dépannage des plugins. Ce ne sont pas des défis mineurs, mais des obstacles majeurs à la livraison logicielle moderne.

Votre parcours de migration est plus simple que vous ne le pensez

Nous avons aidé des milliers d'organisations à migrer depuis d'autres fournisseurs, et nous avons développé les outils et l'expertise nécessaires pour faciliter votre transition :

• Outils de migration automatisés : notre outil d'importation Bitbucket Server transfère les dépôts, les pull requests, les commentaires et même les objets Large File Storage (LFS). Pour Jira, notre outil d'importation intégré gère les tickets, les descriptions et les labels, avec des services professionnels disponibles pour les migrations complexes.

• Efficacité prouvée à grande échelle : un dépôt de 500 Gio avec 13 000 pull requests, 10 000 branches et 7 000 tags ne prendra probablement que 8 heures à migrer de Bitbucket vers GitLab en utilisant le traitement parallèle.

• Retour sur investissement immédiat : une étude Total Economic Impact™ de Forrester Consulting commandée par GitLab révèle qu'investir dans GitLab Ultimate permet de traduire ces avantages en un impact réel sur les résultats financiers, avec un ROI de 483 % sur trois ans, un gain de temps multiplié par 5 dans les activités liées à la sécurité et 25 % d'économies sur les coûts liés à la chaîne d'outils logiciels.

Commencez votre transition vers une plateforme DevSecOps unifiée

Les organisations avant-gardistes n'attendent pas les échéances imposées par les fournisseurs. Elles évaluent les alternatives dès maintenant, pendant qu'elles ont encore le temps de migrer de manière réfléchie vers des plateformes qui protègent leurs investissements et tiennent leurs promesses.

Les organisations investissent dans des déploiements self-managed parce qu'elles ont besoin de contrôle, de conformité et de personnalisation. Lorsque les fournisseurs déprécient ces capacités, ils suppriment non seulement des fonctionnalités, mais aussi la possibilité fondamentale de choisir des environnements adaptés aux exigences métier.

Les plateformes DevSecOps modernes doivent offrir des fonctionnalités complètes qui respectent les besoins de déploiement, consolident les chaînes d'outils et accélèrent la livraison logicielle, sans imposer de compromis en matière de sécurité ou de souveraineté des données.

Contactez notre équipe commerciale dès aujourd'hui pour discuter de vos options de migration, ou explorez nos ressources et découvrez comment des milliers d'organisations ont déjà effectué leur transition vers GitLab.

→ Essayez GitLab Ultimate et GitLab Duo Enterprise gratuitement.

Le flow « ticket à merge request » simplifie la transformation d'un ticket détaillé en brouillon de merge request (MR). Le flow analyse la description et les exigences d'un ticket, ouvre une merge request liée au ticket, crée un plan de développement et propose une implémentation, directement depuis l'interface de GitLab.

Le défi des équipes de développement

Les mises à jour telles que la réorganisation d'une interface utilisateur, l'ajustement de la taille d'un composant ou la modification mineure d'un workflow ne devraient pas nécessiter des heures de configuration. Pourtant, les équipes de développement se retrouvent face à un cycle frustrant : elles doivent rechercher dans le code source pour localiser les bons fichiers, créer des branches, rassembler des modifications dispersées à travers de multiples composants et gérer des processus de revue complexes, avant même de pouvoir vérifier si leur solution fonctionne. Ce processus de développement trop complexe transforme ce qui devrait être des itérations rapides en tâches chronophages qui ralentissent les boucles de rétroaction et transforment des améliorations simples en projets majeurs.

Comment utiliser le flow « ticket à merge request » pour accélérer une mise à jour d'application ?

Vous devez d'abord remplir les conditions ci-dessous avant d'utiliser ce flow :

• Un ticket existant avec des exigences claires et des critères d'acceptation. GitLab Duo Agent Platform arrivera ainsi à mieux comprendre ce que vous essayez d'accomplir et à améliorer la qualité du résultat.
• Un niveau d'accès Développeur ou plus au projet, car le flow apportera des modifications au code source de votre projet.
• GitLab Duo Agent Platform activée pour votre groupe ou projet, avec les flows autorisés. Pour activer cette option, allez dans Paramètres > Général > GitLab Duo > Autoriser l'exécution des flows. GitLab s'engage à fournir des garde-fous, c'est pourquoi les fonctionnalités d'IA agentique nécessitent l'activation de ces options pour protéger les projets sensibles et garantir que seuls les projets sélectionnés sont accessibles à GitLab Duo Agent Platform.

Une fois que vous avez rempli toutes les conditions ci-dessus, suivez les étapes ci-dessous pour tirer parti de ce flow :

1. Créez un ticket de projet qui décrit ce que vous souhaitez que GitLab Duo Agent Platform accomplisse pour vous. Fournissez autant de détails que possible dans la description. Si le ticket existe déjà, ouvrez-le en allant dans Programmation > Tickets et cliquez sur le ticket qui décrit la mise à jour que vous souhaitez. Assurez-vous que le ticket soit précis et détaillé.
2. Sous l'en-tête du ticket, cliquez sur Générer une MR avec GitLab Duo pour lancer le flow.
3. Si vous souhaitez suivre la progression des agents qui travaillent sur l'implémentation de votre ticket, accédez à Automatisation > Sessions d'agent pour voir le journal de session en direct pendant que les agents planifient et proposent des modifications.
4. Une fois le pipeline terminé, un lien vers la merge request apparaît dans l'activité du ticket. Ouvrez-le pour examiner le résumé et les modifications apportées au niveau des fichiers.
5. Si vous souhaitez valider localement les mises à jour proposées par GitLab Duo Agent Platform, vous pouvez effectuer un pull de la branche sur votre ordinateur, compiler et exécuter votre application, puis vérifier que la mise à jour fonctionne comme prévu. Si nécessaire, effectuez des modifications dans la merge request et procédez à la revue habituelle.
6. Si vous êtes satisfait de toutes les mises à jour de l'application proposées, fusionnez la merge request dans la branche principale.

Pourquoi utiliser le flow « ticket à merge request » pour modifier une application ?

Ce flow propose des modifications de code et met à jour directement la merge request. Résultat : vous passez moins de temps à localiser des fichiers et n'avez qu'à évaluer et examiner le résultat. De plus, la merge request est automatiquement liée au ticket d'origine, ce qui maintient un contexte précis pour les relecteurs et les parties prenantes. Enfin, vous pouvez surveiller la session de l'agent afin de suivre toutes les étapes.

Quels sont les avantages de GitLab Duo Agent Platform ?

GitLab Duo Agent Platform est une couche d'orchestration agentique qui fournit un contexte complet au projet, notamment la planification, le codage, la compilation, la sécurisation, le déploiement et la surveillance, afin que les agents puissent aider tout au long du cycle de développement logiciel (SDLC), et pas seulement pour l'édition de code.

• Modèle de données unifié : les agents GitLab Duo opèrent sur les données unifiées du SDLC de GitLab afin de fournir des décisions de meilleure qualité et une collaboration entre les tâches, y compris celles qui ne concernent pas le codage.
• Sécurité et conformité intégrées : les agents GitLab Duo fonctionnent avec des garde-fous à l’échelle de l'entreprise et peuvent être utilisés même dans des environnements hautement réglementés ou hors ligne/air-gapped.
• Interopérabilité et extensibilité : orchestrez des flow entre fournisseurs et outils ; connectez des données externes via les protocoles MCP/Agent2Agent pour un contexte plus riche.
• Collaboration à grande échelle : les agents GitLab Duo fonctionnent dans l'interface utilisateur de GitLab et les IDE afin d'offrir une collaboration multiple entre humains et agents.
• Découvrabilité et partages : trouvez et partagez des agents et des flows dans un catalogue d'IA centralisé.

Essayez le flow « ticket à merge request » dès maintenant

Pour les mises à jour d'application, comme un ajustement mineur de l'interface utilisateur, le flow « ticket à merge request » vous aide à passer rapidement d'un ticket clair à une merge request à réviser : vous pouvez surveiller la progression et valider les modifications dans votre workflow standard. Le flow maintient le contexte, réduit les transferts et permet à votre équipe de se concentrer sur la qualité plutôt que sur des tâches fastidieuses.

Découvrez le flow en action :

<!-- blank line -->

<figure class="video_container"> <iframe src="https://www.youtube.com/embed/BrrMHN4gXF4?si=J7beTgWOLxvS4hOw" frameborder="0" allowfullscreen="true"> </iframe> </figure> <!-- blank line -->

Essayez dès maintenant le flow « ticket à merge request » sur GitLab Duo Agent Platform en profitant d'un essai gratuit de GitLab Ultimate avec GitLab Duo Enterprise.

Les utilisateurs ont désormais la possibilité de choisir Claude Sonnet 4.5 aux côtés d'autres modèles de premier plan, améliorant ainsi leur expérience avec GitLab Duo grâce à des avancées en matière d'orchestration d'outils, d'édition contextuelle et de capacités spécifiques à chaque domaine. Avec des performances de pointe sur SWE-bench Verified (77,2 %) et des atouts en matière de cybersécurité, de finance et de workflows nécessitant des recherches approfondies, les utilisateurs de GitLab peuvent exploiter Claude Sonnet 4.5 pour obtenir des informations plus précises et un contexte plus approfondi dans leurs travaux de développement.

« L’intégration de Claude Sonnet 4.5 dans GitLab représente une avancée majeure pour les équipes de développement. Il s'agit d'un modèle de développement particulièrement performant qui, associé à GitLab Duo Agent Platform, vous offre une assistance plus intelligente directement dans vos workflows. C'est le type d'évolution qui facilite le développement », déclare Taylor McCaslin, Principal, Strategy and Operations for AI Partnerships chez GitLab.

GitLab Duo Agent Platform et Claude Sonnet 4.5

GitLab Duo Agent Platform amplifie la valeur de Claude Sonnet 4.5 en orchestrant les agents, en les connectant aux systèmes internes et en les intégrant tout au long du cycle de développement logiciel. Cette combinaison crée une expérience unique, où le raisonnement avancé et la résolution de problèmes rencontrent le contexte et la sécurité à l'échelle de la plateforme. Le résultat : un développement plus rapide, des résultats plus précis et une couverture organisationnelle renforcée, le tout intégré dans le workflow de GitLab que les équipes de développement utilisent déjà au quotidien.

Où utiliser Claude Sonnet 4.5 ?

Claude Sonnet 4.5 est désormais disponible en tant qu'option de modèle dans GitLab Duo Agent Platform Agentic Chat sur GitLab.com. Vous pouvez sélectionner Claude Sonnet 4.5 dans le menu déroulant de sélection des modèles pour tirer parti de ses capacités de codage avancées dans vos tâches de développement.

Remarque : La possibilité de sélectionner Claude Sonnet 4.5 dans les IDE pris en charge sera bientôt disponible.

Premiers pas

Les clients GitLab Duo Pro et GitLab Duo Enterprise peuvent accéder à Claude Sonnet 4.5 dès aujourd'hui. Consultez notre documentation pour en savoir plus sur les fonctionnalités et les modèles de GitLab Duo.

Vous souhaitez essayer GitLab Ultimate avec GitLab Duo Enterprise ? Commencez un essai gratuit dès aujourd'hui.

GitLab et Yubico se sont associés pour renforcer la sécurité du développement logiciel au moyen de mesures d'authentification robustes. Yubico est l'inventeur de la YubiKey, une clé de sécurité qui offre une authentification multifacteur (MFA) résistante au phishing. En implémentant le protocole FIDO Universal 2nd Factor (U2F) et la protection matérielle YubiKey, GitLab offre aux équipes de développement une défense puissante contre les attaques de phishing et autres cybermenaces afin de garantir la sécurité de leur code et de leurs projets. Cette collaboration renforce l'authentification de niveau entreprise dans la plateforme GitLab et aide les équipes de développement à se concentrer sur la création de logiciels et à avoir confiance en l'intégrité de leur compte.

Découvrez dans cet article comment configurer GitLab pour utiliser les YubiKeys afin de protéger vos équipes contre les menaces en ligne. Vous apprendrez également comment prévenir davantage la falsification de code avec les commits vérifiés de GitLab.

Comment fonctionnent les YubiKeys ?

Les YubiKeys fonctionnent comme des tokens matériels cryptographiques qui génèrent et stockent des clés privées dans un environnement sécurisé. Ces clés implémentent les protocoles d'authentification FIDO2/WebAuthn, qui peuvent être utilisés comme facteur supplémentaire pour se connecter à GitLab.

Voici comment la connexion fonctionne :

1. Vous saisissez votre nom d'utilisateur et votre mot de passe.

2. GitLab envoie un défi cryptographique à votre navigateur.

3. Votre navigateur demande à la YubiKey de signer ce défi.

4. Vous touchez physiquement la YubiKey pour approuver la connexion.

5. La YubiKey crée une signature cryptographique unique pour ce service et ce défi spécifiques.

6. GitLab vérifie la signature à l'aide de votre clé publique stockée lors de la configuration.

La plupart des violations de sécurité majeures sont liées à des mots de passe compromis. Une clé YubiKey garantit la sécurité de votre compte contre une violation à distance. En cas de vol de votre mot de passe, votre compte GitLab reste sécurisé.

La clé YubiKey offre d'autres avantages pour l'authentification sur GitLab :

• Protection contre le phishing : les sites frauduleux n'auront pas les bonnes clés cryptographiques pour vérifier la réponse.

• Aucun secret à voler : la clé privée ne quitte jamais la YubiKey.

• Sécurité physique : une présence physique est requise pour la connexion (vous devez toucher la YubiKey).

Configuration de l'authentification multifacteur YubiKey dans GitLab

Voyons maintenant comment configurer une YubiKey pour l'authentification multifacteur dans GitLab. Assurez-vous d'utiliser un navigateur et un système d'exploitation pris en charge, car ils offrent une meilleure compatibilité WebAuthn pour les clés de sécurité matérielles.

1. Connectez-vous à votre compte GitLab et accédez à vos paramètres utilisateur (cliquez sur votre avatar dans le coin supérieur gauche et sélectionnez Préférences).

2. Dans la barre latérale gauche, cliquez sur Compte et accédez à la section Authentification à deux facteurs.

3. Si vous n'avez pas encore activé l'authentification à deux facteurs, faites-le maintenant.

   a. Cliquez sur Activer l'authentification à deux facteurs.

   b. Scannez le QR code avec votre application d'authentification.

   c. Saisissez le code fourni par votre application d'authentification.

   d. Saisissez votre mot de passe GitLab. Si vous avez besoin d’accéder à votre compte GitLab sans utiliser l'authentification Google, vous devrez peut-être :

   • Utiliser l'option Mot de passe oublié sur la page de connexion GitLab pour configurer un mot de passe GitLab distinct.
   • Contacter votre administrateur GitLab pour configurer une autre méthode de connexion.

   e. Enregistrez vos codes de récupération dans un endroit sûr.

4. Une fois l'authentification à deux facteurs activée, revenez à l'écran précédent en cliquant sur Gérer l'authentification à deux facteurs et faites défiler jusqu'à la section Enregistrer un token matériel.

5. Cliquez sur le bouton Configurer un nouvel appareil. a. Une fenêtre contextuelle de votre navigateur devrait apparaître. Remarque : cette image peut varier selon votre navigateur. Si des fenêtres contextuelles de vos gestionnaires de mots de passe s'affichent, ignorez-les.

    b. Sélectionnez Utiliser un téléphone, une tablette ou une clé de sécurité.

6. Une nouvelle fenêtre contextuelle apparaîtra.

    a. Insérez votre YubiKey dans le port USB de votre ordinateur.

    b. Touchez le contact métallique/bouton sur votre YubiKey lorsque vous y êtes invité. Le champ se remplira automatiquement avec un code à usage unique.

7. Saisissez votre mot de passe GitLab et attribuez un nom à votre clé.

8. Cliquez sur Enregistrer pour ajouter la YubiKey à votre compte.

Votre YubiKey est maintenant enregistrée et peut être utilisée comme second facteur d’authentification lors de votre connexion à GitLab. Vous pouvez enregistrer plusieurs YubiKeys sur votre compte à des fins de sauvegarde. Remarque : le processus peut légèrement varier selon les navigateurs.

<center><i>Enregistrement de la YubiKey</i></center>

Comment se connecter avec une YubiKey sur GitLab ?

Maintenant que votre YubiKey est configurée, vous pouvez vous connecter comme suit :

1. Accédez à GitLab.com.

2. Indiquez votre nom d'utilisateur et votre mot de passe, puis cliquez sur le bouton Se connecter.

3. Vous serez redirigé vers l'écran suivant.

    a. Une fenêtre contextuelle, comme celle ci-dessous, devrait apparaître. Remarque : cette image peut varier selon votre navigateur. Si des fenêtres contextuelles de vos gestionnaires de mots de passe s'affichent, ignorez-les.

    b. Insérez votre YubiKey dans le port USB de votre ordinateur.

    c. Touchez le contact métallique/bouton sur votre YubiKey lorsque vous y êtes invité. Le champ se remplira automatiquement avec un code à usage unique.

Vous devriez être désormais connecté. Vous serez ensuite redirigé vers votre page GitLab.

Remarque : le processus peut légèrement varier selon les navigateurs.

Que se passe-t-il si je perds ma YubiKey ?

Yubico recommande d'utiliser et de conserver une YubiKey de secours. Pensez à votre maison, votre voiture ou votre bureau : vous possédez sûrement une clé de secours dans un endroit sûr. Votre identité numérique devrait bénéficier du même niveau d’attention. Une deuxième YubiKey garantit une sauvegarde rapide et sûre si vous perdez votre clé principale et vous permet également de désactiver facilement la clé perdue et d'ajouter une nouvelle clé principale ou secondaire.

Si vous n'avez pas ajouté de YubiKey supplémentaire, nous vous recommandons de configurer une autre forme d'authentification à deux facteurs à vos comptes. Dans les deux cas, vous devriez être en mesure d'accéder à votre compte et de retirer la clé perdue. Veuillez noter que sans une clé de sauvegarde ou une autre méthode d'authentification, vous devrez contacter le service/site web afin d'obtenir de l'aide pour récupérer votre compte.

Commits vérifiés de GitLab

Pour prévenir davantage la falsification de code, vous pouvez également configurer des commits vérifiés. Dans GitLab, ceux-ci utilisent des signatures GPG (GNU Privacy Guard) pour prouver qu’un commit provient réellement de vous. Ce processus ajoute une couche de sécurité en plus de l'authentification et garantit que non seulement votre compte est sécurisé, mais aussi que chaque modification de code peut être vérifiée de façon cryptographique comme provenant de vous.

Votre YubiKey peut stocker des clés GPG :

• La clé privée est stockée en toute sécurité sur la YubiKey.

• La clé publique est partagée avec GitLab.

• La paire de clés est utilisée pour signer vos commits.

Une fois les clés GPG configurées :

• Lorsque vous effectuez un commit, Git utilise votre clé privée pour créer une signature.

• La clé GPG est accessible depuis la YubiKey connectée.

• La signature est stockée avec les métadonnées du commit.

• GitLab vérifie la signature à l'aide de votre clé publique.

Configuration des commits vérifiés

Voyons comment configurer les commits vérifiés. Dans cet exemple, la clé GPG est stockée dans votre YubiKey et offre une couche de sécurité supplémentaire.

1. Installez le logiciel requis.

# On macOS


brew install --cask yubico-yubikey-manager


brew install gnupg gpg yubikey-manager



# On Ubuntu/Debian


sudo apt install gnupg gpg yubikey-personalization



# On Windows


# Download and install Gpg4win from https://gpg4win.org

2. Vérifiez le statut GPG de la YubiKey.

gpg --card-status

3. Générez des clés GPG directement sur la YubiKey (processus plus sécurisé).

# Start GPG edit mode


gpg --card-edit



# Enter admin mode


admin



# Generate key directly on card


# PIN = '123456' | Admin PIN = '12345678'


generate



# Follow prompts


# See documentation for more info


#

https://support.yubico.com/hc/en-us/articles/360013790259-Using-Your-YubiKey-with-OpenPGP

4. Exportez votre clé publique.

# Get your key ID


gpg --list-secret-keys --keyid-format LONG



# Export the public key


gpg --armor --export YOUR_KEY_ID

5. Ajoutez la clé publique à GitLab.

   a. Cliquez sur votre Avatar GitLab et sélectionnez Préférences.

   b. Dans l'onglet latéral, sélectionnez Clés GPG.

   c. Cliquez sur Ajouter une nouvelle clé.

   d. Collez votre clé publique.

   e. Cliquez sur Ajouter la clé.

6. Configurez Git.

# Set signing key


git config --global user.signingkey YOUR_KEY_ID



# Enable automatic signing


git config --global commit.gpgsign true



# Tell GPG which key to use


echo "default-key YOUR_KEY_ID" >> ~/.gnupg/gpg.conf

7. Testons maintenant la configuration en créant un commit test dans un projet :

# Make a change in the project


# Add changes


git add .



# Make a test commit


git commit -S -m "Test signed commit"



# Verify signature


git verify-commit HEAD



# Push the change


git push

La commande git verify-commit HEAD devrait afficher la clé GPG utilisée :

gpg: Signature made Wed Feb 26 11:45:00 2025 CST


gpg:                using RSA key YOUR_KEY_ID


gpg: Good signature from “NAME (DESCRIPTION) <EMAIL>" [ultimate]

Une fois le commit effectué dans GitLab, vous devriez voir qu'il est vérifiée comme suit :

<center><i>Commit vérifié avec la clé GPG</i></center>

Vous pouvez également utiliser l'API des commits pour vérifier la signature d’un commit, ce qui vous permet d'opérationnaliser davantage le workflow de vérification.

En savoir plus

Pour en savoir plus sur GitLab et Yubico, consultez ces ressources :

• Pourquoi choisir GitLab ?

• Pourquoi choisir Yubico ?

• Solutions de sécurité et de conformité de GitLab

• Annonce concernant GitLab dans le catalogue des plateformes compatibles avec YubiKey

• Documentation sur les commits verifiés de GitLab

• Règles de push dans GitLab

• Documentation relative à la signature de commits avec des clés GPG

Cette reconnaissance valide, selon nous, notre stratégie de plateforme complète à un moment crucial pour le développement logiciel. Les organisations s'empressent d'adopter les capacités alimentées par l'IA tout en maintenant la sécurité, la conformité et l'excellence opérationnelle. Le succès exige une approche de plateforme unifiée qui transforme la façon dont les équipes collaborent et créent de la valeur.

Que nos clients livrent des logiciels agiles, développent des applications cloud-native ou conçoivent des plateformes, GitLab leur permet de collaborer étroitement avec des agents d’IA pour livrer des logiciels sécurisés et fiables, plus rapidement.

<p></p>

Téléchargez les rapports pour en savoir plus.

Une durée de création de valeur accélérée

Notre mission est de permettre à chacun de contribuer et de co-créer des logiciels qui font fonctionner notre monde. Le rythme rapide de notre programme d'innovation démontre que nous sommes loin d'avoir terminé. Nous avons livré de nouvelles solutions à nos clients chaque mois pendant plus de 150 mois, et nous prévoyons de poursuivre cette tradition.

En tant que leader du secteur, nous restons déterminés à aider nos clients à transformer ces nouvelles capacités en valeur commerciale.

Nous sommes convaincus qu'à l'heure où l'innovation alimentée par l'IA s'accélère dans l'ensemble de l'écosystème technologique, il n'a jamais été aussi important qu'aujourd'hui d'adopter une approche de plateforme unifiée pour relever les défis d'ingénierie les plus complexes de nos clients. Cette approche permet aux organisations de réduire les coûts d'intégration, de combler les failles de sécurité et d'adopter l'innovation sans perturber les workflows de livraison de logiciels existants.

Voici quelques exemples :

• Accélérez les releases avec l'IA agentique : les chaînes d'outils fragmentées ralentissent les revues de code et les tests. Les agents et les flows de GitLab Duo automatisent un certain nombre de tâches comme les revues de code, la génération de tests et le tri des vulnérabilités dans le contexte de la plateforme complète, aidant les équipes à réduire les temps de cycle et à améliorer la qualité des logiciels.
• Construisez de manière sécurisée dès le départ : de nombreuses organisations traitent la sécurité comme une réflexion après coup, ce qui entraîne des rectifications coûteuses et des lacunes en matière de conformité. GitLab intègre l'analyse, l'application des politiques et les contrôles de conformité dans les workflows quotidiens, détectant les risques le plus tôt possible sans ralentir les équipes de développement.
• Déployez avec flexibilité : les équipes soumises à des contraintes réglementaires ou opérationnelles strictes ont besoin d'options de déploiement allant au-delà du SaaS multilocataire. GitLab prend en charge les environnements SaaS, self-managed et air-gapped, afin de garantir aux clients un contrôle que les concurrents ne peuvent offrir.
• Offrez une innovation constante : la fragmentation des outils rend l'adoption de nouvelles fonctionnalités risquée et perturbatrice. Les releases mensuelles de GitLab offrent de nouvelles fonctionnalités, telles que GitLab Duo Agent Platform, une gouvernance IA étendue et des intégrations cloud que les équipes peuvent adopter sans avoir à se rééquiper.

Les cas d'utilisation clients qui comptent le plus

Tout comme le Magic Quadrant, nous pensons que le rapport Critical Capabilities 2025 de Gartner dédié aux plateformes DevOps évalue la capacité des plateformes à répondre aux besoins réels des clients. GitLab s'est classée en première position dans 4 des 6 cas d'utilisation présentés dans ce rapport.

GitLab prend en charge les domaines d'innovation suivants :

• Ensemble d'outils intégrés pour une livraison cloud-native et à l'échelle de l’entreprise
• Outils de planification avancés et fonctionnalités de sécurité étendues
• Gestion des paquets et feature flags pour une livraison progressive
• Mesures de la chaîne de valeur pour une visibilité et une amélioration tout au long du cycle de développement logiciel.
• Workflows avec l’IA native, intégrés directement dans les tâches quotidiennes

Cette polyvalence se traduit par une réelle valeur ajoutée pour les clients, comme l'explique Bal Kang, Engineering Platform Lead chez NatWest :

« L'intégration des agents d’IA de GitLab Duo dans notre système d'enregistrement pour le code, les tests, le CI/CD et l'ensemble du cycle de développement logiciel stimule la productivité, la vélocité et l'efficacité. Les agents comprennent l'intention, décomposent les problèmes et agissent, devenant de véritables collaborateurs pour nos équipes. »

Le passage à des plateformes unifiées représente un changement fondamental dans la façon dont les organisations abordent le développement logiciel. C'est pourquoi, selon nous, Gartner® nous a également récemment nommé Leader dans le Magic Quadrant™ 2025 dédié aux assistants IA pour le code.

Alors que les entreprises cherchent à maximiser la productivité des équipes de développement de manière sécurisée et à accélérer l'innovation, une approche de plateforme complète devient plus urgente que jamais.

Téléchargez les rapports pour en savoir plus.

Source : Gartner, Magic Quadrant for DevOps Platforms, Keith Mann, Thomas Murphy, Bill Holz, George Spafford, 22 septembre 2025

Source : Gartner, Critical Capabilities for DevOps Platforms, Thomas Murphy, Keith Mann, George Spafford, Bill Holz, 22 septembre 2025

GARTNER est une marque déposée et une marque de service de Gartner, Inc. et/ou de ses sociétés affiliées aux États-Unis et dans le monde, et MAGIC QUADRANT est une marque déposée de Gartner, Inc. et/ou de ses sociétés affiliées et sont utilisées ici avec autorisation. Tous droits réservés.

Gartner ne cautionne aucun fournisseur, produit ou service décrit dans ses publications de recherche et ne conseille pas aux utilisateurs de la technologie de sélectionner uniquement les fournisseurs ayant les notes les plus élevées ou toute autre désignation. Les publications de recherche de Gartner reflètent les opinions de l'organisation de recherche de Gartner et ne doivent pas être interprétées comme des déclarations de fait. Gartner décline toute garantie, expresse ou implicite, concernant cette recherche, y compris toute garantie de qualité marchande ou d'adéquation à un usage particulier.

Ce graphique a été publié par Gartner Inc. dans le cadre d'un rapport plus large et doit être évalué dans le contexte de l’ensemble du document. Le document Gartner est disponible sur demande auprès de Gartner B.V.

Face à ce défi, la gestion des vulnérabilités apporte une réponse concrète. En identifiant, priorisant et corrigeant les vulnérabilités de manière structurée, cette approche permet de maintenir la cadence de développement tout en renforçant la sécurité des logiciels.

Pour mettre en œuvre cette approche avec succès, ce guide vous présente les différents types de vulnérabilités et leurs risques, détaille chaque étape d'un processus de gestion efficace, et partage les meilleures pratiques en la matière. Vous découvrirez également comment la plateforme DevSecOps de GitLab peut optimiser cette démarche et sécuriser durablement vos développements logiciels.

Qu’est-ce que la gestion des vulnérabilités ?

La gestion des vulnérabilités, appelée aussi vulnerability management, représente l'ensemble des processus destinés à identifier et à neutraliser les risques liés aux failles de sécurité dans les systèmes d'information.

Cette discipline essentielle de la cybersécurité s'articule autour d'un cycle qui comprend la détection proactive des vulnérabilités, leur classification selon leur niveau de sévérité, la définition des priorités de remédiation, le suivi des actions correctives et l’amélioration constante des pratiques de sécurité pour anticiper au mieux les futures menaces.

Vous souhaitez renforcer la sécurité de vos logiciels ? Commencez un essai gratuit de GitLab Ultimate dès aujourd'hui !

Quels sont les différents types de vulnérabilité ?

Ces vulnérabilités, variées et en constante évolution, représentent une menace permanente pour les entreprises qui doivent s’adapter continuellement à un paysage de menaces en perpétuelle mutation. Dans une démarche de gestion structurée, il convient de distinguer deux grandes familles de vulnérabilités :

• Les vulnérabilités techniques : elles sont liées aux logiciels, au matériel ou aux protocoles utilisés dans le système d'information. Les cyberattaques s'appuient le plus souvent sur des erreurs de programmation ou de configuration du code, des défauts conceptuels ou des versions obsolètes d'un logiciel. Les vulnérabilités des dépendances logicielles, les secrets exposés dans le code et les bogues non corrigés offrent aussi un angle d'attaque aux données du système.
• Le facteur humain : il constitue le second type de vulnérabilité que les outils de gestion des vulnérabilités cherchent à maîtriser. Il peut s’agir d’une erreur humaine comme des pratiques de codage non sécurisées, d’un manque de sensibilisation aux bonnes pratiques en matière de sécurisation logicielle, ou encore d’une mauvaise communication entre les services de l’entreprise.

Quelles sont les conséquences d'une mauvaise gestion des vulnérabilités ?

Une vulnérabilité non corrigée peut avoir des effets désastreux, tant sur le plan financier qu'humain. C’est une menace potentielle pour les entreprises, avec des répercussions à de nombreux niveaux :

• Atteinte aux actifs. La compromission de la sécurité peut entraîner la perte de ressources critiques, de données stratégiques et d'informations sensibles. Cela nuit aux processus internes, aux opérations commerciales et aux relations économiques de l'entreprise.
• Pertes financières. Une faille de protection peut engendrer des coûts financiers considérables pour l’entreprise. Aux frais liés aux interruptions de service et aux pertes de productivité, il faut aussi ajouter la mise à jour des systèmes et parfois même le paiement de rançon aux cybercriminels.
• Conformité et amendes. Les incidents de sécurité exposent l'entreprise à des poursuites judiciaires et à des amendes importantes en cas de non-conformité des systèmes, de préjudices subis par des tiers, et de manquement à des réglementations telles que le Règlement Général sur la Protection des Données (RGPD).
• Perte de réputation. La vulnérabilité d'une entreprise met aussi en danger sa réputation et son image de marque. Si des informations sensibles de clients ou partenaires sont exposées, la perte de confiance qui en résulte assombrit les perspectives commerciales de l'entreprise.
• Impact sur la vélocité de développement. Les vulnérabilités découvertes tardivement dans le cycle de développement ralentissent considérablement les déploiements et augmentent les coûts de correction.

D’après notre rapport Global DevSecOps 2024 sur « La sécurité des applications à l'ère du numérique », 55 % des membres de l'équipe de sécurité affirment que les vulnérabilités sont principalement découvertes par la sécurité après le merge du code dans un environnement de test.

Pour se défendre, les entreprises se doivent d'adopter une approche proactive en matière de gestion des vulnérabilités et réduire ainsi au maximum leur surface d’attaque.

Comment mettre en place un processus de gestion des vulnérabilités ?

La complexité et la diversité des menaces exigent une réponse structurée et continue de la part des équipes de développement et de sécurité. Un processus de gestion des vulnérabilités efficace repose sur plusieurs étapes rigoureuses :

1. Identification des composants logiciels. Avant d'identifier des vulnérabilités, il est essentiel de connaître l'étendue du code et des dépendances utilisées. Cette étape consiste à identifier les bibliothèques, frameworks et composants présents dans les logiciels, afin d'avoir une vision claire des éléments à surveiller.
2. Analyse des vulnérabilités. Cette étape consiste à rechercher activement toutes les vulnérabilités présentes dans le code source et les dépendances, en les comparant aux bases de connaissance des vulnérabilités connues afin d'identifier les menaces. Pour cela, il est recommandé de mettre en place des tests de sécurité automatisés (SAST, DAST, analyse des dépendances) afin de corriger ces vulnérabilités le plus tôt possible.
3. Hiérarchisation des risques. En gestion des vulnérabilités, toute faiblesse ne présente pas le même niveau de risque. L'étape d'évaluation des risques permet de prioriser les failles en fonction de leur facilité d'exploitation, de leur niveau de sévérité, et de leur impact potentiel sur l’entreprise et ses clients.
4. Correction et vérification. Une fois les vulnérabilités identifiées et hiérarchisées, les actions correctives interviennent à travers des corrections de code, des modifications architecturales ou des mises à jour de dépendances. Les corrections sont testées avant et après la mise en production pour garantir la résolution complète des vulnérabilités. Pour accélérer ce processus, GitLab permet notamment à ses utilisateurs de suggérer des corrections automatiques et de créer des merge requests à l’aide de l’IA.
5. Surveillance continue. La surveillance en temps réel permet de détecter les nouvelles expositions aux menaces et de rester agile face à l'évolution des risques. Cette surveillance doit s’opérer tout au long du développement de logiciels, avant, pendant et après la mise en production.

Enfin, les processus et outils de gestion des vulnérabilités incluent une réévaluation périodique. Chaque étape est régulièrement réévaluée à mesure que le panorama des menaces change et que les logiciels et les langages de programmation évoluent. Ce cycle itératif garantit un niveau de sécurité optimal et actualisé. Une approche continue et adaptative de la gestion des vulnérabilités différencie une entreprise bien protégée d'une autre à risque.

Intégrez la sécurité à chaque étape du cycle de développement avec l’approche DevSecOps

L'approche DevSecOps représente un changement fondamental dans la gestion des vulnérabilités. Plutôt que de traiter la sécurité comme une étape finale, elle l'intègre tout au long du cycle de développement logiciel.

Cette approche « shift left » permet :

• D’anticiper les risques : l'identification précoce des vulnérabilités réduit drastiquement les coûts de correction et évite les retards de livraison. Responsabiliser les équipes : la sécurité devient une responsabilité partagée, transformant chaque membre de l'équipe en gardien de la qualité du code.
• Automatiser les processus : l'automatisation des analyses libère les équipes des tâches répétitives et accélère la résolution des problèmes.
• Améliorer la collaboration entre les équipes : le rapprochement des équipes Dev et Sec favorise une communication fluide et une résolution plus rapide des vulnérabilités.

Les entreprises comme Airbus qui utilisent GitLab bénéficient de cette approche pour protéger leur code, grâce à l’ajout de scans de sécurité et de vulnérabilité aux tests d'intégration. « Auparavant, toute modification d'une portion du code affectait le fonctionnement d'une autre portion. Nous pouvons désormais identifier les problèmes éventuels dès qu'un développeur effectue un push du code », explique Logan Weber, Software Automation Engineer chez Airbus.

Gestion des vulnérabilités : nos bonnes pratiques

L'évolution rapide des technologies et l'augmentation constante des cybermenaces oblige chaque entreprise à mettre en place les meilleures pratiques de gestion des vulnérabilités (ou vulnerability management). Elles impliquent le changement des habitudes de travail, la modernisation des méthodes de communication, et la sensibilisation des équipes, y compris du management, à ces différents sujets.

Découvrez nos bonnes pratiques pour sécuriser vos logiciels :

• Approche proactive. La prévention constitue le pilier d'une stratégie de sécurité efficace. Anticiper les vulnérabilités et déployer des mesures préventives s'avère infiniment plus rentable que de réagir après qu’une faille de sécurité ne soit exploitée. Cette démarche d'anticipation, associée à une capacité d'adaptation face aux évolutions technologiques, permet aux entreprises de transformer la gestion des vulnérabilités en avantage concurrentiel plutôt qu'en contrainte opérationnelle.
• Collaboration des équipes. Les processus bureaucratiques constituent un frein majeur à la résolution rapide des vulnérabilités, affectant plus de la moitié des équipes de sécurité selon notre Rapport Global DevSecOps 2024. Face à ce constat, l'établissement d'une communication directe et efficace entre les équipes DevSecOps devient essentiel. Cette collaboration optimisée facilite le partage d'informations stratégiques, accélère l'intégration des correctifs en production et garantit une prise en compte continue des enjeux de sécurité à chaque étape du développement logiciel.
• Formation des employés. Des équipes bien formées aux pratiques de codage sécurisé peuvent significativement réduire les vulnérabilités introduites dans le code. La sensibilisation aux vulnérabilités courantes, ainsi que l'utilisation d'outils d'analyse automatisée, renforcent la sécurité à chaque étape du SDLC.
• Consolidation des outils. Remplacer une multitude d'outils disparates par une plateforme unifiée réduit les inefficacités causées par le changement de contexte et améliore la visibilité globale sur la sécurité au sein de l’entreprise.

Des défis toujours à relever

Les bonnes pratiques en matière de gestion des vulnérabilités reposent avant tout sur l'implication et la collaboration de toutes les équipes autour de ces questions. Les défis sont d'autant plus grands que certaines difficultés accompagnent la sécurisation des logiciels dans les environnements de développement modernes :

• La complexité croissante des dépendances logicielles complique l'identification des vulnérabilités et la prise de décision.
• Une approche continue peut être difficile à maintenir pendant les périodes de forte activité de développement.
• Les processus manuels d'analyse des vulnérabilités rendent le travail des équipes fastidieux et peu fiable.
• Le manque de collaboration entre les équipes de développement et de sécurité ralentit le processus de résolution des vulnérabilités.
• La détection tardive des failles de sécurité dans le cycle de développement engendre des coûts supplémentaires à l’entreprise.
• Les exigences réglementaires complexifient la gestion des vulnérabilités.

Pour relever ces défis, les entreprises doivent s'appuyer sur des outils modernes, une meilleure intégration de la sécurité dans les processus de développement et une collaboration efficace entre les équipes.

Comment améliorer votre gestion des vulnérabilités avec GitLab ?

GitLab adopte une approche DevSecOps intégrée qui permet aux équipes d'identifier et de corriger les vulnérabilités le plus tôt possible dans le cycle de développement logiciel.

Pour cela, la plateforme propose les fonctionnalités suivantes :

• Scanners de sécurité : ces scanners incluent les tests statiques de sécurité des applications (SAST) et les tests dynamiques de sécurité des applications (DAST), l’analyse des dépendances, l’analyse des conteneurs, la détection des secrets, l’analyse de l'Infrastructure as Code (IaC), ainsi que les tests à données aléatoires. Ils s'exécutent automatiquement dans les pipelines CI/CD, garantissant une couverture de sécurité exhaustive sans ralentir le développement.
• GitLab Duo : GitLab Duo assiste les équipes de développement tout au long de leur processus de développement logiciel. Cette suite de fonctionnalités alimentées par l’intelligence artificielle analyse les vulnérabilités détectées, fournit des explications contextuelles et propose des solutions de corrections adaptées, permettant une résolution plus rapide et plus efficace des problèmes de sécurité.
• Tableaux de bord et rapports : les tableaux de bord de sécurité et rapports de vulnérabilités offrent une vue d'ensemble en temps réel du niveau de sécurité des logiciels. Cette visibilité facilite le suivi des corrections, la priorisation des actions et la communication avec les parties prenantes.
• Processus d’approbation : la gestion des vulnérabilités commence aussi par une bonne gestion des droits de modifications. GitLab permet d’automatiser un processus d’approbation si des vulnérabilités sont détectées, garantissant une revue poussée des modifications introduisant des vulnérabilités potentielles.

Vous souhaitez renforcer la sécurité de vos logiciels ? Commencez un essai gratuit de GitLab Ultimate dès aujourd'hui !

Les cadres dirigeants reconnaissent que l'innovation logicielle améliorée par l'IA entraîne un changement économique significatif, servant de moteur de croissance et d’expansion des entreprises. Cependant, bien que l'adoption de l'IA génère un retour sur investissement mesurable et une productivité accrue, cette étude révèle également des tensions autour des lacunes en matière de compétences, de la collaboration homme-machine et du besoin de gouvernance formelle de l'IA agentique.

De plus, alors que les cadres dirigeants aspirent à atteindre une productivité optimale grâce à un partenariat 50/50 entre humain et IA, la réalité actuelle révèle que les humains gèrent les trois quarts des tâches, et que l'IA ne contribue uniquement qu'à hauteur d’un quart. Ce décalage s’accompagne de préoccupations persistantes concernant le déplacement d'emplois, la complexité perçue des systèmes d’intelligence artificielle et la cybersécurité.

Pour accéder à notre étude complète GitLab C-Suite Insights - France 2025 « L'innovation logicielle en France, plus de 12 milliards d'euros en jeu », cliquez ici.

Chiffres clés de notre étude

L'innovation logicielle alimentée par l'IA émerge comme nouveau moteur de croissance économique, générant des milliards de dollars de valeur

• Les dirigeants interrogés déclarent économiser en moyenne 22 308,38 € par développeur annuellement grâce aux investissements dans l’IA, ce qui représente plus de 12 milliards d’euros de valeur économique potentielle lorsqu'appliqué aux 553 000 développeurs que compte la France. 86 % déclarent que l'innovation logicielle est désormais une priorité commerciale essentielle. 61 % rapportent que leur entreprise a connu une croissance liée aux efforts d'innovation logicielle au cours des 12 derniers mois. Ils estiment une augmentation de 51 % du chiffre d’affaires et une augmentation de 54 % de la productivité des équipes de développement grâce à l'utilisation de l'IA.

L'IA agentique est en plein essor, mais les dirigeants estiment que la sécurité et la confiance doivent suivre le mouvement

• 88 % des cadres dirigeants s'attendent à ce que l'IA agentique devienne la norme pour le développement logiciel d’ici trois ans.
• En tête de liste des préoccupations concernant l'adoption de l'IA agentique figurent la confidentialité et la sécurité des données (50 %), les menaces liées à la cybersécurité (49 %), et les erreurs introduites par les agents d’IA (42 %).
• 49 % mettent en œuvre des frameworks de gouvernance alignés sur la réglementation.
• 52 % développent des politiques internes d'IA, tandis que 51 % mettent en place des programmes pilotes ou des formations.

Les pénuries de talents à l'ère de l'IA rendent indispensable la mise à niveau des compétences

• 98 % des cadres dirigeants affirment que les contributions humaines sont précieuses pour le développement logiciel.
• 92 % estiment que les entreprises devraient prioriser la formation des employés afin qu'ils puissent utiliser l'IA agentique et combler ainsi leurs lacunes en matière de compétences.
• 75 % pensent que la contribution humaine dans le partenariat entre humain et IA devrait être d'au moins 50/50, avec seulement 25 % estimant que l'IA devrait effectuer la majorité des tâches.
• La collaboration (42 %) et l’empathie (38 %) se classent comme les contributions humaines les plus précieuses au développement logiciel.

L'IA est une priorité pour les conseils d'administration, car l'innovation logicielle prouve son impact sur les résultats financiers

• 9 cadres dirigeants sur 10 déclarent que leur conseil d'administration adhère aux bénéfices de l'innovation logicielle.
• 86 % déclarent être prêts à investir plus de la moitié du budget informatique annuel de leur entreprise pour prioriser l'innovation logicielle.
• 87 % ont adopté des frameworks reliant les activités de développement logiciel aux résultats commerciaux clés.
• Les indicateurs les plus couramment utilisés aujourd'hui pour mesurer le succès de l'innovation logicielle sont une meilleure rentabilité (49 %), une expérience client améliorée (39 %) et une productivité accrue des équipes de développement (38 %).

Vous souhaitez en savoir plus ? Téléchargez notre étude complète GitLab C-Suite Insights - France 2025 « L'innovation logicielle en France, plus de 12 milliards d'euros en jeu ».

Dans la version GitLab 18.3, nous avons posé les bases d'une véritable collaboration entre humains et IA. Nous avons introduit des outils d'IA de premier plan tels que Claude Code, Codex CLI, Amazon Q CLI et Gemini CLI en tant qu'intégrations natives à GitLab, fourni notre premier aperçu du serveur GitLab Model Context Protocol (MCP) en partenariat avec Cursor et lancé deux nouveaux flows : « ticket à MR » et « conversion de fichier CI pour les Flows Jenkins » afin de proposer des solutions à des problèmes quotidiens rencontrés par les équipes.

Avec GitLab 18.4, nous renforçons la sécurité et la gouvernance relatives à votre utilisation de l'IA. Par ailleurs, nous étendons aussi votre capacité à créer et à partager des agents personnalisés, à collaborer plus efficacement grâce à Agentic Chat, à naviguer dans le code source avec le graphe de connaissances et à maintenir vos pipelines opérationnels avec le flow « correction de pipelines en échec ».

<div style="padding:56.25% 0 0 0;position:relative;"><iframe src="https://player.vimeo.com/video/1120293274?badge=0&autopause=0&player_id=0&app_id=58479" frameborder="0" allow="autoplay; fullscreen; picture-in-picture; clipboard-write; encrypted-media; web-share" referrerpolicy="strict-origin-when-cross-origin" style="position:absolute;top:0;left:0;width:100%;height:100%;" title="18.4 Release video placeholder"></iframe></div><script src="https://player.vimeo.com/api/player.js"></script>

Essayez GitLab Ultimate avec GitLab Duo Enterprise gratuitement.

Construisez votre expérience

Commencez votre journée en consultant GitLab Duo AI Catalog, une bibliothèque d'agents spécialisés qui mettent en avant les priorités, automatisent les tâches routinières et vous aident à rester concentré.

GitLab Duo AI Catalog : une bibliothèque d'agents spécialisés

Notre version GitLab 18.4 intègre GitLab Duo AI Catalog (actuellement en phase d'expérimentation), une bibliothèque centralisée où les équipes peuvent créer, partager et collaborer avec des agents personnalisés au sein de leur entreprise. Chaque équipe aime faire les choses à sa façon, c'est pourquoi il suffit de former des agents personnalisés pour que tout soit fait correctement.

Par exemple, un agent Planification de produit personnalisé peut signaler des bogues dans un format spécifique conformément à vos normes de labélisation, un agent Rédacteur technique peut rédiger une documentation concise en suivant vos conventions, ou un agent Securité peut s'assurer que chaque MR respecte vos normes de sécurité et de conformité. Au lieu de fonctionner comme des outils déconnectés, ces agents s'intègrent naturellement dans le workflow de GitLab et vous aident à terminer vos tâches plus rapidement sans perturber les processus établis.

Note : cette fonctionnalité n'est actuellement disponible que sur GitLab.com à titre expérimental. Nous prévoyons de la mettre à la disposition de nos clients GitLab Self-Managed le mois prochain dans la version 18.5.

Réduisez le changement de contexte

GitLab Duo Agentic Chat garantit une collaboration fluide avec les agents.

Agentic Chat : rationaliser la collaboration avec les agents (bêta)

Pièce maîtresse de GitLab Duo Agent Platform (bêta), Agentic Chat vous offre un moyen transparent de collaborer avec les agents d'IA. La dernière mise à jour d'Agentic Chat dans la version GitLab 18.4 améliore l'expérience de chat ainsi que l'affichage et la gestion des sessions.

• Chat avec agent personnalisé. Commençons par votre agent personnalisé que vous venez de créer. Vous pouvez immédiatement le mettre au travail via Agentic Chat. Par exemple, vous pourriez lui demander « donne-moi une liste de tâches » pour commencer à travailler sur les projets les plus urgents. De plus, vous avez maintenant la possibilité de démarrer de nouvelles conversations avec de nouveaux agents et de reprendre des conversations précédentes avec des agents sans perte de contexte.

• Sélection du modèle par l'utilisateur. Avec les versions précédentes, vous pouviez sélectionner des modèles au niveau d'un espace de nommage, mais dans GitLab 18.4, vous pouvez maintenant choisir des modèles au niveau de l'utilisateur à chaque session de chat. Cela vous permet d'opter pour le LLM qui convient le mieux à la tâche à accomplir ou de tester différents LLM pour voir lequel fournit la meilleure réponse concernant votre tâche.

• Formatage et design améliorés. Nous espérons que vous apprécierez le nouveau design de GitLab Duo Agentic Chat, qui comprend également une meilleure gestion des approbations d'appels d'outils pour améliorer votre expérience.

• Sessions d'agents disponibles via Agentic Chat. Les sessions font désormais partie intégrante de l'expérience Agentic Chat. Toute utilisation d’agents ou de flow apparaît maintenant dans l'aperçu des sessions dans Agentic Chat. Chaque session fournit des informations détaillées comme les job logs, les informations utilisateur et les métadonnées d'outils afin de garantir une transparence essentielle sur la façon dont les agents travaillent pour vous. Note : les sessions dans Agentic Chat sont disponibles uniquement sur GitLab.com. Nous prévoyons de les mettre à disposition de nos clients GitLab Self-Managed le mois prochain dans la version 18.5.

Exploitez pleinement votre code source

Avec les agents, le contexte est primordial. Le graphe de connaissances vous permet de donner à vos agents plus de contexte pour qu'ils puissent travailler plus rapidement et vous donner de meilleurs résultats.

Graphe de connaissances de GitLab (version bêta)

Le graphe de connaissances disponible dans la version 18.4 transforme la façon dont les équipes et les agents comprennent et naviguent dans les codes sources complexes. Il fournit une carte connectée de la totalité de votre projet et relie fichiers, routes et références tout au long du cycle de développement logiciel. Les outils tels que l'accès aux définitions, la recherche dans le code source et le suivi des références disponibles dans les requêtes de chat aident les équipes de développement à poser des questions précises comme « quels sont les autres éléments impactés par cette modification ? ».

Ce contexte approfondi aide les équipes à avancer plus rapidement et à se sentir plus en confiance, qu'il s'agisse d'intégrer de nouveaux contributeurs, d'effectuer des recherches approfondies sur un projet ou d'explorer l’impact d’une modification sur le code dépendant. Plus votre écosystème gravite dans GitLab, plus le graphe de connaissances devient puissant et donne aux équipes et aux agents d'IA les bases pour travailler avec précision, vitesse et plein accès aux informations du projet. Dans les futures versions, nous intégrerons toutes vos données GitLab dans le graphe de connaissances, y compris les plans, les merge requests, les vulnérabilités de sécurité et plus encore.

Cette version du graphe de connaissances se concentre sur l'indexation locale du code, où l'interface CLI gkg transforme votre code source en une base de données graphique dynamique et intégrable pour la génération augmentée par récupération (RAG). Vous pouvez l'installer à l’aide d’un simple script en une ligne, analyser des dépôts locaux et vous connecter via MCP pour interroger votre espace de travail.

Notre vision pour le graphe de connaissances est double : construire une édition communautaire dynamique que les équipes de développement peuvent exécuter localement dès aujourd'hui, qui servira de fondation pour un futur service de graphe de connaissances entièrement intégré au sein de GitLab.com et des instances auto-hébergées.

<div style="padding:56.25% 0 0 0;position:relative;"><iframe src="https://player.vimeo.com/video/1121017374?badge=0&autopause=0&player_id=0&app_id=58479" frameborder="0" allow="autoplay; fullscreen; picture-in-picture; clipboard-write; encrypted-media; web-share" referrerpolicy="strict-origin-when-cross-origin" style="position:absolute;top:0;left:0;width:100%;height:100%;" title="18.4 Knowledge Graph Demo"></iframe></div><script src="https://player.vimeo.com/api/player.js"></script>

Essayez GitLab Ultimate avec GitLab Duo Enterprise gratuitement.

Automatisez la maintenance de vos pipelines

Corrigez les échecs de pipeline plus rapidement et restez concentré avec le flow « correction de pipelines en échec ».

Corrigez des pipelines en échec en tenant compte du contexte métier

Le maintien des pipelines est essentiel pour votre vélocité de développement, mais les approches traditionnelles se concentrent uniquement sur le dépannage technique sans considérer l'impact métier. Le flow « correction de pipelines en échec » adresse ce problème en combinant l'analyse technique avec le contexte stratégique. Par exemple, il peut automatiquement prioriser la correction d'un pipeline de déploiement en échec pour un service client avant un job de test nocturne, ou signaler différemment les problèmes de compilation dans une branche de release hautement prioritaire par rapport aux branches de fonctionnalités expérimentales.

• La détection des échecs avec contexte métier surveille les exécutions de pipeline et comprend l'importance des différents workflows et cibles de déploiement.

• L'analyse des causes profondes en contexte analyse les journaux d'échec en parallèle des exigences métier, les modifications récentes et les dépendances entre projets pour identifier les causes sous-jacentes.

• La priorisation stratégique des correctifs génère des corrections appropriées tout en considérant l'impact métier, les échéances et les priorités d'allocation des ressources.

• La résolution intégrée au workflow crée automatiquement des merge requests avec des correctifs qui maintiennent des processus de revue appropriés et fournissent un contexte métier afin d'aider à prioriser les tâches.

Ce flow assure l'exécution des pipelines et l'alignement stratégique. Ses corrections automatisées prennent en compte les objectifs métier et ne servent pas uniquement à résoudre des problèmes techniques de manière isolée.

Personnalisez votre environnement IA

L'automatisation ne fonctionne que si vous faites confiance aux modèles qui l'alimentent. C'est pourquoi la version 18.4 offre des fonctionnalités de gouvernance comme la sélection de modèles et les clés gérées par GitLab.

Sélection de modèles GitLab Duo pour l'optimisation des performances

La sélection de modèles est maintenant proposée en disponibilité générale afin de contrôler directement les grands modèles de langage (LLM) qui alimentent GitLab Duo. Vous et votre équipe pouvez sélectionner les modèles de votre choix, les appliquer à l'ensemble de votre entreprise ou les adapter à chaque fonctionnalité. Vous pouvez définir des valeurs par défaut pour garantir la cohérence entre les espaces de nommage et les outils, dans le respect des exigences en matière de gouvernance, de conformité et de sécurité.

Pour les clients qui utilisent GitLab Duo Self-Hosted, la nouvelle prise en charge de GPT OSS et GPT‑5 offre une flexibilité supplémentaire pour les workflows de développement alimentés par l'IA.

Note : GitLab Duo Self-Hosted n'est pas disponible pour les clients GitLab.com, et les modèles GPT ne sont pas pris en charge sur GitLab.com.

Protégez vos données sensibles

La gouvernance s’accompagne d’une protection des données afin de contrôler précisément ce que l'IA peut et ne peut pas voir.

GitLab Duo Context Exclusion : une protection granulaire des données

Un contrôle granulaire sur les informations auxquelles les agents d'IA peuvent accéder est nécessaire. Dans la version 18.4, GitLab Duo Context Exclusion fournit des paramètres au niveau du projet qui permettent aux équipes d'interdire à l'IA d'accéder à des fichiers spécifiques ou des chemins d'accès de fichiers :

• Exclusions spécifiques à certains fichiers pour aider à protéger les fichiers sensibles tels que les configurations de mots de passe, les secrets et les algorithmes propriétaires.

• Règles basées sur les chemins d’accès pour créer des modèles d'exclusion en fonction des structures de répertoires ou des conventions de nommage de fichiers.

• Configuration flexible pour appliquer des exclusions au niveau du projet tout en maintenant l'efficacité du workflow de développement.

• Visibilité d'audit pour suivre le contenu exclu et garantir la conformité aux politiques de gouvernance des données.

GitLab Duo Context Exclusion vous aide à protéger vos données sensibles pendant que vous accélérez votre développement avec l'IA agentique.

Renforcez vos fonctionnalités d'IA avec de nouveaux outils MCP

Les outils MCP étendus font passer ces fonctionnalités à la vitesse supérieure en connectant votre environnement GitLab à un écosystème plus vaste d'agents intelligents.

Nouveaux outils pour le serveur GitLab MCP

Sur la base du serveur MCP initial introduit dans la version 18.3, GitLab 18.4 ajoute plus d'outils MCP afin de définir la manière dont les clients MCP interagissent avec GitLab. Ces nouveaux outils augmentent les possibilités d'intégration et permettent aux agents d'IA de première partie et tiers de s'attaquer à des tâches plus détaillées telles que l'accès aux données de projet, l'exécution d'opérations de code ou la recherche dans des dépôts, le tout dans le respect des modèles de sécurité et d'autorisations existants. Pour une liste complète des outils MCP, y compris les nouveautés de la version 18.4, consultez notre documentation dédiée au serveur MCP.

Découvrez l'avenir du développement logiciel intelligent

Avec GitLab Duo Agent Platform, les équipes n'ont plus à travailler sur un ticket à la fois dans un fil de discussion unique : la collaboration se déroule désormais dans plusieurs fils avec des agents asynchrones qui agissent comme des collègues pour accomplir des tâches plus rapidement. Nous donnons vie à cette vision unique en respectant les souhaits d'indépendance et de liberté de choix de nos clients : vous pouvez travailler dans vos environnements cloud préférés en utilisant les LLM et les outils d'IA qui vous conviennent le mieux, dans le respect des règles de sécurité et de conformité que vous avez définies.

En tant que partie intégrante de cette innovation, GitLab 18.4 est non seulement une mise à jour logicielle, mais aussi une version plus fluide, plus intelligente et plus sûre qui facilite le quotidien des équipes de développement. Des agents réutilisables aux corrections de pipeline adaptées aux enjeux métier, chaque fonctionnalité est conçue pour renforcer la concentration des équipes et assurer vitesse, sécurité et contrôle. Pour un aperçu plus approfondi de la façon dont ces fonctionnalités se combinent en pratique, consultez notre vidéo de démonstration.

<div style="padding:56.25% 0 0 0;position:relative;"><iframe src="https://player.vimeo.com/video/1120288083?badge=0&autopause=0&player_id=0&app_id=58479" frameborder="0" allow="autoplay; fullscreen; picture-in-picture; clipboard-write; encrypted-media; web-share" referrerpolicy="strict-origin-when-cross-origin" style="position:absolute;top:0;left:0;width:100%;height:100%;" title="A day in the life with GitLab Duo Agent Platform"></iframe></div><script src="https://player.vimeo.com/api/player.js"></script>

<p></p>

Les utilisateurs de GitLab Premium et GitLab Ultimate peuvent commencer à utiliser ces fonctionnalités dès aujourd'hui sur GitLab.com et GitLab Self-Managed, tandis que les clients GitLab Dedicated pourront y accéder le mois prochain.

Activez les fonctionnalités bêta et expérimentales dans GitLab Duo Agent Platform dès aujourd'hui et découvrez comment l'IA, avec un accès complet au contexte, peut transformer la façon dont vos équipes développent des logiciels. Nouveau sur GitLab ? Commencez votre essai gratuit et découvrez pourquoi l'avenir du développement est alimenté par l'IA, sécurisé et orchestré sur la plateforme DevSecOps la plus complète au monde.

Maintenez votre instance GitLab à jour

Pour vous assurer d'obtenir les dernières fonctionnalités, mises à jour de sécurité et améliorations de performances, nous vous recommandons de maintenir votre instance GitLab à jour. Les ressources suivantes peuvent vous aider à planifier et terminer votre mise à niveau :

• Outil de chemin d’accès de mise à niveau indiquez votre version actuelle pour consulter les étapes à suivre afin de mettre à niveau votre instance.

• Documentation de mise à niveau : guides détaillés pour chaque version prise en charge, y compris les exigences, les instructions étape par étape et les meilleures pratiques.

En effectuant régulièrement des mises à niveau, vous vous assurez que votre équipe bénéficie des dernières fonctionnalités de GitLab ainsi que d'une sécurité et d’une prise en charge optimales.

Pour les entreprises qui privilégient une approche autonome, pourquoi ne pas faire appel à GitLab Managed Maintenance ? Avec GitLab Managed Maintenance, votre équipe se concentre sur l'innovation tandis que les experts GitLab gèrent les mises à niveau de votre instance GitLab Self-Managed afin d'assurer la fiabilité, la sécurité et l'efficacité de vos processus DevSecOps. Contactez votre gestionnaire de compte pour obtenir plus d'informations.

Essayez GitLab Ultimate avec GitLab Duo Enterprise gratuitement.

Cet article de blog contient des énoncés de nature prospective au sens de la Section 27A de la Securities Act de 1933, telle que modifiée, et de la Section 21E de la Securities Exchange Act de 1934. Bien que nous croyions que les attentes reflétées dans les énoncés de nature prospective contenus dans cet article de blog sont raisonnables, ils sont soumis à des risques connus et inconnus, des incertitudes, des hypothèses et d'autres facteurs qui peuvent entraîner des résultats ou des conséquences sensiblement différents. De plus amples informations sur ces risques et autres facteurs sont incluses sous la rubrique « Facteurs de risque » dans nos documents déposés auprès de la SEC. Nous ne nous engageons pas à mettre à jour ou à réviser ces déclarations après la date de publication de cet article, sauf si la loi l'exige.

Téléchargez le rapport complet.

De l'IA à une collaboration intelligente

L'évaluation de Gartner s'est concentrée sur les capacités d'assistance pour le code par IA générative de GitLab Duo. Initialement conçu comme un module d'IA complémentaire à la plateforme DevSecOps de GitLab, GitLab Duo a posé les fondations de notre vision actuelle : une IA agentique intégrée nativement à la plateforme DevSecOps de GitLab.

GitLab Duo Agent Platform permet aux équipes de développement de collaborer avec plusieurs agents d'IA qui automatisent des tâches tout au long du cycle de développement logiciel. Ces agents interagissent entre eux et avec les équipes de développement à l'aide du graphe de connaissances de GitLab afin d'avoir une compréhension complète du contexte du projet. Les équipes gagnent ainsi en rapidité tout en conservant visibilité et contrôle sur leurs processus.

• Des agents spécialisés prennent en charge simultanément diverses tâches : génération de code, analyse de sécurité et recherche.
• Le graphe de connaissances connecte les agents à un système de référence unifié qui couvre le code, les tickets, les pipelines et les données de conformité.
• La collaboration entre humains et agents s'effectue par le biais d'un chat en langage naturel et de flows personnalisables, avec validation et supervision intégrées.
• L'interopérabilité avec les outils et les systèmes externes est assurée grâce au Model Context Protocol (MCP) et aux frameworks Agent2Agent (A2A).

Étant donné que les agents gèrent les tâches routinières sous supervision humaine, les équipes peuvent accélérer leur cadence, se concentrer sur les activités à forte valeur ajoutée et maintenir la sécurité et la conformité de leurs projets.

Conception sécurisée et pratique flexible

GitLab Duo Agent Platform place la sécurité et la conformité au premier plan. Les agents s'exécutent dans l'environnement DevSecOps sécurisé de GitLab, et chaque action peut être suivie et vérifiée avant application des modifications. Les intégrations sécurisées garantissent une gestion sûre des identifiants et données sensibles, tandis que l'interopérabilité via des standards ouverts connecte les agents aux outils externes sans exposer l'entreprise à des risques.

La plateforme donne aux équipes l'assurance que l'IA améliore leur productivité sans nuire à la gouvernance.

Voici comment chaque partie prenante en bénéficie :

• Les équipes de développement se concentrent sur les tâches complexes à fort impact et délèguent les tâches routinières aux agents pour des résultats plus rapides et un contexte plus précis directement dans leurs workflows existants.
• Les responsables en ingénierie gagnent en visibilité sur l'évolution des tâches tout au long du cycle de développement logiciel, car les agents opèrent dans un cadre clairement défini. Ils s'assurent que leurs équipes se concentrent sur les priorités et simplifient l'intégration des nouveaux arrivants à l'aide des agents, qui ont accès au contexte et aux workflows.
• Les entreprises informatiques conservent le contrôle sur l'activité des agents grâce aux fonctionnalités de gouvernance qui appliquent les politiques de codage et de sécurité, offrent une flexibilité dans le choix des modèles et assurent une interopérabilité sécurisée avec une supervision humaine de bout en bout.

À la pointe du développement avec l’IA native

GitLab poursuit le développement de GitLab Duo et ajoutera de nouveaux agents, des workflows avancés et des capacités d'orchestration étendues à GitLab Duo Agent Platform. Cet engagement en faveur de l'innovation renforce la productivité de vos équipes sur la plateforme que vous connaissez et en laquelle vous avez confiance. Suivez les mises à jour de notre roadmap et découvrez comment nous révolutionnons le DevSecOps avec l'IA native.

Téléchargez le rapport Magic Quadrant™ 2025 de Gartner® dédié aux assistants IA pour le code et essayez GitLab Duo Agent Platform dès aujourd'hui.

Source : Gartner, Magic Quadrant for AI Code Assistants, Philip Walsh, Haritha Khandabattu, Matt Brasier, Keith Holloway, Arun Batchu, 15 septembre 2025

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 marque 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.

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 une 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.

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 Gartner est disponible sur demande auprès de Gartner B.V.

Une étape importante dans notre collaboration

Cette collaboration associe la plateforme DevSecOps complète et intelligente de GitLab à l'expertise approfondie d'Accenture en matière de transformation numérique et de services de mise en œuvre, permettant aux organisations de créer et de livrer des logiciels sécurisés à grande échelle. Cet accord mondial fournit un cadre global qui peut être facilement adapté localement.

Cette collaboration se concentrera dans un premier temps sur plusieurs domaines clés :

• La transformation DevSecOps à l'échelle de l'entreprise : aider les organisations à moderniser leurs pratiques de développement et à rationaliser leur cycle de livraison de logiciels
• La modernisation des mainframes : accompagner les organisations à migrer depuis leurs systèmes hérités
• GitLab Duo combiné à Amazon Q : proposer le développement logiciel piloté par l'IA aux organisations qui cherchent à accélérer leur vitesse de développement tout en maintenant la sécurité et la conformité de bout en bout

Perspectives d'avenir

Nous sommes impatients d'aider nos clients communs à accélérer l'innovation, à rationaliser leurs processus de développement et à renforcer leur posture de sécurité afin d’atteindre plus efficacement leurs objectifs commerciaux.

Pour plus d'informations sur la façon dont GitLab et Accenture peuvent aider votre organisation, consultez notre site partenaire ou contactez votre représentant Accenture ou GitLab.

Pour aider nos clients à maximiser leurs investissements dans l'IA, nous avons développé la solution GitLab Duo Analytics dans le cadre de notre programme d'accélération GitLab Duo. GitLab Duo Analytics est une solution complète et orientée client qui transforme les données d'utilisation brutes en données métiers exploitables et mesure le ROI. Il s’agit d’un outil d'accompagnement spécialisé que nous avons créé pour répondre aux besoins d'analyse immédiats des entreprises, qui calculent de plus en plus la productivité de l'IA dans son ensemble.

Ces données de base aident à transformer l'IA en profondeur. Par exemple, les entreprises peuvent les utiliser pour optimiser l’attribution des licences, identifier les cas d’utilisation à forte valeur ajoutée et élaborer des business cases convaincants pour renforcer l'adoption de l'IA au sein des équipes de développement.

Une grande entreprise du secteur financier a collaboré avec l’un de nos Customer Success Architect dans le cadre du programme d'accélération GitLab Duo afin d’obtenir une visibilité sur son investissement GitLab Duo Enterprise. Ensemble, ils ont mis en œuvre une solution d'analyse hybride qui combine la collecte mensuelle de données avec une intégration API en temps réel, afin de créer une base évolutive pour mesurer les gains de productivité de l'IA et optimiser l'utilisation des licences à l'échelle de l'entreprise.

Mesurer le ROI de l'IA dans le développement d'entreprise

Avant de mettre en œuvre une solution d'analyse, il est essentiel de comprendre comment vous évaluez votre utilisation de l'IA.

Posez-vous les questions suivantes :

• Quelles fonctionnalités de GitLab Duo doivent être évaluées ? (Suggestions de code, assistance par chat, scanning de sécurité) ?
• Qui utilise l'IA au sein de votre entreprise ? (Développeurs, équipes de sécurité, ingénieurs DevOps) ?
• Quels indicateurs métiers sont importants pour votre entreprise ? (Gain de temps, gains de productivité, optimisation des coûts) ?
• Comment fonctionne votre collecte de données actuelle (Exports manuels, intégration API, outils existants) ?

Utilisez cette étape pour définir les éléments suivants :

• Votre framework de calcul du ROI
• Vos indicateurs clés de performance (KPI)
• Votre stratégie de collecte de données
• Vos exigences de reporting des parties prenantes

Exemple de framework de calcul du ROI

Guide de mise en œuvre étape par étape

Veuillez noter que la solution ci-dessous décrit une approche open source que vous pouvez déployer gratuitement dans votre propre environnement. Téléchargez, personnalisez et exécutez cette solution dès maintenant !

Prérequis

Avant de commencer, assurez-vous de disposer des éléments suivants :

• Instance GitLab avec GitLab Duo activé
• Token API GitLab avec autorisations de lecture
• Accès pour configurer les variables CI/CD de GitLab
• Connaissances de base des pipelines CI/CD de GitLab

1. Configurer et paramétrer l'environnement initial

Configurez l'environnement du projet en clonant d'abord le dépôt.

git clone https://gitlab.com/gitlab-org/professional-services-automation/tools/utilities/gitlab-graphql-api.git
cd gitlab-graphql-api

Effectuez un push vers votre propre instance GitLab ou votre espace de nommage, puis accédez à votre projet dans GitLab pour configurer les variables CI/CD.

2. Configurer les variables de contrôle du pipeline

Contrôlez quels pipelines d’analyse s'exécutent en définissant les variables CI/CD du projet. Allez dans Paramètres du projet → CI/CD → Variables et ajoutez :

Exemples de configurations :

• Configurer GitLab Duo uniquement : ENABLE_DUO_METRICS="true", ENABLE_PROJECT_METRICS="false"
• Configurer les deux tableaux de bord : ENABLE_DUO_METRICS="true", ENABLE_PROJECT_METRICS="true"
• Tout désactiver : ENABLE_DUO_METRICS="false", ENABLE_PROJECT_METRICS="false"

3. Configurer l’ingestion des données

Configurez l'ingestion des données dans votre fichier .gitlab-ci.yml. Cette action crée des métadonnées de projet brutes partagées entre les métriques.

Variables de configuration de base :

variables:
  GROUP_PATH: "gitlab-org/professional-services-automation"  # Your group path
  INCLUDE_SIMPLE_FIELDS: "fullPath,name,description"  # Fields to fetch
  ARGUMENT_FIELDS: "mergeRequests"  # Argument fields requiring additional config
  LIMIT: "100"  # Projects per API call
  MAX_ITERATIONS: "2"  # Maximum API calls (for testing)
  GITLAB_GRAPHQL_API_VERSION: "0.1.0"  # API version from Package Registry

Configurer les champs d'argument pour des métriques spécifiques :

Pour chaque métrique que vous souhaitez collecter, définissez des variables de champ d'argument :

# Example: Merged Merge Requests
ARGUMENT_FIELD_1_NAME: "mergeRequests"
ARGUMENT_FIELD_1_FILTER_NAME: "state"
ARGUMENT_FIELD_1_FILTER_VALUE: "merged"
ARGUMENT_FIELD_1_RETURN_VALUES: "count totalTimeToMerge"

# Example: Packages Count
ARGUMENT_FIELD_2_NAME: "packages"
ARGUMENT_FIELD_2_RETURN_VALUES: "count"

4. Configurer l'agrégation des métriques

Après l'ingestion des données, configurez les règles d'agrégation dans .gitlab/Schedule.gitlab-ci.yml pour chaque métrique que vous souhaitez générer.

Exemple de configuration de job de métrique :

process_average_time_to_merge:
  <<: *process_data_template
  stage: process_data
  variables:
    METRIC_NAME: "9_Average_Time_To_Merge"
    BUSINESS_LEVEL_START: 2
    BUSINESS_LEVEL_END: 4
    AGGREGATE_COLUMNS: "mergeRequests_state_merged_totalTimeToMerge:sum mergeRequests_state_merged_count:sum"
    NEW_COLUMN_NAME: "average_time_to_merge_days"
    NEW_COLUMN_FORMULA: "mergeRequests_state_merged_totalTimeToMerge / mergeRequests_state_merged_count / (24 * 60 * 60)"
    SORT_BY: "average_time_to_merge_days"
    FILTER_CONDITION: "mergeRequests_state_merged_count >= 5"

Variables requises pour chaque métrique :

5. Exécuter le pipeline planifié pour configurer l’analyse

Une fois configuré, exécutez un pipeline planifié pour générer votre analyse :

1. Allez dans CI/CD → Planifications
2. Créez une nouvelle planification ou exécutez-en une existante
3. Le pipeline va automatiquement :

• Ingérer les données selon votre configuration
• Agréger les métriques selon vos règles
• Déployer les tableaux de bord sur GitLab Pages

6. Accéder à vos tableaux de bord d’analyse

Après l'exécution réussie du pipeline planifié, GitLab Pages déploie automatiquement vos tableaux de bord :

• Tableau de bord des métriques de projet: https://your-username.gitlab.io/project-name/existing-metrics/
• Tableau de bord des métriques GitLab Duo: https://your-username.gitlab.io/project-name/duo-metrics/
• Page d'accueil principale: https://your-username.gitlab.io/project-name/

La page d'accueil principale détecte automatiquement quels tableaux de bord sont disponibles et affiche les liens appropriés.

Vous verrez les éléments suivants :

• Utilisation des licences : nombre total d’utilisateurs sous licence par rapport au nombre d’utilisateurs actifs (avec analyse des suggestions de code)

• Analyse de GitLab Duo Chat : utilisateurs uniques de GitLab Duo Chat, moyenne des événements du chat sur 90 jours et taux d'adoption du chat

• Analyse d'engagement de GitLab Duo : catégorisation de l'utilisation de GitLab Duo pour un groupe d'utilisateurs comme Fort (10+ suggestions), Moyen (5-9) ou Faible (1-4) selon les modèles d'utilisation

• Analyse de l'utilisation : suggestions de code par langage de programmation (répartition par langage), analyse des performances des langages de suggestions de code (taux d'acceptation et de rejet)

• Tendances hebdomadaires de GitLab Duo Chat : modèles d'utilisation de GitLab Duo Chat

Les fonctionnalités du tableau de bord incluent :

• L’analyse de l'utilisation des licences - Suivi des utilisateurs sous licence par rapport aux utilisateurs actifs
• Analyse des suggestions de code - Suivi des taux d'acceptation et de la répartition des langages
• Analyse de GitLab Duo Chat - Affichage des interactions par chat et des taux d'adoption
• Analyse de l’engagement des utilisateurs - Catégorisation des utilisateurs par niveau d'activité
• Analyse des performance par langage - Analyse des taux d'acceptation par langage de programmation

7. Comprendre les API utilisées

La solution exploite plusieurs API GitLab pour collecter des données d'utilisation complètes :

API pour collecter les données d'utilisation de l'IA (aiUsageData)

# Fetches individual code suggestion events
query: |
  {
    group(fullPath: "your-group") {
      aiUsageData {
        codeSuggestionEvents {
          event         # ACCEPTED or SHOWN
          timestamp     # When it happened
          language      # Programming language
          suggestionSize # SINGLE_LINE or MULTI_LINE
          user { username }
        }
      }
    }
  }
# Purpose: Tracks every code suggestion shown or accepted by developers

API pour collecter les utilisateurs du module d'extension GitLab Self-Managed

# Gets licensed user information
query: |
  {
    selfManagedAddOnEligibleUsers(
      addOnType: DUO_ENTERPRISE
      filterByAssignedSeat: "Yes"
    ) {
      user {
        username
        lastDuoActivityOn
      }
    }
  }
# Purpose: Identifies who has licenses and when they last used Duo

API pour collecter les métriques d'IA

query: |
  {
    aiMetrics(from: "2024-01-01", to: "2024-06-30") {
      codeSuggestions {
        shownCount
        acceptedCount
      }
      duoChatContributorsCount
      duoAssignedUsersCount
    }
  }
# Purpose: Gets pre-calculated metrics for trend analysis

API pour collecter le Ping de Service (REST)

url: "{GITLAB_URL}/api/v4/usage_data/service_ping" 
# Purpose: Collects instance-wide usage statistics 

Mise en pratique complète

Pour démontrer la puissance de cette solution d'analyse intégrée, parcourons ensemble toutes les étapes d'une implémentation complète, du déploiement initial au calcul automatisé du ROI.

Commencez par déployer la solution conteneurisée dans votre environnement avec la configuration Docker fournie. En quelques minutes, l'API d'analyse et le tableau de bord React seront opérationnels localement.

L'architecture de données hybride commence immédiatement à collecter des métriques à partir de vos exports CSV mensuels existants et établit des connexions GraphQL en temps réel vers votre instance GitLab.

Automatisation via les scripts Python

Cette approche déploie toute sa puissance lorsque vous exploitez les scripts Python pour automatiser l'ensemble du workflow de collecte et de traitement des données. La solution comprend des scripts Python complets qui peuvent être facilement personnalisés et planifiés.

Intégration GitLab CI/CD

Pour une automatisation à l'échelle de l'entreprise, intégrez ces scripts Python dans des pipelines CI/CD planifiés. Cette approche exploite votre infrastructure GitLab existante et garantit une collecte de données cohérente et fiable :

# .gitlab-ci.yml example

duo_analytics_collection:
  stage: analytics
  script:
    - python scripts/enhanced_duo_data_collection.py
    - python scripts/metric_aggregations.py
    - ./deploy_dashboard_updates.sh
  schedule:
    - cron: "0 2 1 * *"  # Monthly on 1st at 2 AM
  only:
    - schedules

Cette stratégie d'automatisation transforme la collecte manuelle de données en un moteur d'analyse autonome. Vos scripts Python s'exécutent mensuellement via les pipelines CI/CD de GitLab, collectent automatiquement les données d'utilisation, calculent les métriques de ROI et mettent à jour les tableaux de bord, le tout sans intervention manuelle.

Une fois automatisée, la solution fonctionne de manière fluide : les pipelines planifiés exécutent les scripts de collecte de données Python, traitent les réponses GraphQL en indicateurs commerciaux et mettent à jour les données du tableau de bord. Vous découvrirez ainsi de véritables modèles d'utilisation dans le tableau de bord comme les volumes de suggestions de code par langage de programmation, les tendances d'adoption des utilisateurs entre les équipes et le taux d'utilisation des licences.

Dans le tableau de bord, la vue d'ensemble du ROI est ici le véritable atout. Vous y trouverez des métriques d'engagement concrètes qui peuvent être converties en impact commercial pour votre entreprise : vous découvrirez peut-être que vos utilisateurs actifs de GitLab Duo génèrent un ROI mensuel de 127 % grâce à des gains de temps et de productivité, tandis que 23 % de vos licences restent sous-utilisées.

Ces informations se traduisent immédiatement en recommandations concrètes : vous pouvez ainsi fournir des licences aux équipes les plus performantes, mettre en place une formation ciblée pour les utilisateurs avec des licences sous-utilisées et élaborer des arguments commerciaux basés sur les données pour une adoption plus large de l'IA.

Pourquoi choisir GitLab ?

La plateforme DevSecOps complète de GitLab fournit la base idéale pour l'analyse et l'évaluation de l'IA en entreprise. Avec des API GraphQL natives, un accès flexible aux données et des capacités d’IA intégrées via GitLab Duo, les entreprises peuvent centraliser l'évaluation de l'IA tout au long du cycle de développement logiciel sans perturber les workflows existants.

L'architecture ouverte de la solution permet des solutions d'analyse personnalisées comme celle développée dans le cadre de notre programme d'accélération GitLab Duo. L'engagement de GitLab en faveur d’une conception API-first signifie que vous pouvez extraire des données d'utilisation détaillées, intégrer avec les systèmes d'entreprise existants et élaborer des calculs de ROI sophistiqués qui s'alignent sur des métriques spécifiques et les exigences de création de rapports de votre organisation.

Au-delà des capacités techniques, notre approche garantit que vous ne faites pas que mettre en œuvre des outils, vous élaborez également des stratégies d'adoption de l'IA durables. Cette solution conçue spécialement dans le cadre du programme d'accélération GitLab Duo illustre parfaitement cette approche avec des conseils pratiques, des frameworks éprouvés et des solutions personnalisées qui répondent à de véritables défis comme le calcul du ROI et l'optimisation des licences.

À mesure que GitLab continue d'améliorer ses capacités d'analyse avec l'IA native, cette approche n'en est que plus précieuse. Les frameworks de calcul, les indicateurs clés de performance et les processus de collecte de données établis via des solutions d'analyse personnalisées s'intègrent de manière transparente aux fonctionnalités natives améliorées et garantissent que votre investissement dans l'évaluation de l'IA évolue au même rythme que GitLab.

Essayez GitLab Duo dès aujourd'hui

Le calcul du ROI de l'IA n'est qu’un début. Avec les fonctionnalités de GitLab Duo, vous pouvez obtenir une analyse complète qui suit non seulement l'utilisation de l'IA, mais sert aussi de base pour une optimisation basée sur les données. Cette base peut ensuite évoluer avec la croissance de votre entreprise et avec les capacités d'IA en pleine expansion de GitLab.

La solution d'analyse développée dans le cadre du programme d'accélération de GitLab Duo démontre comment les partenariats axés sur la réussite client peuvent apporter une valeur immédiate et des avantages stratégiques à long terme. Du déploiement initial au calcul du ROI à l'échelle de l'entreprise, cette solution offre la visibilité et les données nécessaires pour maximiser les investissements dans l’IA et favoriser son adoption durable.

La combinaison de l'automatisation Python, de l'intégration GitLab CI/CD et de l'analyse sur mesure crée un avantage concurrentiel qui s'étend bien au-delà de la productivité individuelle des équipes de développement. Elle permet une prise de décision stratégique, optimise l'allocation des ressources et fournit des arguments commerciaux convaincants pour un investissement et une expansion continus de l'IA.

L'avenir du développement alimenté par l'IA est basé sur les données, et commence par une évaluation approfondie. Que vous commenciez votre parcours dans l’IA ou que vous optimisiez des investissements existants, GitLab fournit à la fois la plateforme et la base du partenariat nécessaires pour réussir.

Lancez-vous dès aujourd'hui avec GitLab Duo et profitez d'un essai gratuit de GitLab Ultimate avec GitLab Duo Enterprise.

Pour répondre à ces questions, nous avons créé le framework de sécurité relatif à l'IA de GitLab afin de montrer aux responsables de la sécurité comment GitLab et ses clients peuvent garantir un développement sécurisé alimenté par l'IA avec GitLab Duo.

La genèse des défis de sécurité liés à l'IA

Les responsables sécurité de divers secteurs mentionnent tous le même schéma : leurs organisations adoptent rapidement les technologies d'IA pour améliorer la livraison logicielle, alors que leurs équipes sécurité peinent à établir des contrôles adéquats.

Cette problématique n'est pas simplement une question de ressources ou d'expertise, elle représente un changement fondamental dans la façon dont les organisations doivent aborder la sécurité à l'ère de l'IA. Les responsables sécurité assistent à une adoption rapide et sans précédent de l'IA dans leurs organisations, des équipes de développement aux départements marketing.

Les organisations intègrent l'IA dans leurs propres logiciels, et nombre de leurs applications SaaS actuelles ont également des fonctionnalités d'IA. Bien que cette adoption favorise l'innovation et l'efficacité, elle crée également un ensemble complexe de problématiques de sécurité que les frameworks traditionnels n'étaient pas conçus pour traiter.

Voici quelques-uns des défis spécifiques que nous avons identifiés.

Les défis de sécurité à l'ère de l'IA

1. Incertitudes concernant la responsabilité et le contrôle

En raison du rythme rapide d'adoption de l'IA, de nombreuses organisations se retrouvent sans stratégie cohérente de gouvernance de sécurité. Les équipes de sécurité doivent alors essayer d'adapter les frameworks de sécurité existants pour répondre aux préoccupations spécifiques à l'IA. Quant aux responsables sécurité, ils tentent de comprendre où commencent et s’arrêtent leurs responsabilités en matière de sécurité liée à l'IA. La traditionnelle relation fournisseur-client se complexifie avec les systèmes d'IA, car les flux de données, l'entraînement des modèles et les processus d'inférence créent de nouveaux types d'interactions et de dépendances.

2. Évolution de l'évaluation des risques

Les modèles de risques de sécurité traditionnels peinent à capturer les caractéristiques uniques des systèmes d'IA. Les responsables sécurité constatent que les frameworks standards d'évaluation des risques ne traitent pas correctement les risques de sécurité spécifiques à l'IA, qui diffèrent selon l'implémentation et le contexte d'utilisation. Plus difficile encore, les organisations doivent évaluer les fournisseurs d'IA alors que leurs équipes de sécurité ne disposent pas forcément d'une expertise technique approfondie sur ce sujet.

3. Complexification de la protection des données

Les systèmes d'IA présentent des défis uniques en matière de protection des données. La façon dont ces systèmes traitent, apprennent et génèrent des données crée de nouveaux problèmes de confidentialité et de sécurité que les organisations doivent évaluer soigneusement. Les RSSI sont tenus de s'assurer que leurs frameworks de gouvernance des données évoluent afin de pouvoir s'adapter à la façon dont les systèmes d'IA utilisent et protègent les informations sensibles. Implémenter l'IA sans mesures de protection adéquates pourrait révéler par inadvertance des informations confidentielles dans les résultats générés par l'IA.

4. Conformité et normes

Le paysage réglementaire relatif à la sécurité de l'IA évolue rapidement : de nouvelles normes, notamment la norme ISO 42001, sont mises en place en parallèle des frameworks existants. Les responsables sécurité doivent apprendre à gérer cet environnement complexe et s'assurer que leurs implémentations d'IA restent conformes aux réglementations actuelles et futures. Ils doivent trouver un équilibre entre adoption de l'IA et contrôles de sécurité robustes qui répondent aux exigences réglementaires.

Comment relever ces défis ?

Pour répondre aux préoccupations des RSSI, nous avons développé un framework complet pour aider les organisations à gérer la sécurité de l'IA dans le contexte de notre plateforme DevSecOps alimentée par l'IA. Notre framework de sécurité relatif à l'IA détaille notre implémentation axée sur la confidentialité de l'IA dans GitLab Duo et les procédures de validation de sécurité de nos fournisseurs d'IA. Il comprend également une matrice de responsabilités pour aider les responsables sécurité à gérer leurs tâches liées à la sécurité de l'IA et à innover dans un environnement sécurisé. Nous avons également compilé une sélection de risques de sécurité spécifiques à l'IA à garder à l'esprit et mis en évidence la façon dont les fonctionnalités de GitLab comme les garde-fous relatifs aux prompts peuvent aider à les atténuer.

Vous souhaitez en savoir plus sur nos contrôles de sécurité ? Consultez notre framework de sécurité relatif à l'IA.

En savoir plus

• Centre pour la transparence de l'IA de GitLab
• Améliorer la sécurité de l'IA dans GitLab avec des identités composites
• Sécurité, conformité et IA : découvrez 3 nouvelles fonctionnalités GitLab
• Informations clés sur l'IA et sécurité de notre communauté de développeurs