Pourquoi choisir GKE pour déployer vos agents d'IA ?

GKE offre une orchestration d'entreprise qui s'intègre parfaitement aux pipelines CI/CD de GitLab grâce à l'authentification OpenID Connect (OIDC). Votre équipe de développement peut déployer des agents d'IA tout en conservant une visibilité, une conformité et un contrôle complets sur votre infrastructure cloud. Ce guide utilise l'Agent Development Kit (ADK) de Google afin de créer l'application, ce qui garantit une intégration fluide lors du déploiement avec GitLab.

Voici trois avantages clés de cette approche :

Contrôle total de l'infrastructure : vos données, vos règles, votre environnement. Vous conservez un contrôle complet sur l'emplacement d'exécution de vos agents d'IA et de leur configuration.

Intégration native avec GitLab : pas de solution de contournement complexe. Vos pipelines existants fonctionnent immédiatement grâce à l'intégration native de GitLab avec Google Cloud.

Mise à l'échelle de niveau production : GKE gère automatiquement la mise à l'échelle et l'orchestration interne à mesure que vos charges de travail d'IA augmentent.

Avec GKE, GitLab offre la fiabilité d'entreprise dont vos déploiements d'IA ont besoin sans sacrifier l'expérience développeur que vos équipes attendent.

Prérequis

Avant de commencer, assurez-vous d'avoir activé ces API :

• API GKE
• API Artifact Registry
• API Vertex AI

Assurez-vous également de disposer des éléments suivant :

• Un projet GitLab créé
• Un cluster GKE provisionné
• Un dépôt Artifact Registry créé

Le processus de déploiement

1. Configurer IAM et les autorisations sur GitLab

Accédez à vos intégrations GitLab afin de configurer l'authentification Google Cloud (IAM).

Accédez à Paramètres > Intégrations et configurez l'intégration Google Cloud. Si vous utilisez une intégration au niveau du groupe, notez que les paramètres par défaut sont déjà hérités par les projets. Il vous suffit donc de configurer vos paramètres une fois au niveau du groupe pour que tous les projets en bénéficient et les héritent.

Pour configurer les paramètres, vous devez fournir les éléments suivants :

• ID du projet
• Numéro du projet
• ID du pool d'identités de charge de travail
• ID du fournisseur

Une fois ces informations renseignées, GitLab fournit un script à exécuter dans Google Cloud Console via Cloud Shell. Le résultat de l'exécution de ce script est un pool de fédération d'identité de charge de travail avec l'identité de service de compte principal nécessaire pour permettre l'accès approprié.

2. Configurer l'intégration à Artifact Registry

Toujours dans les paramètres d'intégration de GitLab, configurez la gestion des artefacts :

1. Cliquez sur Gestion des artefacts.
2. Sélectionnez Google Artifact Registry.
3. Indiquez les éléments suivants :
   • ID du projet
   • Nom du dépôt (créé au préalable)
   • Emplacement du dépôt

GitLab fournit un autre script à exécuter dans Google Cloud Console.

Important : avant de continuer, ajoutez ces rôles supplémentaires au pool de fédération d'identité de charge de travail :

• Utilisateur de compte de service
• Développeur Kubernetes
• Observateur de cluster Kubernetes

Ces autorisations permettent à GitLab de déployer vers GKE dans les étapes suivantes.

3. Créer le pipeline CI/CD

Voici maintenant la partie essentielle : la création du pipeline CI/CD pour le déploiement.

Accédez à Compilation > Éditeur de pipeline et définissez votre pipeline en quatre étapes :

• Build : Docker crée l'image de conteneur.
• Test : GitLab Auto DevOps fournit des scans de sécurité intégrés afin de garantir l'absence de vulnérabilités.
• Importation : utilise le composant CI/CD intégré de GitLab pour effectuer un push vers Google Artifact Registry.
• Déploiement : utilise la configuration Kubernetes pour déployer vers GKE.

Voici le fichier .gitlab-ci.yml complet :

default:
  tags: [ saas-linux-2xlarge-amd64 ]

stages:
  - build
  - test
  - upload
  - deploy

variables:
  GITLAB_IMAGE: $CI_REGISTRY_IMAGE/main:$CI_COMMIT_SHORT_SHA
  AR_IMAGE: $GOOGLE_ARTIFACT_REGISTRY_REPOSITORY_LOCATION-docker.pkg.dev/$GOOGLE_ARTIFACT_REGISTRY_PROJECT_ID/$GOOGLE_ARTIFACT_REGISTRY_REPOSITORY_NAME/main:$CI_COMMIT_SHORT_SHA
  GCP_PROJECT_ID: "your-project-id"
  GKE_CLUSTER: "your-cluster"
  GKE_REGION: "us-central1"
  KSA_NAME: "ai-agent-ksa"

build:
  image: docker:24.0.5
  stage: build
  services:
    - docker:24.0.5-dind
  before_script:
    - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY
  script:
    - docker build -t $GITLAB_IMAGE .
    - docker push $GITLAB_IMAGE

include:
  - template: Jobs/Dependency-Scanning.gitlab-ci.yml
  - template: Jobs/Container-Scanning.gitlab-ci.yml
  - template: Jobs/Secret-Detection.gitlab-ci.yml
  - component: gitlab.com/google-gitlab-components/artifact-registry/upload-artifact-registry@main
    inputs:
      stage: upload
      source: $GITLAB_IMAGE
      target: $AR_IMAGE

deploy:
  stage: deploy
  image: google/cloud-sdk:slim
  identity: google_cloud
  before_script:
    - apt-get update && apt-get install -y kubectl google-cloud-sdk-gke-gcloud-auth-plugin
    - gcloud container clusters get-credentials $GKE_CLUSTER --region $GKE_REGION --project $GCP_PROJECT_ID
  script:
    - |
      kubectl apply -f - <<EOF
      apiVersion: apps/v1
      kind: Deployment
      metadata:
        name: ai-agent
        namespace: default
      spec:
        replicas: 2
        selector:
          matchLabels:
            app: ai-agent
        template:
          metadata:
            labels:
              app: ai-agent
          spec:
            serviceAccountName: $KSA_NAME
            containers:
            - name: ai-agent
              image: $AR_IMAGE
              ports:
              - containerPort: 8080
              resources:
                requests: {cpu: 500m, memory: 1Gi}
                limits: {cpu: 2000m, memory: 4Gi}
              livenessProbe:
                httpGet: {path: /health, port: 8080}
                initialDelaySeconds: 60
              readinessProbe:
                httpGet: {path: /health, port: 8080}
                initialDelaySeconds: 30
      ---
      apiVersion: v1
      kind: Service
      metadata:
        name: ai-agent-service
        namespace: default
      spec:
        type: LoadBalancer
        ports:
        - port: 80
          targetPort: 8080
        selector:
          app: ai-agent
      ---
      apiVersion: autoscaling/v2
      kind: HorizontalPodAutoscaler
      metadata:
        name: ai-agent-hpa
        namespace: default
      spec:
        scaleTargetRef:
          apiVersion: apps/v1
          kind: Deployment
          name: ai-agent
        minReplicas: 2
        maxReplicas: 10
        metrics:
        - type: Resource
          resource:
            name: cpu
            target: {type: Utilization, averageUtilization: 70}
      EOF
      
      kubectl rollout status deployment/ai-agent -n default --timeout=5m
      EXTERNAL_IP=$(kubectl get service ai-agent-service -n default -o jsonpath='{.status.loadBalancer.ingress[0].ip}')
      echo "Deployed at: http://$EXTERNAL_IP"
  only:
    - main

Configuration essentielle pour GKE

Pour que tout fonctionne, et c'est la raison pour laquelle nous avons besoin de cette configuration supplémentaire pour GKE, nous devons disposer d'un compte de service Kubernetes dans le cluster qui peut fonctionner avec Vertex AI. Ce compte de service doit être autorisé à accéder aux capacités d'IA de Google Cloud.

Sans cela, nous pouvons déployer l'application, mais l'agent d'IA ne fonctionnera pas. Nous devons créer un compte de service Kubernetes capable d'accéder à Vertex AI.

Exécutez cette configuration ponctuelle :

#!/bin/bash



PROJECT_ID="your-project-id"



GSA_NAME="ai-agent-vertex"



GSA_EMAIL="${GSA_NAME}@${PROJECT_ID}.iam.gserviceaccount.com"



KSA_NAME="ai-agent-ksa"



CLUSTER_NAME="your-cluster"



REGION="us-central1"




# Create GCP Service Account



gcloud iam service-accounts create $GSA_NAME \
    --display-name="AI Agent Vertex AI" \
    --project=$PROJECT_ID

# Grant Vertex AI permissions



gcloud projects add-iam-policy-binding $PROJECT_ID \
    --member="serviceAccount:${GSA_EMAIL}" \
    --role="roles/aiplatform.user"

# Get cluster credentials



gcloud container clusters get-credentials $CLUSTER_NAME \
    --region $REGION --project $PROJECT_ID

# Create Kubernetes Service Account



kubectl create serviceaccount $KSA_NAME -n default




# Link accounts



kubectl annotate serviceaccount $KSA_NAME -n default \
    iam.gke.io/gcp-service-account=${GSA_EMAIL}

gcloud iam service-accounts add-iam-policy-binding ${GSA_EMAIL} \
    --role=roles/iam.workloadIdentityUser \
    --member="serviceAccount:${PROJECT_ID}.svc.id.goog[default/${KSA_NAME}]" \
    --project=$PROJECT_ID

4. Déployer vers GKE

Une fois que vous avez terminé, effectuez un push vers le pipeline et le tour est joué.

Le pipeline vient d'être déployé. Accédez à CI/CD > Pipelines pour voir les quatre étapes :

• Build
• Test (avec tous les scans de sécurité définis)
• Importation vers Artifact Registry (réussie)
• Déploiement vers Kubernetes dans GKE (réussi)

Résumé

Avec GitLab et Google Cloud, vous êtes en mesure de déployer votre agent d'IA vers GKE en toute simplicité et sécurité en quelques étapes seulement grâce à l'intégration native de GitLab avec Google Cloud.

Regardez cette démo :

Utilisez l'exemple de code complet de ce tutoriel pour commencer dès maintenant. Vous n’utilisez pas encore GitLab ? Découvrez la plateforme DevSecOps et profitez d'un essai gratuit. Les startups hébergées sur Google Cloud disposent d'une offre spéciale pour essayer et utiliser GitLab.

Prise en charge du rempaquetage géométrique avec les dépôts distants promisor

Les objets qui viennent d'être créés dans un dépôt Git sont souvent stockés sous forme de fichiers libres individuels. Pour garantir de bonnes performances et une utilisation optimale de l'espace disque, ces objets libres sont régulièrement compressés dans ce qu'on appelle des fichiers d'empaquetage (« packfiles »). Le nombre de fichiers d'empaquetage dans un dépôt augmente au fil du temps en raison des tâches effectuées, comme la création de nouveaux commits ou la récupération depuis un dépôt distant. À mesure que le nombre de fichiers d'empaquetage augmente dans un dépôt, Git doit effectuer davantage de travail pour rechercher des objets individuels. Par conséquent, pour préserver les performances optimales du dépôt, les fichiers d'empaquetage sont périodiquement rempaquetés via git-repack(1) afin de consolider les objets dans un nombre réduit de fichiers d'empaquetage. Lors du rempaquetage, deux stratégies existent : « tout-en-un » et « géométrique ».

La stratégie tout-en-un est assez simple et constitue la stratégie par défaut actuelle. Comme son nom l'indique, tous les objets du dépôt sont empaquetés dans un seul fichier. Cette approche est idéale pour le dépôt d'un point de vue des performances, car Git n'a besoin de parcourir qu'un seul fichier d'empaquetage lors de la recherche d'objets. Le principal inconvénient ? Le calcul d'un fichier d'empaquetage unique pour un dépôt peut prendre beaucoup de temps en cas de dépôt volumineux.

La stratégie géométrique permet d'atténuer ce problème en maintenant une progression géométrique des fichiers d'empaquetage en fonction de leur taille, au lieu de toujours rempaqueter dans un seul fichier. Lors du rempaquetage, Git maintient un ensemble de fichiers d'empaquetage classés par taille, où chaque fichier de la séquence doit avoir au moins deux fois la taille du fichier d'empaquetage précédent. Si un fichier d'empaquetage de la séquence enfreint cette propriété, les fichiers d'empaquetage sont combinés selon les besoins jusqu'à ce que la progression soit rétablie. Cette stratégie permet de limiter le nombre de fichiers d'empaquetage dans un dépôt tout en minimisant également la quantité de travail à effectuer pour la plupart des opérations de rempaquetage.

Toutefois, la stratégie de rempaquetage géométrique n'était pas compatible avec les clones partiels. Ces derniers permettent de cloner uniquement certaines parties d'un dépôt (par exemple en ignorant tous les blobs de plus de 1 mégaoctet). Cette approche peut réduire considérablement la taille d'un dépôt, et Git sait comment récupérer les objets manquants auxquels il doit accéder ultérieurement.

Résultat : nous obtenons un dépôt dans lequel il manque certains objets. Tout objet qui pourrait ne pas être entièrement connecté est stocké dans un fichier d'empaquetage « promisor ». Lors du rempaquetage, cette propriété promisor doit être conservée pour les fichiers d'empaquetage contenant un objet promisor, afin qu'il soit possible de déterminer si un objet manquant est attendu et peut être récupéré depuis le dépôt distant promisor. Avec une stratégie de rempaquetage tout-en-un, Git sait gérer correctement les objets promisor et les stocke dans un fichier d'empaquetage promisor distinct. Malheureusement, la stratégie de rempaquetage géométrique ne savait pas comment accorder un traitement spécial aux fichiers d'empaquetage promisor et les fusionnait avec des fichiers d'empaquetage normaux sans tenir compte de la présence d'objets promisor. Heureusement, en raison d'un bogue, la commande git-pack-objects(1) sous-jacente échoue lors de l'utilisation du rempaquetage géométrique dans un dépôt de clone partiel. Les dépôts dans cette configuration ne pouvaient donc de toute façon pas être rempaquetés. Ce n'est pas idéal, mais c'est un résultat préférable à une corruption du dépôt.

Avec la sortie de Git 2.53, le rempaquetage géométrique fonctionne désormais avec les dépôts de clones partiels. Lors d'un rempaquetage géométrique, les fichiers d'empaquetage promisor sont gérés séparément afin de préserver le marqueur promisor et sont rempaquetés selon une progression géométrique distincte. Avec ce correctif, la stratégie géométrique suit une progression logique en vue de s'imposer comme la stratégie de rempaquetage par défaut. Pour plus d'informations, consultez le fil de discussion de la liste de diffusion correspondant.

Ce projet a été mené par Patrick Steinhardt.

git-fast-import(1) : préservation des signatures valides uniquement

Dans notre article de blog consacré à la version Git 2.52, nous avons abordé les améliorations liées aux signatures apportées à git-fast-import(1) et git-fast-export(1). Consultez cet article pour une explication plus détaillée de ces commandes, de leur utilisation et des modifications apportées concernant les signatures.

Pour résumer brièvement, git-fast-import(1) fournit un backend qui permet d'importer efficacement des données dans un dépôt et qui est utilisé par des outils tels que git-filter-repo(1) pour aider à réécrire l'historique d'un dépôt en masse. Dans la version Git 2.52, git-fast-import(1) a appris l'option --signed-commits=<mode>, qui est similaire à la même option dans git-fast-export(1). Avec cette option, il est devenu possible de conserver ou de supprimer de façon inconditionnelle les signatures des commits et des tags.

Dans les situations où seule une partie de l'historique du dépôt a été réécrite, toute signature pour les commits ou tags réécrits devient invalide. Cela signifie que git-fast-import(1) est limité : la commande peut soit supprimer toutes les signatures, soit les conserver même si elles sont devenues invalides. Mais conserver des signatures invalides n'est pas vraiment utile, c'est pourquoi la réécriture de l'historique avec git-repo-filter(1) entraîne la suppression de toutes les signatures, même si le commit ou tag sous-jacent n'est pas réécrit. Cette approche n'est pas idéale : si le commit ou tag ne change pas, sa signature est toujours valide et il n'y a donc aucune raison réelle de la supprimer. Nous avons en réalité besoin de préserver les signatures pour les objets inchangés, et de supprimer les signatures invalides.

Avec la sortie de Git 2.53, l'option --signed-commits=<mode> de git-fast-import(1) a appris un nouveau mode strip-if-invalid qui, lorsqu'il est utilisé, supprime seulement les signatures devenues invalides des commits réécrits. Ainsi, avec cette option, il devient possible de préserver certaines signatures de commits lors de l'utilisation de git-fast-import(1). Il s'agit d'une étape critique vers la mise en place des bases qui permettent à des outils comme git-repo-filter(1) de préserver les signatures valides et, plus tard, de signer à nouveau les signatures invalides.

Ce projet a été mené par Christian Couder.

Plus de données collectées dans git-repo-structure

Dans la version Git 2.52, la sous-commande « structure » a été introduite dans git-repo(1). L'objectif de cette commande était de collecter des informations sur le dépôt et de remplacer éventuellement nativement des outils tels que git-sizer(1). Chez GitLab, nous hébergeons des dépôts extrêmement volumineux, et disposer d'informations sur la structure générale d'un dépôt est essentiel pour comprendre ses performances. Dans cette version, la commande collecte désormais également des informations sur la taille totale des objets accessibles dans un dépôt afin d'aider à comprendre la taille globale du dépôt. Dans les données de sortie ci-dessous, vous pouvez voir que la commande collecte désormais à la fois les tailles totales décompressées et sur disque des objets accessibles par type.

$ git repo structure

| Repository structure | Value      |
| -------------------- | ---------- |
| * References         |            |
|   * Count            |   1.78 k   |
|     * Branches       |      5     |
|     * Tags           |   1.03 k   |
|     * Remotes        |    749     |
|     * Others         |      0     |
|                      |            |
| * Reachable objects  |            |
|   * Count            | 421.37 k   |
|     * Commits        |  88.03 k   |
|     * Trees          | 169.95 k   |
|     * Blobs          | 162.40 k   |
|     * Tags           |    994     |
|   * Inflated size    |   7.61 GiB |
|     * Commits        |  60.95 MiB |
|     * Trees          |   2.44 GiB |
|     * Blobs          |   5.11 GiB |
|     * Tags           | 731.73 KiB |
|   * Disk size        | 301.50 MiB |
|     * Commits        |  33.57 MiB |
|     * Trees          |  77.92 MiB |
|     * Blobs          | 189.44 MiB |
|     * Tags           | 578.13 KiB |

Vous aurez peut-être également remarqué que les valeurs de taille dans le tableau des données de sortie sont désormais également affichées de manière plus conviviale avec des unités. Dans les versions suivantes, nous espérons étendre davantage les données de sortie de cette commande pour fournir des éléments supplémentaires, tels que les objets individuels les plus volumineux du dépôt.

Ce projet a été mené par Justin Tobler.

Pour en savoir plus

Cet article n'a mis en évidence que quelques-unes des contributions apportées par GitLab et la communauté Git pour cette dernière version. Vous pouvez en apprendre davantage sur ces contributions dans l'annonce de version officielle du projet Git. Consultez également nos articles de blog précédents sur les versions de Git pour découvrir d'autres contributions des membres de l'équipe GitLab.

🎯 Essayez GitLab Duo Agent Platform dès aujourd'hui !

Introduction à la personnalisation

GitLab Duo Agent Platform offre des fonctionnalités puissantes, et vous pouvez l'exploiter encore davantage en l'adaptant aux besoins spécifiques de votre équipe. GitLab propose des options de personnalisation flexibles à plusieurs niveaux :

• Au niveau de l'utilisateur : préférences personnelles qui s'appliquent à tous les projets (règles personnalisées, AGENTS.md, configuration MCP)
• Au niveau du workspace : configurations spécifiques au projet (règles personnalisées, AGENTS.md, configuration MCP)
• Au niveau du projet : agents et flows personnalisés que vous créez et gérez au sein d'un projet spécifique

Partie 1 : personnaliser le comportement des agents

Règles personnalisées

Les règles personnalisées fournissent des instructions aux agents et flows afin de garantir un comportement cohérent au sein de votre équipe sans nécessiter de répétitions (exemples : guides de style relatifs au développement ou manière d'exécuter les tests).

Accédez au répertoire de configuration de votre workspace IDE ou utilisateur.

Règles personnalisées au niveau de l'utilisateur

Les règles au niveau de l'utilisateur s'appliquent à tous vos projets et workspaces.

Pour des instructions détaillées sur la création de règles personnalisées au niveau de l'utilisateur, consultez la documentation de GitLab.

Créez le fichier ~/.gitlab/duo/chat-rules.md dans votre répertoire personnel.

Exemples de règles :

- Include JSDoc comments for all functions
- Use single quotes for strings
- Follow the existing code style in the repository
- Write concise explanations, avoid lengthy descriptions
- Suggest tests for any code changes
- Use async/await instead of promises

Règles personnalisées au niveau du workspace

Les règles du workspace s'appliquent uniquement à un projet spécifique. Elles remplacent les règles au niveau de l'utilisateur pour ce projet.

Créez le fichier .gitlab/duo/chat-rules.md à la racine de votre projet.

Exemples de règles pour un projet Vue.js :

- Use Vue 3 Composition API with `<script setup>`
- Always include TypeScript types for props
- Use scoped styles with SCSS
- Follow the Slippers UI design system
- Keep components under 300 lines
- Use kebab-case for component names
- Include accessibility attributes (aria-*, role)

Bonnes pratiques pour les règles personnalisées

• Soyez précis : « utilise des guillemets simples » est mieux que « suis le guide de style ».
• Priorisez : indiquez les règles les plus importantes en premier.
• Concentrez-vous sur votre équipe : les règles doivent refléter les standards de votre équipe, pas vos préférences personnelles.
• Misez sur des règles exploitables : les règles doivent être suffisamment claires pour qu'un agent d’IA puisse les suivre.
• Maintenez vos règles : mettez à jour les règles lorsque vos standards évoluent.
• Évitez les conflits : ne contredisez pas le style de votre code source.

Astuce : utilisez la fonctionnalité Code Owners pour gérer qui approuve les modifications de .gitlab/duo/chat-rules.md.

Pour un tutoriel détaillé d'un cas d'utilisation des règles personnalisées, consultez l'article sur les règles personnalisées dans GitLab Duo Agentic Chat pour renforcer l'efficacité des équipes de développement.

AGENTS.md : personnaliser le comportement des agents

AGENTS.md est un fichier standard qui permet de personnaliser le comportement des agents. Il vous aide à définir comment les agents doivent se comporter dans vos conversations de chat, vos flows de base et vos flows personnalisés sans modifier les agents eux-mêmes.

Différence avec les règles personnalisées : le fichier AGENTS.md est utilisé par tous les agents et flows (de base et personnalisables). Il suit également une norme que d'autres outils d'IA peuvent utiliser, par exemple Claude Code en tant qu'agent externe. Utilisez AGENTS.md lorsque vous souhaitez que vos instructions s'appliquent à plusieurs contextes.

Niveau de l'utilisateur (s'applique à tous vos projets et workspaces) :

• macOS/Linux : ~/.gitlab/duo/AGENTS.md
• Windows : %APPDATA%\GitLab\duo\AGENTS.md

Niveau du workspace (s'applique à un projet spécifique) :

• Créez le fichier AGENTS.md à la racine de votre projet.

Niveau du sous-répertoire (s'applique à des répertoires spécifiques dans les monorepos) :

• Créez le fichier AGENTS.md dans les sous-répertoires pour des instructions contextuelles spécifiques.

Fonctionnement :

• Le fichier AGENTS.md au niveau de l'utilisateur s'applique à tous les projets.
• Le fichier AGENTS.md au niveau du workspace s'applique à un projet spécifique.
• Les fichiers AGENTS.md au niveau du sous-répertoire fournissent un contexte pour des parties spécifiques de votre code source.
• Les agents et flows combinent les instructions de tous les niveaux applicables.
• Les instructions AGENTS.md (nouvelles ou mises à jour) nécessitent de déclencher de nouveaux flows ou de démarrer un nouveau chat avec un agent (personnalisé).

Contrôles du fichier AGENTS.md

• La personnalité et le ton de l'agent
• Les instructions spécifiques au projet
• Les normes et conventions de codage
• Les préférences d'utilisation des outils
• Les exigences de formatage des données de sortie
• La structure et l'organisation du dépôt

Exemple d'un fichier AGENTS.md

# Agent Customization for Our Project
## General Guidelines
- Always prioritize code quality over speed
- Follow our project's architecture patterns
- Reference existing code examples when suggesting changes
- Ask for clarification if requirements are ambiguous
## Code Style
- Use TypeScript for all new code
- Follow ESLint configuration in the project
- Include unit tests for all new functions
- Use descriptive variable names (no single letters except loops)
## Documentation
- Add JSDoc comments to all public functions
- Update README.md if adding new features
- Include examples in code comments
## Security
- Never suggest hardcoding secrets or API keys
- Always validate user input
- Use parameterized queries for database operations
- Flag potential security issues immediately

Bonnes pratiques pour le fichier AGENTS.md

• Soyez précis : incluez des exemples concrets de votre projet.
• Restez concis : concentrez-vous sur ce qui est unique à votre projet.
• Utilisez le contrôle de version : effectuez un commit dans votre dépôt et utilisez le suivi des modifications.
• Soyez aligné avec votre équipe : discutez avec votre équipe avant de finaliser votre fichier.
• Mettez à jour votre fichier régulièrement : affinez à mesure que votre projet évolue.
• Documentez la structure du dépôt : aidez les agents à comprendre l'organisation de votre code source.

Prérequis

• GitLab 18.8 ou version ultérieure
• Pour VS Code : extension GitLab Workflow 6.60 ou version ultérieure
• Pour JetBrains : plugin GitLab 3.26.0 ou version ultérieur
• Pour les flows : mettez à jour la configuration du flow pour accéder au contexte user_rule

En savoir plus sur AGENTS.md.

Instructions de revue personnalisées

Les instructions de revue personnalisées fournissent des directives spécifiques pour le flow de base Code Review. Ces instructions garantissent des standards de revue de code cohérents et peuvent être adaptées à des types de fichiers spécifiques dans votre projet.

Créez le fichier .gitlab/duo/mr-review-instructions.yaml à la racine de votre projet.

Exemples d'instructions de revue :

instructions:
  - name: Ruby Style Guide
    fileFilters:
      - "*.rb"           # Ruby files in the root directory
      - "lib/**/*.rb"    # Ruby files in lib and its subdirectories
      - "!spec/**/*.rb"  # Exclude test files
    instructions: |
      1. Ensure all methods have proper documentation
      2. Follow Ruby style guide conventions
      3. Prefer symbols over strings for hash keys

  - name: TypeScript Source Files
    fileFilters:
      - "**/*.ts"        # TypeScript files in any directory
      - "!**/*.test.ts"  # Exclude test files
    instructions: |
      1. Ensure proper TypeScript types (avoid 'any')
      2. Follow naming conventions
      3. Document complex functions

Bonnes pratiques pour les instructions de revue personnalisées :

• Soyez précis et concret : des instructions claires et numérotées fonctionnent mieux.
• Utilisez des modèles glob : ciblez des types de fichiers spécifiques avec fileFilters.
• Concentrez-vous sur les normes importantes : priorisez les points de revue les plus critiques.
• Expliquez le « pourquoi » : aidez les relecteurs à comprendre le raisonnement.
• Testez les modèles : assurez-vous que les modèles glob correspondent aux fichiers visés.

Astuce : utilisez la fonctionnalité Code Owners pour protéger les modifications apportées à .gitlab/duo/mr-review-instructions.yaml.

Pour obtenir des instructions de configuration détaillées et des exemples, consultez la documentation relative aux instructions de revue personnalisées.

Partie 2 : étendre les fonctionnalités avec le MCP

Le Model Context Protocol (MCP) permet aux agents d'accéder à des systèmes externes comme Jira, Slack, AWS et plus encore. Cette section couvre la configuration du MCP pour étendre les capacités des agents.

🎯 Découvrez maintenant une démo interactive du MCP pour apprendre à l'utiliser.

Configuration du MCP pour les intégrations externes

Le Model Context Protocol (MCP) permet aux agents d'accéder à des systèmes externes comme Jira, Slack, AWS et plus encore.

Portée : niveau de l'utilisateur (s'applique à tous les workspaces) ou niveau du workspace (spécifique au projet, remplace la configuration utilisateur)

Créer une configuration utilisateur :

• macOS/Linux : ~/.gitlab/duo/mcp.json
• Windows : C:\Users\<username>\AppData\Roaming\GitLab\duo\mcp.json
• VS Code : exécutez la commande GitLab MCP: Open User Settings (JSON)

Créer une configuration workspace :

• Créez le fichier : .gitlab/duo/mcp.json à la racine de votre projet

Bonnes pratiques :

• Sécurité avant tout : utilisez des serveurs MCP qui nécessitent OAuth et non des tokens en texte brut.
• Portée minimale : activez uniquement les serveurs MCP que vous utilisez réellement et en qui vous avez confiance.
• Tests locaux : vérifiez que les connexions et l'autorisation au MCP fonctionnent avant de les partager avec les équipes.
• Documentation des intégrations : expliquez ce que fournit chaque serveur MCP.
• Contrôle de version : stockez la configuration dans .gitlab/duo/mcp.json avec l'approbation de la fonctionnalité Code Owners.

Pour obtenir des instructions de configuration détaillées et des exemples, consultez la partie 7 : intégrer le Model Context Protocol (MCP).

Partie 3 : créer des agents et flows personnalisés

Les agents et flows personnalisés vous permettent d'automatiser les workflows spécifiques de votre équipe. Avant de vous lancer dans la personnalisation, il est utile de comprendre leurs caractéristiques et leur fonctionnement : consultez le guide Démarrer avec GitLab Duo Agent Platform pour en savoir plus.

• Partie 3 : comprendre les agents. Découvrez les agents de base, personnalisés et externes, et quand les utiliser.
• Partie 4 : comprendre les flows. Découvrez comment les flows orchestrent plusieurs agents pour résoudre des problèmes complexes.
• Partie 5 : découvrir le catalogue d'IA. Apprenez à créer et partager des agents et flows au sein de votre organisation. Une fois que vous comprenez les bases, cette section fournit un aperçu des options de personnalisation avec des liens vers des guides détaillés.

Prompts système pour les agents personnalisés

Les prompts système définissent la personnalité, les compétences et le comportement d'un agent. Un prompt bien conçu renforce l'efficacité des agents et les aligne avec les besoins de votre équipe.

Qu'est-ce qu'un prompt système ? Les prompts système sont des instructions qui indiquent à un agent comment se comporter, quelles compétences il possède et comment répondre aux demandes. Ils constituent la base du comportement des agents personnalisés.

Éléments clés d'un prompt système efficace :

• Définition du rôle : rôle et fonction de l'agent
• Domaines d'expertise : domaines ou technologies spécifiques
• Directives de comportement : comment il doit interagir et répondre
• Format des données de sortie : structure des réponses
• Contraintes : ce qu'il doit éviter

Bonnes pratiques :

• Soyez précis : des prompts plus spécifiques produisent de meilleurs résultats.
• Utilisez des exemples : montrez à l'agent à quoi ressemble un bon résultat.
• Définissez la portée : indiquez clairement ce que l'agent doit et ne doit pas faire.
• Testez de manière itérative : affinez les prompts en fonction du comportement de l'agent.
• Contrôle de version : suivez les modifications des prompts dans votre dépôt.

Pour des conseils détaillés sur la création de prompts système et d'agents personnalisés, consultez la Partie 3 : comprendre les agents.

Agents et flows personnalisables

Étant donné que les informations sont nombreuses, nous avons divisé les tutoriels pour faciliter la lecture :

Agents personnalisables :

• Apprenez à créer des agents avec des prompts système personnalisés, à configurer les outils et à gérer les autorisations.
• Consultez la Partie 3 : comprendre les agents – section Agents personnalisables.

Flows personnalisables :

• Apprenez à créer des workflows en plusieurs étapes, à configurer des composants et à mettre en place une automatisation basée sur des événements.
• Consultez la Partie 4 : comprendre les flows – section Flows personnalisables.

Outils d'agent :

• Les outils déterminent les actions que les agents peuvent effectuer. Configurez les outils en fonction de l'objectif de votre agent et des exigences de sécurité.
• Consultez la Partie 3 : comprendre les agents pour les détails de configuration des outils.

Résumé : quand utiliser les personnalisations

Perspectives

Félicitations ! Vous avez terminé toute la série concernant GitLab Duo Agent Platform. Vous savez maintenant :

• Comment utiliser les agents et flows tout au long du SDLC en fonction de vos cas d'utilisation
• Comment découvrir et partager des solutions dans le catalogue d'IA
• Comment surveiller et gérer vos workflows d'IA
• Comment étendre les capacités avec les intégrations MCP
• Comment personnaliser chaque aspect de GitLab Duo Agent Platform pour votre équipe

Consultez l'aperçu complet de la série pour revoir toutes les parties et explorer des sujets spécifiques en profondeur.

Ressources

• Documentation relative aux règles personnalisées
• Documentation relative au fichier AGENTS.md
• Documentation relative aux instructions de revue personnalisées
• Documentation relative aux agents personnalisables
• Documentation relative aux flows personnalisables
• Documentation relative au client MCP

Article précédent : Partie 7 : intégrer le Model Context Protocol

Retour au début : Aperçu complet de la série

🎯 Essayez GitLab Duo Agent Platform dès aujourd'hui !

Présentation des fonctionnalités de la section Automatisation

La section Automatisation est votre centre de contrôle où vous pouvez gérer les workflows d'IA dans GitLab. Elle offre une visibilité sur l'activité des agents et des flows et permet l'automatisation basée sur des événements.

Accédez à Projet → Automatisation.

La section Automatisation propose les sous-sections suivantes :

• Agents : visualisez, créez et gérez les agents de votre projet.
• Flows : visualisez, créez et gérez les flows de votre projet.
• Déclencheurs : configurez l'automatisation basée sur des événements pour les flows.
• Sessions : surveillez l'exécution des agents et des flows avec des logs détaillés.

Gérer les agents

La section Agents vous permet de visualiser, créer et gérer les agents de votre projet.

Accédez à Automatisation → Agents.

Les sections Agents et Flows proposent deux onglets pour organiser vos ressources :

• Activé : agents/flows disponibles dans votre projet
• Géré : agents/flows créés et contrôlés par votre projet

Pour augmenter le nombre d'agents disponibles :

• Créez de nouveaux agents personnalisés, activez-les au niveau du groupe parent, puis activez-les dans votre projet.
• Parcourez le catalogue d'IA et activez les agents existants d'abord dans votre groupe parent, puis dans votre projet.

Pour plus de détails sur la création d'agents personnalisés, consultez la Partie 3 : comprendre les agents.

Gérer les flows

La section Flows vous permet de visualiser, créer et gérer les flows de votre projet.

Accédez à Automatisation → Flows.

Pour augmenter le nombre de flows disponibles :

• Créez de nouveaux flows personnalisés, activez-les au niveau du groupe parent, puis activez-les dans votre projet.
• Parcourez le catalogue d'IA et activez les flows existants d'abord dans votre groupe parent, puis dans votre projet.

Pour plus de détails sur la création de flows personnalisés, consultez Partie 4 : comprendre les flows.

Automatiser à l'aide de déclencheurs

Les déclencheurs permettent l'automatisation sur la base d'événements. Ils exécutent automatiquement des agents ou des flows lorsque des événements spécifiques du cycle de développement logiciel (SDLC) GitLab se produisent.

Accédez à Automatisation → Déclencheurs.

Types d'événements déclencheurs disponibles :

• Mention : mention dans un commentaire, par exemple @ci-cd-optimizer
• Assignation : assignation à un ticket ou une merge request, par exemple via l'interface ou l'action rapide /assign @ci-cd-optimizer
• Assignation en tant que relecteur : assignation comme relecteur de merge request, par exemple via l'interface ou l'action rapide /assign_reviewer @ci-cd-optimizer

Fonctionnement des déclencheurs :

1. Un événement se produit (par ex., @ci-cd-optimizer mentionné dans un commentaire de merge request).
2. Le déclencheur identifie le flow à exécuter.
3. Le flow s'exécute et démarre une session.
4. Les résultats sont publiés dans le ticket/la merge request.

Pour obtenir des instructions de configuration, consultez la documentation relative aux déclencheurs.

Surveiller avec les sessions

Les sessions offrent une transparence totale sur l'exécution des agents et des flows, avec le raisonnement, les outils exécutés et les résultats. Chaque exécution crée une session avec un log des activités.

Accédez à Automatisation → Sessions.

Les sessions affichent :

• Le statut d'exécution (Créé, En cours, Terminé, Échec, Saisie requise, etc.)
• La progression étape par étape et les actions entreprises
• Le raisonnement de l'agent et son processus de décision
• Le lien vers les logs du job du runner (onglet Détails)

Onglet Activité

L'onglet Activité affiche l'exécution étape par étape avec chaque action entreprise par l'agent, les outils utilisés et les résultats de ces actions.

Onglet Détails

L'onglet Détails donne accès aux logs complets du job du runner, où vous pouvez consulter le contexte d'exécution complet et toute information système sur l'exécution du flow.

Les logs du job contiennent les données de sortie d'exécution complètes, avec tous les messages système, les invocations d'outils et les informations détaillées concernant les tâches effectuées par le flow.

Pour plus de détails, consultez la documentation relative aux sessions.

Perspectives

Vous savez désormais comment surveiller l'activité des agents et des flows via les sessions, configurer une automatisation basée sur des événements avec les déclencheurs et gérer vos workflows d'IA depuis la section Automatisation. Vous apprendrez ensuite comment utiliser GitLab Duo avec des outils externes et des sources de données dans la Partie 7 : intégrer le Model Context Protocol.

Ressources

• Documentation relative aux sessions
• Documentation relative aux déclencheurs
• Documentation relative aux flows personnalisables
• Documentation relative aux Agents personnalisables

Article suivant : Partie 7 : intégrer le Model Context Protocol

Article précédent : Partie 5 : découvrir le catalogue d'IA

Dans cet article, découvrez les meilleures pratiques CI/CD à connaître pour accélérer la livraison de logiciels, réduire les risques et améliorer la qualité logicielle.

Qu’est-ce que le CI/CD ?

Le CI/CD est à la fois un processus technologique, un état d'esprit et une suite d'étapes. En termes simples, l'intégration continue (CI) permet aux équipes DevSecOps d'optimiser le développement du code grâce à l'automatisation. Elle simplifie les builds logiciels et l'intégration du code source, permet le contrôle de version et favorise une meilleure collaboration entre les équipes.

Là où la l'intégration continue (CI) s'arrête, la livraison continue (CD) prend le relais avec des tests et des déploiements automatisés. La livraison continue réduit considérablement le travail manuel des équipes Ops, tout en permettant de réduire la chaîne d'outils nécessaires à la gestion du cycle de développement logiciel.

Ensemble, la CI et la CD forment un pipeline d'intégration et de livraison continues, orchestré pour automatiser les étapes de développement, du build du code à son déploiement en production.

En intégrant des scans de sécurité et des contrôles de conformité en amont du pipeline, le CI/CD met en œuvre une approche « shift-left » de la sécurité où les problèmes sont identifiés et corrigés en amont avant d'atteindre l’environnement de production.

→ Essayez GitLab Ultimate et GitLab Duo Enterprise gratuitement et découvrez toute la puissance du CI/CD intégré à une plateforme DevSecOps complète.

Les 10 meilleures pratiques CI/CD

1. Utilisez une plateforme DevSecOps unifiée

Regroupez vos outils CI/CD au sein d'une seule et même plateforme afin de réduire les coûts de maintenance, limiter les changements de contexte et renforcer la collaboration entre les équipes. Moins il y a d'outils, moins il y a de complexité d'intégration, et meilleure est l'expérience pour les équipes chargées du développement, de la sécurité et des opérations.

2. Automatisez tout

Optimisez continuellement votre pipeline CI/CD pour atteindre un état d'« automatisation continue ». Cette automatisation inclut les tests automatisés, les scans de sécurité, le déploiement et le provisionnement de l'infrastructure. Plus vos processus sont automatisés, plus vos livraisons sont rapides, cohérentes et fiables.

3. Échouez vite et souvent

Les équipes de développement doivent être informées immédiatement lorsqu'un commit provoque une erreur. Corriger le code pendant que le problème est encore frais dans leur esprit limite le changement de contexte, tout en améliorant la qualité du code. Cette approche contribue aussi à la satisfaction et à la productivité des équipes DevSecOps.

4. Validez fréquemment

Des commits réguliers et de petite taille facilitent la revue, les tests et le déploiement du code. Ces changements incrémentaux limitent les risques et accélèrent les livraisons.

5. Adoptez une approche « shift-left »

Le CI/CD offre l'opportunité d'intégrer la sécurité très tôt dans le développement logiciel. En déplaçant la sécurité plus en amont, les failles sont détectées avant la mise en production, réduisant ainsi le coût et l'impact des correctifs.

6. Exploitez l'IA pour diagnostiquer les pipelines en échec

Les outils alimentés par l'intelligence artificielle permettent de diagnostiquer automatiquement les pipelines en échec, d'identifier leur cause et de suggérer des correctifs. Cette approche réduit considérablement le temps de résolution de plusieurs heures à quelques minutes tout en libérant les équipes de tâches répétitives.

7. Décorrélez déploiement et release grâce aux feature flags

Les feature flags permettent de déployer du code en production sans exposer immédiatement les nouvelles fonctionnalités aux utilisateurs. Cette approche sécurise les déploiements, facilite les tests progressifs et rend les retours en arrière instantanés en cas de problème.

8. Monitorez tout

Mettez en place une surveillance complète couvrant les métriques applicatives, les logs et les indicateurs de performance. Des alertes bien configurées, à la fois sur les seuils techniques et métier, permettent d'anticiper les anomalies et d'assurer la stabilité du service.

9. Maintenez le pipeline en tant que code

Stockez la configuration de votre pipeline CI/CD dans le même système de contrôle de version que votre application. Chaque modification est ainsi suivie, révisable et réversible.

10. Mettez en place des boucles de rétroaction continues

Le CI/CD n'est pas un processus figé. Veillez à ce que toutes les équipes puissent facilement recevoir et apporter des retours. Les retours issus de la supervision, des alertes ou des validations post-déploiement alimentent une amélioration continue du pipeline.

Les meilleures pratiques en matière de livraison continue

La livraison continue mérite à elle seule une attention particulière : si l'intégration continue fait souvent la une, c'est bien la livraison continue qui concrétise la promesse du DevOps : livrer plus vite et plus souvent.

Voici les meilleures pratiques à adopter en matière de livraison continue pour des déploiements fluides et fiables :

• Commencez par votre configuration actuelle. Inutile d'attendre la plateforme parfaite. Analysez vos processus de déploiement existants, repérez les points de friction et automatisez d'abord les tâches manuelles les plus répétitives. L'amélioration continue commence toujours avec ce que vous avez déjà.
• Adoptez des stratégies de déploiement progressif. Mettez en place des approches éprouvées comme le déploiement bleu/vert, le déploiement canari ou les feature flags. Ces méthodes réduisent considérablement les risques et facilitent les retours en arrière rapides en cas d'incident.
• Assurez la cohérence entre vos environnements. Vos environnements de développement, de préproduction et de production doivent être les plus similaires possible. L'Infrastructure as Code (IaC) vous aidera à éliminer les dérives de configuration.
• Automatisez la validation après chaque déploiement. Mettez en place des smoke tests automatisés et des états de service automatiques pour vérifier instantanément la stabilité du système après une mise en production. Si une validation échoue, le pipeline doit pouvoir déclencher automatiquement un retour à la version précédente.
• Mettez en place une supervision complète. Suivez à la fois les indicateurs techniques (temps de réponse, taux d'erreur) et les indicateurs métiers (satisfaction, engagement, conversion). La détection précoce des anomalies est la clé d'une production stable.
• Adoptez le déploiement sans interruption. Concevez vos applications et votre processus de déploiement de manière à gérer les mises à jour sans temps d'arrêt. Le « zéro temps d'arrêt » doit être un objectif dès la conception.
• Simplifiez les retours à la version précédente. Le retour en arrière doit être instantané. Testez vos processus régulièrement et assurez-vous qu'un retour complet puisse être exécuté en un clic.
• Dissociez déploiement et mise en production. Grâce aux feature flags, vous pouvez déployer du code sans exposer immédiatement les nouvelles fonctionnalités. Cela vous permet de tester en conditions réelles tout en limitant les risques pour les utilisateurs finaux.

Tirez parti de tous les avantages de l'intégration et de la livraison continues avec la plateforme DevSecOps de GitLab.

Comment optimiser son pipeline CI/CD ?

Le pipeline CI/CD est la colonne vertébrale du développement moderne. C’est une série d'étapes automatisées qui achemine le code du développement à la mise en production. Un pipeline type comprend les étapes suivantes : build, tests, scans de sécurité, déploiement et supervision. Ces étapes peuvent être réalisées manuellement, mais c'est leur automatisation qui décuple la rapidité et la fiabilité du processus.

Optimisez les performances du pipeline

• Utilisez la mise en cache des builds pour éviter de recompiler les éléments inchangés.
• Définissez des règles conditionnelles pour ignorer les étapes inutiles lorsque le code n'a pas été modifié.
• Optimisez les images Docker avec des builds multi-étapes et des images de base plus légères.

Améliorez la visibilité du pipeline

• Ajoutez un suivi de la durée du pipeline pour identifier les goulots d'étranglement.
• Mettez en place une journalisation détaillée et une collecte d’artefacts pour faciliter le diagnostic.
• Appuyez-vous sur les tableaux de bord de GitLab pour visualiser les taux de réussite et les tendances en matière de performances.

Optimisez l'efficacité des ressources

• Ajustez la taille de vos runners selon leur charge réelle.
• Exploitez les instances ponctuelles ou la mise à l'échelle automatique pour réduire les coûts d'exécution.
• Nettoyez les ressources temporaires et les artefacts après l'achèvement du pipeline.

Anticipez la croissance de l'équipe

• Utilisez des composants de pipeline pour uniformiser les pratiques entre projets. Utilisez des environnements dynamiques qui se créent et se suppriment automatiquement.
• Configurez des workflows d'approbation de déploiement avant toute mise en production.

Stratégie de déploiement CI/CD

L'objectif du CI/CD est simple : livrer un logiciel plus performant, plus rapidement, et en continu. Les organisations qui adoptent cette approche gagnent en agilité, en productivité et en qualité. Encore faut-il définir une stratégie adaptée à votre contexte.

Voici quelques leviers pour réussir vos déploiements :

• Privilégiez les petits changements. Le déploiement fréquent de mises à jour incrémentales facilite les tests, les revues et les retours en arrière. Cela réduit les risques et améliore la stabilité des logiciels.
• Montez progressivement en puissance. Démarrez sur des projets à faible impact pour affiner vos processus avant de vous attaquer aux systèmes critiques.
• Automatisez les retours en arrière. Définissez des seuils d'alerte (taux d'erreur, indicateurs de performance, état des services) qui déclenchent un retour à la version précédente automatique.
• Répétez vos déploiements. Testez régulièrement votre processus de déploiement dans des environnements de préproduction qui reflètent la production.
• Planifiez vos fenêtres de déploiement. Commencez par des périodes de faible activité avant de passer à un déploiement continu.
• Mesurez l'impact de chaque déploiement. Suivez les performances techniques et les indicateurs business après chaque déploiement pour évaluer la réussite.

Comment mesurer la performance de votre CI/CD ?

Il est impossible d'améliorer ce qu'on ne mesure pas. Les équipes DevSecOps s'appuient sur des indicateurs pour évaluer la performance et détecter les marges de progrès.

Les 4 métriques DORA

Les organisations les plus performantes mesurent systématiquement ces quatre indicateurs issus du framework DORA :

• Fréquence de déploiement : nombre de mises en production réussies sur une période donnée. Les organisations d'élite déploient jusqu'à plusieurs fois par jour.
• Délai d'exécution des modifications : temps écoulé entre le le premier commit et le déploiement en production. Objectif cible : passer sous la barre des 24 heures.
• Taux d'échec des modifications : pourcentage de déploiements provoquant des incidents en production et nécessitant des correctifs urgents ou des retours en arrière. Un taux inférieur à 15 % est signe d'un pipeline mature.
• Temps moyen de restauration : rapidité de résolution après incident. Les meilleurs rétablissent un service complet en moins d'une heure. Une restauration rapide nécessite une supervision robuste et des capacités de retour en arrière automatisées.

Les autres KPI à suivre

• Coûts d'infrastructure : le CI/CD cloud-native peut entraîner des dépenses importantes s'il n'est pas géré correctement. Les pratiques qui réduisent les temps de build et optimisent l'utilisation des ressources ont un impact direct sur les coûts opérationnels.
• Satisfaction et rétention des équipes : les développeurs satisfaits restent fidèles à l'entreprise. Lorsque les équipes collaborent efficacement sur les pratiques CI/CD, la fidélisation suit. Un pipeline fluide réduit ainsi le stress, améliore la collaboration et fidélise les équipes de développement.

Impact business immédiat

Ces indicateurs techniques se traduisent par des gains concrets :

• Des cycles de livraison plus courts améliorent les délais de mise sur le marché et la compétitivité.
• Un faible taux d'échec réduit les coûts d'assistance et les interruptions.
• Un temps moyen de réparation rapide garantit la continuité des services et la satisfaction client.

Les équipes hautement performantes en matière de CI/CD obtiennent systématiquement de meilleurs résultats commerciaux, améliorent leur productivité, et ont une plus grande capacité d'innovation. — Étude DORA 2025

Quels sont les avantages d'une approche CI/CD maîtrisée ?

L'application rigoureuse des bonnes pratiques CI/CD profite à tous : utilisateurs, développeurs et dirigeants, en favorisant un développement logiciel plus fluide, collaboratif et orienté qualité.

• Des fonctionnalités livrées plus vite : cycles courts, releases fréquentes et corrections rapides.
• Une qualité logicielle renforcée : moins de bugs, moins de stress, plus de stabilité.
• Une meilleure réactivité client : intégration immédiate des retours utilisateurs.
• Un service plus fiable : supervision continue et retours à la version précédente automatisés.
• Un environnement propice à l'innovation : moins de tâches répétitives, plus de création de valeur.
• Des équipes plus engagées : moins d'incidents, plus de temps pour le développement et la collaboration.

Comment déployer le CI/CD dans votre organisation ?

Avant de vous lancer, clarifiez les objectifs stratégiques et leur impact sur votre cycle de développement logiciel. Impliquez vos équipes dès la phase de conception de votre approche CI/CD : elles seront les premières concernées par ce changement.

• Évaluez les solutions adaptées à vos besoins (infrastructure, sécurité, gouvernance).
• Testez les outils via des essais gratuits pour valider leur intégration dans votre pile existante.
• Avancez progressivement, en automatisant étape par étape.
• Suivez vos métriques clés pour mesurer les gains de performance et d'efficacité.

→ Essayez GitLab Ultimate et GitLab Duo Enterprise gratuitement et découvrez toute la puissance du CI/CD intégré à une plateforme DevSecOps complète.

🎯 Essayez GitLab Duo Agent Platform dès aujourd'hui !

Qu'est-ce que le catalogue d'IA ?

Le catalogue d'IA est un dépôt centralisé qui permet de découvrir, de créer et de partager des agents et des flows dans l'ensemble de votre organisation. Il favorise la cohérence, les solutions réutilisables et la collaboration en permettant aux équipes d'exploiter des solutions préconfigurées et des bonnes pratiques.

Actions possibles avec le catalogue d'IA :

• Découvrir : parcourez les agents et les flows créés par GitLab et la communauté.
• Créer : créez et maintenez des agents et des flows personnalisés dans une interface unique.
• Activer : activez des agents et des flows au niveau de votre groupe principal, puis utilisez-les dans vos projets.
• Partager : publiez vos agents et vos flows afin que d'autres puissent les utiliser (visibilité publique ou privée).
• Dupliquer : copiez et personnalisez des agents et des flows existants.

Accéder au catalogue d'IA et l'utiliser

Accédez à Explorer → Catalogue d'IA.

Le catalogue propose actuellement deux types d'éléments :

• Agents : des agents personnalisables pour des tâches ponctuelles, interactives ou contextuelles.
• Flows : des flows personnalisables pour des automatisations reproductibles en plusieurs étapes, qui orchestrent une équipe d'agents.

Pour obtenir des informations détaillées, consultez la documentation relative au catalogue d'IA.

Découvrir les agents et des flows

Le catalogue d'IA facilite la découverte d'agents et de flows adaptés à vos besoins :

Comment parcourir le catalogue :

1. Accédez à Explorer → Catalogue d'IA.
2. Sélectionnez l'onglet Agents ou Flows.
3. Parcourez les agents ou flows disponibles et consultez le titre, la description et le statut de visibilité.
4. Cliquez sur n'importe quel agent ou flow pour afficher davantage de détails.

Activer des agents et des flows :

Une fois que vous avez trouvé un agent ou un flow que vous souhaitez utiliser :

1. Cliquez sur l'agent ou le flow pour en afficher les détails.
2. Cliquez sur le bouton Activer dans le groupe pour ajouter l'agent ou le flow à votre groupe principal.
3. Activez-le dans votre projet pour commencer à l'utiliser.

Créer, partager et gérer la visibilité

Créer des agents et des flows

Voici des instructions détaillées pour créer des agents et des flows.

Créer des agents :

Accédez à Explorer → Catalogue d'IA → Agents → Nouvel agent.

1. Assignez une tâche ou une spécialisation spécifique à cet agent, par exemple un agent de débogage et de dépannage.
2. Ajoutez un nom qui s'affichera et une description pour aider les autres utilisateurs à identifier l'objectif et la raison pour laquelle ils souhaiteraient utiliser l'agent, par exemple troubleshoot-debugger.
3. Indiquez la visibilité et l'accès. Sélectionnez un projet privé et définissez la visibilité comme privée si vous souhaitez commencer par tester l'agent.
4. Définissez le comportement, les capacités et la spécialisation de l'agent dans le prompt système. Pour obtenir des détails sur la création de prompts système efficaces, consultez la Partie 3 : comprendre les agents.
5. Sélectionnez et limitez éventuellement l'accès aux outils pour les agents. Par exemple, un agent de débogage a besoin d'un accès en lecture au code, aux tickets et aux merge requests, mais n'a pas besoin d'un accès en écriture pour apporter des modifications.

Créer des flows :

Accédez à Explorer → Catalogue d'IA → Flows → Nouveau flow.

1. Définissez une tâche spécifique complexe en plusieurs étapes, par exemple un flow d'optimisation de pipeline CI/CD.
2. Ajoutez un nom qui s'affichera et une description pour aider les autres utilisateurs à identifier l'objectif et la raison pour laquelle ils souhaiteraient utiliser le flow, par exemple ci-cd-optimizer.
3. Indiquez la visibilité et l'accès. Sélectionnez un projet privé et définissez la visibilité comme privée si vous souhaitez commencer par tester l'agent.
4. Définissez le comportement du flow ainsi que ses composants d'agents, ses prompts et ses routeurs. Pour obtenir des détails sur la structure YAML des flows, consultez la Partie 4 : comprendre les flows.

Pour plus de détails, consultez les ressources suivantes :

• Documentation concernant les agents personnalisables
• Documentation concernant les flows personnalisables

Partager votre travail et définir la visibilité

Lors de la création d'agents ou de flows, vous pouvez choisir entre une visibilité privée et publique afin de contrôler qui peut y accéder et les utiliser.

Visibilité privée :

• Les agents et flows ne peuvent être consultés que par les membres du projet de gestion qui disposent au moins du rôle Développeur, ou par les utilisateurs avec le rôle Propriétaire pour le groupe principal.
• Ils ne peuvent pas être activés dans d'autres projets.
• Ils sont utiles pour les workflows spécifiques d'une équipe ou sensibles.

Visibilité publique :

• Les agents et flows peuvent être consultés par toute personne sur l'instance.
• Ils peuvent être activés dans n'importe quel projet répondant aux prérequis.
• Ils apparaissent dans le catalogue d'IA pour faciliter leur découverte.

Bonnes pratiques de partage

Lorsque vous publiez des agents et des flows dans le catalogue d'IA, n'oubliez pas de suivre ces recommandations :

Nommage :

• Utilisez des noms clairs et descriptifs (par exemple, security-code-review, api-documentation-generator).
• Évitez les noms génériques comme agent1 ou my-flow.
• Incluez l'objectif dans le nom lorsque cela est possible.

Documentation :

• Indiquez une description claire de ce que fait l'agent ou le flow.
• Ajoutez des cas d'utilisation et des exemples.
• Documentez tous les prérequis ou dépendances.

Qualité :

• Testez minutieusement l'agent ou le flow avant de le publier.
• Assurez-vous que l'agent ou le flow résout un problème réel.
• Veillez à ce qu'il puisse être maintenu et qu'il soit bien documenté.
• Prenez en compte les cas limites et la gestion des erreurs.

Choix concernant la visibilité :

• Commencez avec une visibilité privée pour effectuer des tests avec votre équipe.
• Passez à une visibilité publique une fois les tests validés et documentés.
• Ne publiez que si l'agent ou le flow apporte une valeur ajoutée.
• Prenez en compte le public et les cas d'utilisation.

Comprendre la gestion des versions

Les agents et flows personnalisés du catalogue d'IA conservent un historique des versions pour suivre les modifications.

Fonctionnement de la gestion des versions :

• GitLab crée automatiquement une nouvelle version lorsque vous mettez à jour le prompt système d'un agent ou modifiez la configuration d'un flow.
• Les versions utilisent la gestion sémantique de version (par exemple, 1.0.0, 1.1.0).
• GitLab effectue une gestion sémantique de version automatique : les mises à jour incrémentent toujours la version mineure.
• Les versions sont immuables afin de garantir un comportement cohérent.

Épinglage des versions :

Lorsque vous activez un agent ou un flow :

• Dans un groupe : GitLab l'épingle à la dernière version.
• Dans un projet : GitLab l'épingle à la même version que votre groupe principal.

Conséquences :

• Vos projets utilisent une version fixe et stable de l'agent ou du flow.
• Les mises à jour dans le catalogue d'IA n'affectent pas automatiquement votre configuration.
• Vous devez accepter explicitement de passer aux nouvelles versions : les mises à jour ne sont jamais automatiques.
• Vous conservez un contrôle total sur le moment d'adoption des nouvelles versions.

Consulter les versions :

• Accédez à Automatisation → Agents ou Automatisation → Flows.
• Sélectionnez l'agent ou le flow pour afficher sa version sur le côté droit dans la section À propos.

Mettre à jour vers la dernière version

Lorsqu'une nouvelle version d'un agent ou d'un flow est disponible dans le catalogue d'IA, vous pouvez mettre à jour vos projets pour l'utiliser.

1. Accédez à Automatisation → Agents ou Automatisation → Flows.
2. Cliquez sur l'agent ou le flow que vous souhaitez mettre à jour.
3. Cliquez sur le bouton Mettre à jour (apparaît lorsqu'une version plus récente est disponible).
4. Examinez les modifications apportées dans la nouvelle version.
5. Confirmez la mise à jour pour épingler votre projet à la dernière version.

Perspectives

Vous savez désormais comment découvrir, créer et partager des agents et des flows via le catalogue d'IA. Dans la Partie 6, vous apprendrez à surveiller l'activité des agents et des flows via les sessions, à configurer des déclencheurs basés sur des événements et à gérer vos workflows d'IA.

Ressources

• Documentation concernant le catalogue d'IA
• Documentation concernant les agents personnalisables
• Documentation concernant les flows personnalisables

Article suivant : Partie 6 : surveiller, gérer et automatiser les workflows d'IA

Article précédent : Partie 4 : comprendre les flows

🎯 Essayez GitLab Duo Agent Platform dès aujourd'hui !

Introduction aux flows

Les flows sont des combinaisons d'un ou de plusieurs agents qui collaborent ensemble. Ils orchestrent des workflows multi-étapes pour résoudre des problèmes complexes et s'exécutent sur la plateforme de calcul de GitLab.

Caractéristiques clés des flows :

• Orchestration multi-agents : ils combinent plusieurs agents spécialisés.
• Intégrés : ils s'exécutent sur la plateforme de calcul, aucun environnement supplémentaire nécessaire.
• Pilotés par des événements : ils sont déclenchés par des mentions, des assignations ou peuvent être assignés en tant que relecteur.
• Asynchrones : ils s'exécutent en arrière-plan pendant que vous continuez à travailler.
• Workflows complets : ils gèrent les tâches de bout en bout, de l'analyse à l'implémentation.

Les flows sont des workflows autonomes capables de rassembler du contexte, de prendre des décisions, d'exécuter des changements et de livrer des résultats pendant que vous vous concentrez sur d'autres tâches.

Flows vs agents : quelle est la différence ?

Les agents travaillent avec vous de manière interactive. Les flows travaillent pour vous de manière autonome.

Vue d'ensemble des types de flows

Flows de base

Les flows de base sont des workflows prêts pour la production créés et maintenus par GitLab. Ils sont accessibles via des contrôles UI dédiés ou des interfaces IDE.

Flows de base actuellement disponibles

Flows personnalisables

Les flows personnalisables sont des workflows définis en YAML que vous créez pour les besoins spécifiques de votre équipe. Ils s'exécutent dans GitLab Runner et peuvent être déclenchés par des événements GitLab.

🎯 Essayez les flows : visionnez notre démo interactive des flows personnalisables pour explorer comment les créer et les configurer.

Pourquoi créer des flows personnalisés ?

Les flows personnalisables automatisent les tâches multi-étapes répétitives spécifiques au workflow de votre équipe. Contrairement aux flows de base qui servent des objectifs généraux, les flows personnalisables sont adaptés aux processus, outils et exigences de votre organisation.

Cas d'utilisation courants :

• Revue de code automatisée : processus de revue multi-étapes (scan de sécurité → vérification de qualité → validation de style)
• Vérification de la conformité : vérification des exigences réglementaires, de la conformité des licences ou des politiques de sécurité pour chaque merge request
• Génération de documentation : mise à jour automatique de la documentation API, des fichiers README ou des changelogs basée sur les modifications de code
• Gestion des dépendances : scans de sécurité hebdomadaires, mises à jour automatisées et rapports de vulnérabilité
• Tests personnalisés : suites de tests spécialisées pour votre pile technologique ou vos tests d'intégration

Exemple concret

Une entreprise fintech crée un flow de conformité qui s'exécute sur chaque merge request. Lorsqu'il est déclenché par @compliance-flow, le flow exécute les étapes suivantes :

1. L'agent Security Analyst scanne le code pour détecter les violations PCI-DSS et vérifie les données sensibles exposées.
2. L'agent Code Review vérifie que les modifications respectent les standards de codage sécurisé et les bonnes pratiques.
3. L'agent de documentation vérifie que les modifications apportées à l'API incluent une documentation mise à jour.
4. L'agent de synthèse agrège les résultats et publie un rapport de conformité avec un statut réussite/échec.

L'ensemble de la revue de conformité se déroule automatiquement en 5 à 10 minutes, avec des vérifications cohérentes sur toutes les merge requests.

Comment déclencher des flows personnalisés ?

Les flows personnalisés peuvent être déclenchés de plusieurs façons :

1. Via des mentions dans les tickets/merge requests : mentionnez le flow dans un commentaire pour le déclencher. Exemple pour un flow de génération de documentation :

@doc-generator Generate API documentation for this feature

2. En assignant le flow à un ticket ou une merge request : assignez le flow en utilisant :

• L'interface utilisateur de GitLab : cliquez sur le bouton « Assigner » sur le ticket/la merge request et sélectionnez le flow.
• Commande : utilisez la commande /assign dans un commentaire. Exemple :

/assign @doc-generator

3. En assignant le flow en tant que relecteur : assignez le flow comme relecteur sur une merge request en utilisant :

• L'interface utilisateur de GitLab : cliquez sur le bouton « Assigner un relecteur » sur la merge request et sélectionnez le flow.
• Commande : utilisez la commande /assign reviewer dans un commentaire. Exemple :

/assign_reviewer @doc-reviewer

Chacune de ces méthodes déclenche automatiquement le flow pour qu'il exécute ses tâches.

Comment créer des flows personnalisés

Les flows personnalisés sont créés via l'interface de GitLab sous Automatisation → Flows → Nouveau flow dans votre projet, ou depuis Explorer → Catalogue d'IA → Flows → Nouveau flow. Vous définissez votre flow à l'aide d'une configuration YAML qui précise les composants, les prompts, le routage et le flow d'exécution. Le schéma YAML vous permet de créer des workflows multi-agents sophistiqués avec un contrôle précis du comportement et de l’orchestration des agents.

Éléments clés d'un flow personnalisé :

• Composants : définissez les agents et les étapes de votre workflow
• Prompts : configurez le comportement et les instructions du modèle d'IA
• Routeurs : contrôlez le flow entre les composants
• Set d'outils : indiquez quels outils de l'API GitLab les agents peuvent utiliser

Exemple de flow personnalisé YAML

Contexte : cet exemple montre un flow d'implémentation de fonctionnalité pour une plateforme de réservation de voyages. Lorsqu'un développeur crée un ticket avec des exigences de fonctionnalité, il peut déclencher ce flow pour analyser automatiquement les exigences, examiner le code source, implémenter la solution et créer une merge request, le tout sans intervention manuelle.

Voici la configuration YAML :

version: "v1"
environment: ambient
components:
  - name: "implement_feature"
    type: AgentComponent
    prompt_id: "implementation_prompt"
    inputs:
      - from: "context:goal"
        as: "user_goal"
      - from: "context:project_id"
        as: "project_id"
    toolset:
      - "get_issue"
      - "get_repository_file"
      - "list_repository_tree"
      - "find_files"
      - "blob_search"
      - "create_file"
      - "create_commit"
      - "create_merge_request"
      - "create_issue_note"
    ui_log_events:
      - "on_agent_final_answer"
      - "on_tool_execution_success"
      - "on_tool_execution_failed"

prompts:
  - name: "Cheapflights Feature Implementation"
    prompt_id: "implementation_prompt"
    unit_primitives: []
    prompt_template:
      system: |
        You are an expert full-stack developer specializing in travel booking platforms, specifically Cheapflights.

        Your task is to:
        1. Extract the issue IID from the goal (look for "Issue IID: XX")
        2. Use get_issue with project_id={{project_id}} and issue_iid to retrieve issue details
        3. Analyze the requirements for the flight search feature
        4. Review the existing codebase using list_repository_tree, find_files, and get_repository_file
        5. Design and implement the solution following Cheapflights best practices
        6. Create all necessary code files using create_file (call multiple times for multiple files)
        7. Commit the changes using create_commit
        8. Create a merge request using create_merge_request
        9. Post a summary comment to the issue using create_issue_note with the MR link

        Cheapflights Domain Expertise:
        - Flight search and booking systems (Amadeus, Sabre, Skyscanner APIs)
        - Fare comparison and pricing strategies
        - Real-time availability and inventory management
        - Travel industry UX patterns
        - Performance optimization for high-traffic flight searches

        Code Standards:
        - Clean, maintainable code (TypeScript/JavaScript/Python/React)
        - Proper state management for React components
        - RESTful API endpoints with comprehensive error handling
        - Mobile-first responsive design
        - Proper timezone handling (use moment-timezone or date-fns-tz)
        - WCAG 2.1 accessibility compliance

        Flight-Specific Best Practices:
        - Accurate fare calculations (base fare + taxes + fees + surcharges)
        - Flight duration calculations across timezones
        - Search filter logic (price range, number of stops, airlines, departure/arrival times)
        - Sort algorithms (best value, fastest, cheapest)
        - Handle edge cases: date line crossing, daylight saving time, red-eye flights
        - Currency amounts use proper decimal handling (avoid floating point errors)
        - Dates use ISO 8601 format
        - Flight codes follow IATA standards (3-letter airport codes)

        Implementation Requirements:
        - No TODOs or placeholder comments
        - All functions must be fully implemented
        - Include proper TypeScript types or Python type hints
        - Add JSDoc/docstring comments for all functions
        - Comprehensive error handling and input validation
        - Basic unit tests for critical functions
        - Performance considerations for handling large result sets

        CRITICAL - Your final comment on the issue MUST include:
        - **Implementation Summary**: Brief description of what was implemented
        - **Files Created/Modified**: List of all files with descriptions
        - **Key Features**: Bullet points of main functionality
        - **Technical Approach**: Brief explanation of architecture/patterns used
        - **Testing Notes**: How to test the implementation
        - **Merge Request Link**: Direct link to the created MR (format: [View Merge Request](MR_URL))

        IMPORTANT TOOL USAGE:
        - Extract the issue IID from the goal first (e.g., "Issue IID: 12" means issue_iid=12)
        - Use get_issue with project_id={{project_id}} and issue_iid=<extracted_iid>
        - Create multiple files by calling create_file multiple times (once per file)
        - Use create_commit to commit all files together with a descriptive commit message
        - Use create_merge_request to create the MR and capture the MR URL from the response
        - Use create_issue_note with project_id={{project_id}}, noteable_id=<issue_iid>, and body=<your complete summary with MR link>
        - Make sure to include the MR link in the comment body so users can easily access it

      user: |
        Goal: {{user_goal}}
        Project ID: {{project_id}}

        Please complete the following steps:
        1. Extract the issue IID and retrieve full issue details
        2. Analyze the requirements thoroughly
        3. Review the existing codebase structure and patterns
        4. Implement the feature with production-ready code
        5. Create all necessary files (components, APIs, tests, documentation)
        6. Commit all changes with a clear commit message
        7. Create a merge request
        8. Post a detailed summary comment to the issue including the MR link

      placeholder: history
    params:
      timeout: 300

routers:
  - from: "implement_feature"
    to: "end"

flow:
  entry_point: "implement_feature"

Ce que fait ce flow : ce flow orchestre un agent d'IA pour implémenter automatiquement une fonctionnalité en analysant les exigences du ticket, en examinant le code source, en écrivant du code prêt pour la production avec une expertise métier, et en créant une merge request avec un commentaire de synthèse détaillé.

Pour obtenir une documentation complète et des exemples, consultez les pages suivantes :

• Documentation relative aux flows personnalisables
• Framework de dépôt des flows (schéma YAML)

Exécution des flows

Les flows s'exécutent sur le système de calcul de la plateforme GitLab. Lorsqu'ils sont déclenchés par un événement (mention, assignation ou clic sur un bouton), une session est créée et le flow commence à s'exécuter.

Variables d'environnement disponibles

Les flows ont accès à des variables d'environnement qui fournissent le contexte sur le déclencheur et l'objet GitLab :

• AI_FLOW_CONTEXT : contexte sérialisé en JSON qui inclut les diffs des merge requests, les descriptions des tickets, les commentaires et les fils de discussion
• AI_FLOW_INPUT : le texte du prompt ou du commentaire de l'utilisateur qui a déclenché le flow
• AI_FLOW_EVENT : le type d'événement qui a déclenché le flow (mention, assign, assign_reviewer)

Ces variables permettent à votre flow de comprendre ce qui l'a déclenché et d'accéder aux données GitLab pertinentes pour effectuer sa tâche.

Flows multi-agents

Les flows personnalisés peuvent inclure plusieurs composants d'agents qui travaillent ensemble de manière séquentielle. La configuration YAML du flow définit :

• Les composants : un ou plusieurs agents (AgentComponent) ou étapes déterministes
• Routeurs : définissent le flow entre les composants (par exemple, du composant A au composant B jusqu'à la fin)
• Prompts : configurent le comportement et le modèle de chaque agent

Par exemple, un flow de revue de code pourrait avoir un agent de sécurité, puis un agent de qualité, puis un agent d'approbation, avec des routeurs qui les connectent en séquence.

Surveillance de l'exécution des flows

Pour afficher les flows en cours d'exécution pour votre projet :

1. Accédez à Automatisation → Sessions.
2. Sélectionnez une session pour afficher plus de détails.
3. L'onglet Détails affiche un lien vers les logs du job CI/CD.

Les sessions affichent des informations détaillées qui incluent la progression étape par étape, les outils invoqués, le raisonnement et le processus de prise de décision.

Quand utiliser les flows

• Tâches complexes multi-étapes
• Automatisation en arrière-plan
• Workflows basés sur les événements
• Modifications multi-fichiers
• Tâches chronophages
• Revues/vérifications automatisées

Prochaines étapes

Vous connaissez maintenant les flows et savez comment les créer et quand les utiliser par rapport aux agents. Dans la Partie 5 : découvrir le catalogue d'IA, vous apprendrez à créer et à partager des agents et des flows dans votre organisation. Explorez le catalogue d'IA pour connaître les flows et agents disponibles, les ajouter à vos projets, et publier vos propres agents et flows.

Ressources

• Flows de GitLab Duo Agent Platform
• Documentation relative aux flows de base
• Documentation relative aux flows personnalisables
• Configuration d'exécution des flows
• Guide des variables CI/CD de GitLab
• Comptes de service

Article suivant : Partie 5 : découvrir le catalogue d'IA

Article précédent : Partie 3 : comprendre les agents

Les changements apportés

Conseils améliorés pour les tests

Nous mettons davantage l'accent sur les environnements de test locaux pour protéger à la fois les chercheurs et notre infrastructure de production. Nous recommandons fortement les tests locaux avec le GitLab Development Kit (GDK) pour la plupart des recherches en sécurité. Le GDK vous donne accès à des fonctionnalités de pointe avant leur publication et vous permet d'expérimenter sans devoir vous préoccuper de l'infrastructure de production.

Si vous devez démontrer l'impact d'une attaque par déni de service (DoS), nous vous recommandons de le tester sur une instance GitLab auto-gérée avec des spécifications et des ressources égales ou supérieures aux exigences d'installation des instances GitLab auto-gérées.

Pour les vulnérabilités qui requièrent l'architecture de production de GitLab.com, vous devez utiliser des comptes de test créés avec votre alias de courrier électronique HackerOne : yourhandle@wearehackerone.com.

Portée affinée pour une meilleure concentration

Nous avons clarifié plusieurs domaines de portée en fonction des retours de la communauté :

Les attaques par DoS sortent du champ d'application : des exceptions peuvent être envisagées pour les vulnérabilités DoS au niveau de l'application qui entraînent une interruption totale persistante du service et peuvent être exécutées via des points de terminaison non authentifiés (exemples : ReDoS, bombes logiques, etc.).

Injection de prompt : l'injection de prompt autonome sort du champ d'application, mais peut être admise si elle sert de vecteur initial pour causer un préjudice au-delà de sa limite de sécurité.

Métadonnées et énumération : la collecte générale d'informations sort du champ d'application, tandis que les violations de confidentialité exposant des données confidentielles tombent dans le champ d'application. Nous avons fourni de nouveaux exemples détaillés qui distinguent ces deux types de problèmes sur la page des politiques du programme.

Période de transition pour les chercheurs

Nous sommes conscients que les changements de politique peuvent créer de l'incertitude pour les chercheurs qui mènent des enquêtes actives. Pour préserver la confiance pendant cette transition et éviter d'interférer avec les importantes recherches déjà en cours :

• GitLab offre un délai de grâce de 7 jours pour les rapports DoS soumis avant le 22 janvier 2026 à 21 h 00, heure du Pacifique (23 janvier 2026 à 6 h 00, heure française). Les rapports soumis avant cette date seront évalués selon notre politique précédente.

Votre investissement dans la sécurité de GitLab nous tient à cœur, et nous nous engageons à honorer la politique dans le cadre de laquelle vous avez commencé votre recherche.

Notre engagement envers la communauté

Ces changements reflètent notre engagement profond envers la communauté des chercheurs à travers trois principes clés.

1. Nous mettons l'accent sur la transparence en établissant des limites plus claires et des critères objectifs qui réduisent l'ambiguïté et préviennent les différends.

2. Nous renforçons la sécurité grâce à des conseils améliorés sur la plateforme de test qui protègent à la fois les systèmes de production et les chercheurs contre les interruptions accidentelles de service.

3. Nous assurons l'équité grâce à des normes d'évaluation cohérentes et à des dispositions qui garantissent un traitement équitable pour tous les chercheurs, y compris ceux qui participent déjà au programme.

Les ajustements apportés à la portée contribuent également à la durabilité du programme, car ils concentrent les ressources sur les problèmes de sécurité à fort impact et maintiennent une couverture large.

Lancez-vous

Envie de contribuer à la sécurité de GitLab ?

• Nouveaux chercheurs : visitez notre page consacrée au programme HackerOne.
• Configurer des tests locaux : téléchargez le GitLab Development Kit.
• Examiner les politiques : consultez notre documentation complète pour obtenir des directives détaillées.
• Comprendre l'évaluation de la gravité : explorez notre calculateur CVSS.

Nous remercions la communauté des chercheurs dont l'engagement continu aide à maintenir la sécurité de GitLab. Votre expertise et votre dévouement font une réelle différence pour des millions d'utilisateurs dans le monde.

Des questions sur ces changements ? Contactez notre équipe en créant un ticket dans notre projet de questions HackerOne sur GitLab.

🎯 Essayez GitLab Duo Agent Platform dès aujourd'hui !

Qu'est-ce qu'un agent ?

Les agents sont des partenaires de collaboration d'IA spécialisés au sein de GitLab Duo Agent Platform. Chaque type d'agent remplit des objectifs différents et s'exécute dans des contextes différents.

Types d'agents

Agents de base

Conçus et maintenus par GitLab, ces agents sont disponibles immédiatement sans aucune configuration requise.

La disponibilité des agents de base peut être gérée par les propriétaires d'espaces de nommage ou les administrateurs d'instance.

Commencez à interagir avec les agents de base en ouvrant GitLab Duo Agentic Chat dans l'IDE ou l'interface utilisateur Web.

L'agent GitLab Duo

Il s'agit de l'agent par défaut, votre partenaire de collaboration de développement polyvalent pour créer et modifier du code, ouvrir des merge requests, trier et mettre à jour des tickets et epics, et exécuter des workflows avec un contexte complet de la plateforme SDLC.

Exemples de prompts :

• « Explique-moi comment fonctionne le système d'authentification. »
• « Où se trouve la logique du profil utilisateur ? »
• « Comment dois-je implémenter la fonctionnalité X ? »

L'agent Planner

Il aide à la planification produit, à la décomposition des epics et à la création de tickets structurés.

Exemples de prompts :

• « Crée un epic pour le nouveau système de paiement avec des sous-tâches. »
• « Décompose le ticket #789 en tâches plus petites. »
• « Génère des critères d'acceptation pour cette fonctionnalité. »

En savoir plus sur l'agent Planner Agent.

L'agent Security Analyst

Il trie les vulnérabilités, identifie les faux positifs et hiérarchise les risques de sécurité.

Exemples de prompts :

• « Trie toutes les vulnérabilités détectées lors du dernier scan. »
• « Quels résultats SAST sont des faux positifs ? »
• « Hiérarchise les problèmes de sécurité en fonction du risque réel. »

En savoir plus sur l'agent Security Analyst Agent.

L'agent Data Analyst

ll interroge, visualise et met en évidence les données à travers la plateforme de GitLab en utilisant GitLab Query Language (GLQL) pour fournir des informations exploitables sur vos projets et équipes.

Exemples de prompts :

• « Combien de merge requests ont été créées au cours du dernier trimestre ? »
• « Montre-moi sur quoi chaque membre de l'équipe a travaillé ce mois-ci. »
• « Quelles sont les tendances en matière de délais de résolution des tickets ? »
• « Trouve tous les tickets ouverts avec le label 'bug' dans mon projet. »
• « Génère une requête GLQL pour compter les merge requests par auteur. »

En savoir plus sur l'agent Data Analyst Agent.

Les agents personnalisables

Créez vos propres agents adaptés aux workflows et standards spécifiques de votre équipe.

Cas d'usage courants

• Agent chargé du dépannage et du débogage : il débogue les bogues logiciels et les régressions, et analyse les échecs de déploiement.
• Agent chargé de la documentation : il maintient la documentation conformément à vos conventions.
• Assistant chargé de l'intégration des équipes : il aide les nouveaux membres de l'équipe à se familiariser avec les pratiques spécifiques à l'entreprise.
• Moniteur de conformité : il veille au respect des exigences réglementaires.
• Agent d'assistance localisé : il trie les tickets d'assistance dans une langue localisée, par exemple le français.

Regardez l'enregistrement de la présentation des cas d'utilisation de la plateforme Duo Agent lors du GitLab DACH Roadshow Vienna 2025 :

🎯 Essayez maintenant : démo interactive des agents personnalisables. Explorez comment créer et configurer des agents personnalisés.

Comment créer un agent personnalisé ?

Les agents personnalisés sont configurés via les paramètres de votre projet ou de votre groupe. Le composant clé est le prompt système, qui définit le comportement et l'expertise de votre agent.

Exemple de prompt système de l'agent personnalisé devops-debug-failures-agent :

You are an expert in Dev, Ops, DevOps, and SRE, and can debug code and runtime failures.

Your speciality is that you can correlate static SDLC data with runtime data from CI/CD pipelines, logs, and other tool calls necessary.

Expect that the user has advanced knowledge, but always provide commands and steps to reproduce your analysis so they can learn from you.

Start with a short summary and suggested actions, and then go into detail with thoughts, analysis, suggestions.

Think creative and consider unknown unknowns in your debug journey.

Options de visibilité :

• Privé : il est visible uniquement par les membres du projet de gestion (rôle Developeur et niveau supérieur). Ne peut pas être activé dans d'autres projets.
• Public : il peut être visible par tous et activable dans tout projet répondant aux prérequis. Il apparaît dans le catalogue d'IA.
  

Guide de configuration complet disponible dans la documentation.

Bonnes pratiques

Conseils pour le prompt système :

• Soyez précis sur le rôle et les responsabilités de l'agent.
• Définissez des standards de qualité et des contraintes clairs.
• Incluez des exemples de résultats attendus.
• Gardez les prompts concentrés sur une tâche principale.

Commencez progressivement :

• Commencez par des autorisations en lecture seule.
• Testez minutieusement avant d'accorder un accès en écriture.
• Recueillez les retours de l'équipe et itérez.

Les agents externes

Les agents externes s'exécutent en arrière-plan sur la plateforme GitLab lorsqu'ils sont déclenchés par des mentions (par exemple, @ai-codex) ou des assignations dans des tickets et des merge requests. Contrairement aux agents de base et aux agents personnalisables qui fonctionnent de manière interactive dans le chat, les agents externes s'exécutent de manière asynchrone, permettant une automatisation puissante avec des fournisseurs d'IA spécialisés.

Gestion des identifiants : à partir de la disponibilité générale de GitLab Duo Agent Platform, les identifiants de connexion gérés par GitLab seront utilisés pour prendre en charge les agents externes, évitant aux clients d'avoir à gérer et faire pivoter eux-mêmes les clés API.

Quand utiliser les agents externes ?

• Vous avez besoin d'un comportement d'IA agentique spécifique ou de LLM pour des tâches spécialisées.
• Vous souhaitez une automatisation déclenchée par des événements (et non un chat interactif).
• Vous devez respecter des exigences spécifiques en matière de conformité ou de résidence des données.

Pourquoi utiliser les agents externes ?

• Exploiter des modèles d'IA spécialisés : accédez à des fonctionnalités spécifiques à certains fournisseurs comme l'analyse de code de Claude Code ou la délégation de tâches d'OpenAI Codex.
• Respecter les exigences de conformité : conservez les données auprès de fournisseurs d'IA approuvés pour respecter les politiques réglementaires ou de sécurité.
• Tester différents fournisseurs : testez différents comportements d'IA agentique et de LLM afin de trouver celui qui convient le mieux à vos workflows.
• Accéder à des fonctionnalités uniques : utilisez des outils spécifiques à certains fournisseurs comme l'analyse de code de Claude Code ou la délégation de tâches d'OpenAI Codex.

Exemple concret

Une équipe de développement utilise OpenAI Codex comme agent externe pour la revue de code. Lorsque les développeurs créent des merge requests, ils assignent Codex comme relecteur. L'agent :

1. Analyse les modifications apportées au code dans la merge request.
2. Vérifie les bonnes pratiques et les problèmes de qualité du code.
3. Suggère des améliorations et des optimisations.
4. Publie des commentaires de revue détaillés avec des recommandations spécifiques.
5. Fournit des liens vers la documentation pertinente.

Tout cela se produit automatiquement en arrière-plan pendant que le développeur continue à travailler, avec les résultats publiés directement dans la merge request.

Agents externes pris en charge

Les intégrations suivantes ont été testées et sont disponibles :

• Anthropic Claude : génération, revue et analyse de code
• OpenAI Codex : assistance au code alimentée par GPT

Exemple d'utilisation :

@ai-codex Please implement this issue

Cela déclenche un job d'exécution de runner qui exécute l'outil IA externe et publie les résultats dans GitLab.

Configuration des agents externes

Pour obtenir des instructions de configuration complètes incluant les comptes de service, les déclencheurs et des exemples de configuration, consultez notre documentation sur les agents externes.

Personnalisation du comportement des agents avec AGENTS.md

Personnalisez le comportement des agents à l'aide des fichiers AGENTS.md suivant le standard agents.md. Pour en savoir plus, consultez la Partie 8 : personnalisation de GitLab Duo Agent Platform : règles de chat, prompts et workflows.

Choisir le type d'agent le mieux adapté à vos cas d'usage

Résumé

GitLab Duo Agent Platform offre les types d'agents suivants :

• Agent de base : des agents prêts à l'emploi pour les tâches courantes (Chat, Planner, Security Analyst, Data Analyst)
• Agent personnalisable : des agents spécifiques à l'équipe qui peuvent être créés avec des prompts et comportements personnalisés
• Agent externe : des agents intégrés avec des outils IA externes

Commencez avec les agents de base, créez des agents personnalisés pour répondre aux besoins spécifiques de votre équipe et explorez les agents externes lorsque vous avez besoin de fournisseurs d'IA spécialisés.

Article suivant : Partie 4 : comprendre les flows

Article précédent : Partie 2 : démarrer avec GitLab Duo Agentic Chat

Qu'est-ce que GitLab Duo Agentic Chat ?

GitLab Duo Agentic Chat est votre interface principale où vous pouvez interagir avec des agents d'IA tout au long de votre workflow de développement. Contrairement aux chatbots classiques de type questions-réponses qui se contentent de répondre à des requêtes, GitLab Duo Agentic Chat est un partenaire de collaboration d'IA autonome capable d'agir en votre nom : il peut créer et modifier du code, ouvrir des merge requests, trier et mettre à jour des tickets/epics et exécuter des workflows avec un contexte complet de la plateforme SDLC, le tout en vous informant à chaque étape.

🎯 Essayez GitLab Duo Agent Platform dès aujourd'hui !

Capacités clés :

• Opérations sur le code : création de fichiers, modification de code, ouverture de merge requests.
• Analyse de projet : consultation des tickets, epics, merge requests, commits Git, pipelines CI/CD, analyses (GLQL) et scans de sécurité.
• Tâches opérationnelles : hiérarchisation, mise à jour ou création de tickets et d'epics, résolution des vulnérabilités, génération de documentation et de tests, correction des pipelines CI/CD en échec.
• Conscience du contexte : mémorisation de l'historique des conversations, compréhension de l'architecture du projet, recherche dans le code source, le wiki et la documentation de GitLab.
• Extensibilité : intégration avec des services externes via Model Context Protocol (MCP).
• Prise en charge de plusieurs agents : utilisation d'agents spécialisés pour différentes tâches.

🎯 Découvrez une démo interactive de GitLab Duo Agentic Chat et explorez l'interface de chat ainsi que ses fonctionnalités.

Accéder à GitLab Duo Agentic Chat

Fonctionnalités du panneau de l'interface utilisateur Web

• Panneau réduit : icône visible dans le coin supérieur droit
• Panneau ouvert : barre latérale déployée (~400px de largeur)
• Panneau maximisé : extension pour afficher des réponses détaillées

Sélection du modèle

Les grands modèles de langage (LLM) excellent dans différentes tâches et exigences en matière de connaissances. Choisissez le modèle approprié en fonction de vos besoins.

Niveaux de configuration

• Niveau du groupe : défini par le propriétaire du groupe, s'applique à tous les utilisateurs
• Niveau de l'utilisateur : contrôle individuel lorsque le groupe l'autorise

Sélection de l'agent

Les agents sont des partenaires de collaboration d'IA spécialisés dans des tâches spécifiques. Basculez entre les agents selon vos besoins :

Sélection de l'agent

Comment changer d'agent

1. Ouvrez GitLab Duo Agentic Chat.
2. IDE : cliquez sur le menu déroulant de l'agent (sous l'onglet de sélection du modèle).
3. Interface Web : ouvrez un nouveau chat.
4. Sélectionnez l'agent dont vous avez besoin.

Cas d'utilisation courants

Gestion et hiérarchisation des tickets

Pour la gestion des tickets et les workflows de planification, utilisez l'agent Planner, un agent spécialisé conçu pour les tâches de gestion de produit.

Exemples de prompts :

• « Répertorie tous les tickets ouverts avec les labels “bogue” et “priorité élevée” créés au cours des 30 derniers jours. »
• « Crée un ticket pour l'implémentation de l'authentification utilisateur avec OAuth2, inclus les critères d'acceptation et les exigences techniques. »
• « Analyse le ticket #456 et suggère des tickets connexes qui pourraient avoir la même cause profonde. »
• « Décompose l'epic #123 en tâches plus petites et indique une estimation de la complexité. »

Analyse et résolution des vulnérabilités

Pour les workflows de sécurité, utilisez l'agent Security Analyst, un agent spécialisé conçu pour la gestion et la résolution des vulnérabilités.

Exemples de prompts :

• « Montre-moi toutes les vulnérabilités critiques dans le dernier scan de pipeline. »
• « Classe toutes les vulnérabilités du dernier scan de sécurité et identifie lesquelles sont des faux positifs. »
• « Explique la vulnérabilité #789 en termes simples et montre-moi où elle se situe dans le code. »
• « Quelle est la correction recommandée pour la vulnérabilité d'injection SQL dans le point d'entrée de recherche utilisateur ? »
• « Crée une merge request pour corriger la vulnérabilité XSS trouvée dans src/components/UserProfile.vue. »

Compréhension et documentation du code

Obtenez des réponses sur votre code source sans avoir à rechercher manuellement dans les fichiers avec l'agent GitLab Duo.

Exemples de prompts :

• « Comment fonctionne le flux d'authentification dans cette application ? »
• « Trouve tous les endroits où la fonction sendEmail est appelée. »
• « Explique ce que fait la méthode calculateDiscount dans src/pricing/calculator.ts. »
• « Génère la documentation pour les points de terminaison API dans src/api/routes/. »
• « Quels design patterns sont utilisés dans le répertoire src/services/ ? »

Intégration à un nouveau projet

Mettez-vous rapidement à la page en cas de nouveau projet afin de comprendre son architecture, sa configuration et ses dépendances avec l'agent GitLab Duo.

Exemples de prompts :

• « Donne-moi un aperçu de l'architecture de ce projet et de ses composants principaux. »
• « Où est défini le schéma de base de données ? »
• « Comment configurer mon environnement de développement local ? »
• « Quelles sont les dépendances principales et à quoi servent-elles ? »

Débogage et dépannage de pipeline

Identifiez et résolvez rapidement les problèmes dans votre code et vos pipelines CI/CD grâce à l'analyse assistée par l'IA avec l'agent GitLab Duo.

Exemples de prompts :

• « Pourquoi le pipeline CI/CD échoue-t-il à l'étape de test ? »
• « Analyse les logs d'erreur du job #12345 et suggère des corrections. »
• « Pourquoi le pipeline #9876 a-t-il échoué ? Montre-moi les logs d'erreur du job de déploiement qui a échoué. »
• « L'application plante lors du traitement de fichiers volumineux. Aide-moi à déboguer cela. »
• « Examine les commits récents qui pourraient avoir causé la régression de performance. »
• « Comment puis-je optimiser le temps de build de ce pipeline ? »
• « Crée un nouveau job CI/CD pour exécuter des scans de sécurité sur chaque merge request. »

Revue de code et amélioration de la qualité

Bénéficiez d'une assistance d'IA durant les revues de code pour détecter les problèmes et améliorer la qualité du code avec un agent personnalisé entraîné sur les standards de codage et les bonnes pratiques de votre équipe.

Exemples de prompts :

• « Examine la merge request !234 pour détecter les bogues potentiels et les problèmes de sécurité. »
• « Suggère des optimisations de performance pour les requêtes de base de données dans cette merge request. »
• « Vérifie si la merge request !456 respecte nos standards de codage et nos bonnes pratiques. »
• « Identifie tout problème d'accessibilité dans les nouveaux composants d'interface. »

Implémentation de fonctionnalités

Accélérez le développement en générant du code, des tests et de la documentation avec l'agent GitLab Duo.

Exemples de prompts :

• « Crée un point de terminaison d'API REST pour l'inscription utilisateur avec validation. »
• « Génère des tests unitaires pour la classe OrderService avec une couverture de 80 %. »
• « Implémente la pagination pour la page de liste des produits. »
• « Ajoute la gestion d'erreurs et la journalisation à la fonctionnalité de téléchargement de fichiers. »

Refactorisation et amélioration du code

Modernisez et améliorez le code existant avec les conseils de l'IA en utilisant l'agent GitLab Duo.

Exemples de prompts :

• « Refactorise UserController en fonction des principes SOLID. »
• « Convertis ce fichier JavaScript en TypeScript avec des définitions de types appropriées. »
• « Suggère des améliorations pour faciliter le test de cette fonction. »
• « Identifie la duplication de code dans le répertoire src/utils/ et suggère comment la consolider. »
• « Modernise le projet de Java 8 vers Java 21. Suis les recommandations de l'epic 188. »
• « Crée un plan de migration pour moderniser le code mainframe COBOL, et évalue Java/Python. »

Dépannage

Des conseils de dépannage supplémentaires sont disponibles dans notre documentation.

Perspectives

GitLab Duo Agentic Chat est disponible dans les IDE et l'interface utilisateur de GitLab. Les prochaines versions fourniront la prise en charge du terminal avec GitLab Duo CLI, qui est actuellement en développement. Suivez l'epic produit pour obtenir plus d'informations.

Maintenant que vous avez découvert GitLab Duo Agentic Chat, explorez les différents types d'agents et apprenez à créer des agents personnalisés dans la Partie 3 : comprendre les agents. Découvrez les agents de base, créez des agents personnalisés pour votre équipe et intégrez des agents externes comme Claude Code et OpenAI Codex.

Ressources

• Documentation concernant GitLab Duo Agentic Chat
• Documentation concernant GitLab Duo Agent Platform

Article suivant : Partie 3 : comprendre les agents

Article précédent : Partie 1 : démarrer avec GitLab Duo Agent Platform

GitLab Duo Agent Platform représente un changement fondamental dans la façon dont les développeurs interagissent avec l'IA au cours du cycle de vie du développement logiciel. Axé non plus seulement sur le code et s'appuyant sur le contexte complet du SDLC, GitLab Duo Agent Platform permet à plusieurs agents d'IA spécialisés de travailler aux côtés de votre équipe, en gérant des tâches complexes de manière asynchrone tandis que vous vous concentrez sur l'innovation et la résolution de problèmes.

GitLab Duo Agent Platform transforme les workflows de développement linéaires traditionnels en systèmes de collaboration multi-agents dynamiques.

Qu'est-ce que GitLab Duo Agent Platform ?

GitLab Duo Agent Platform est une couche d'orchestration d'IA qui permet :

• La collaboration asynchrone entre les développeurs et les agents d'IA spécialisés
• Un contexte SDLC complet qui couvre le code, les tickets, les epics, les merge requests, les pipelines CI/CD, les wikis, les analyses et les scans de sécurité
• Des flows multi-agents où de nombreux agents collaborent en parallèle sur des tâches complexes
• Une automatisation intelligente qui comprend les normes, les pratiques et les exigences de conformité de votre organisation

Il s'agit d'assistants d'IA pour votre équipe qui peuvent prendre en charge des workflows entiers, car ils comprennent les exigences et créent des merge requests, tandis que vous maintenez une visibilité et un contrôle complets.

🧠 Essayez GitLab Duo Agent Platform dès aujourd'hui !

Architecture de GitLab Duo Agent Platform

GitLab Duo Agent Platform se compose de plusieurs composants interconnectés qui travaillent ensemble pour fournir une assistance d'IA complète. Le diagramme ci-dessous montre les méthodes d'interaction de l'utilisateur avec GitLab Duo Agent Platform. Il illustre les quatre façons dont les utilisateurs peuvent interagir avec les agents :

Comment les équipes interagissent avec GitLab Duo Agent Platform

Quatre façons d'utiliser les agents

1. GitLab Duo Agentic Chat : ouvrez le panneau de chat dans l'interface GitLab ou votre IDE pour engager des conversations interactives avec les agents fondamentaux et personnalisés. Sélectionnez parmi les modèles IA disponibles et obtenez une aide en temps réel.
2. Déclencher des flows personnalisés : mentionnez les flows dans les commentaires de tickets ou de merge requests, ou assignez des relecteurs pour déclencher automatiquement les flows personnalisés. Ceux-ci s'exécutent de manière asynchrone via l'exécution du runner.
3. Déclencher des flows par défaut : construits et maintenus par GitLab, notamment le flow Déveloper (développeur), le flow Code Review (revue de code), le flow Fix CI/CD Pipeline (correction de pipelines CI/CD), le flow Convert Jenkins to GitLab CI/CD (conversion de fichiers Jenkins en GitLab CI/CD), et le flow Software Development (développement logiciel).
4. Déclencher des agents externes : assignez ou mentionnez des agents d'IA externes (comme Claude Code ou OpenAI Codex) dans les commentaires de tickets ou de merge requests pour les déclencher automatiquement. Ceux-ci s'exécutent de manière asynchrone via l'exécution du runner.

Gestion et découverte

• Catalogue d'IA : parcourez, créez et partagez des agents et des flows dans votre organisation. Découvrez les agents et les flows créés par GitLab et votre équipe, puis ajoutez-les à vos projets. Vous pouvez également créer et publier vos propres agents et flows personnalisés et les mettre à disposition.
• Fonctionnalités d'automatisation : votre hub central où vous pouvez tout gérer. Affichez et gérez vos agents, configurez et surveillez les flows, examinez toutes les activités dans les sessions (y compris l'état du pipeline), et configurez des déclencheurs pour l'automatisation basée sur les événements.

Explorons brièvement chaque composant (nous les approfondirons dans les articles ultérieurs) :

GitLab Duo Agentic Chat

Votre interface principale pour interagir avec les agents. Disponible en tant que panneau persistant dans l'interface GitLab et dans votre IDE. Pour en savoir plus, consultez l'article Partie 2 : démarrer avec GitLab Duo Agentic Chat.

Agents

Les agents sont des assistants spécialisés alimentés par l'IA conçus pour gérer des tâches spécifiques tout au long de votre workflow de développement. Considérez-les comme des membres de votre équipe avec une expertise et des capacités uniques.

À propos des agents externes

Les agents externes s'exécutent en arrière-plan sur le calcul de la plateforme GitLab lorsqu'ils sont déclenchés par des mentions (par exemple, @ai-codex) ou des assignations dans les tickets et les merge requests. Contrairement aux agents par défaut et personnalisables qui utilisent des boucles de rétroaction synchrones, les agents externes s'exécutent de manière asynchrone, ce qui entraîne une automatisation puissante avec des fournisseurs IA spécialisés.

Les forces des agents

• Prompts spécialisés : chaque agent possède un prompt système unique qui définit son expertise, son comportement et son style de communication.
• Accès aux outils : les agents peuvent lire des fichiers, accéder aux tickets/merge requests/epics, rechercher du code, analyser les logs des tâches CI/CD et les rapports de vulnérabilité, et bien plus en fonction de leur configuration.
• Contexte du projet : ils ont accès aux tickets, merge requests, code, pipelines CI/CD et vulnérabilités de sécurité.

Pour plus d'informations, consultez la Partie 3 : comprendre les agents. Découvrez comment créer des agents personnalisés, intégrer des fournisseurs d'IA externes et configurer les prompts et les outils des agents pour les besoins spécifiques de votre équipe.

Flows

Les flows sont des workflows multi-étapes qui combinent plusieurs actions pour résoudre des problèmes complexes. Contrairement aux agents qui répondent à des questions, les flows exécutent des workflows complets de manière autonome via l'exécution du runner.

Les forces des flows

• Exécution multi-étapes : ils combinent plusieurs opérations en un seul workflow.
• Traitement asynchrone : ils s'exécutent en arrière-plan tandis que vous continuez à travailler.
• Accès complet au pipeline : ils s'exécutent via l'exécution du runner avec un contexte de projet complet.
• Déclenchement en fonction d'événements : ils sont déclenchés automatiquement en fonction d'événements GitLab

Pour plus d'informations, consultez la Partie 4 : comprendre les flows, y compris les workflows multi-agents.

Agents vs flows : quelle est la différence ?

Comprendre quand utiliser un agent plutôt qu'un flow est essentiel pour travailler efficacement avec GitLab Duo Agent Platform.

Guide de décision rapide

• Vous travaillez de manière interactive ou souhaitez des commentaires instantanés ? → Utilisez le chat
• Vous avez besoin d'automatisation en arrière-plan, de revues de merge requests ou de tâches complexes dans plusieurs fichiers ? → Utilisez les flows

Point essentiel

Les agents et les flows peuvent tous deux prendre des mesures et créer du code. La principale différence est la façon dont ils interagissent et s'exécutent : les agents communiquent de manière interactive dans votre interface de chat, tandis que les flows s'exécutent de manière asynchrone en arrière-plan sur le calcul de la plateforme.

Catalogue d'IA

Une bibliothèque centralisée où vous pouvez parcourir, découvrir, créer et partager des agents et des flows dans votre organisation. Vous retrouverez plus d'informations à ce sujet dans la Partie 5 : découvrir le catalogue d'IA.

Capacités d'automatisation

Votre hub pour gérer les workflows d'agents et de flows :

• Agents : affichez et gérez les agents de votre projet. Plus d'informations dans la Partie 3.
• Flows : affichez, créez et gérez les flows de votre projet. Plus d'informations dans la Partie 4.
• Sessions : logs d'activité des agents
• Déclencheurs : gestion de l'automatisation basée sur les événements pour les flows de votre projet

Comprendre les sessions

Chaque exécution d'agent et de flows crée une session qui enregistre les activités agentiques. Les sessions fournissent une transparence complète sur les événements, y compris le raisonnement de l'agent, les détails d'exécution, l'appel d'outils, les résultats et le suivi complet des décisions.

Pour afficher les sessions, accédez à votre projet > Automatiser > Sessions. Vous pourrez ensuite accéder à la console du pipeline pour voir les logs d'exécution détaillés.

Sélection du modèle

L'une des puissantes fonctionnalités de GitLab Duo Agent Platform est la capacité à choisir le modèle IA qui alimente votre conversation.

Disponible dans : GitLab 18.4 et versions ultérieures

Comment sélectionner le modèle :

1. Ouvrez GitLab Duo Agentic Chat.
2. Recherchez la liste déroulante des modèles.
3. Cliquez pour voir les modèles disponibles.
4. Sélectionnez le modèle qui convient le mieux à votre tâche.

Remarque : la sélection du modèle est actuellement disponible uniquement dans l'interface web. L'intégration IDE utilise le modèle par défaut sélectionné pour votre groupe.

Votre première interaction avec un agent

Découvrons une simple première interaction avec GitLab Duo Agentic Chat :

Exemple 1 : comprendre votre projet (agent)

Scénario : vous venez de rejoindre un projet et vous devez comprendre sa structure et son architecture.

Étapes :

1. Ouvrez le panneau GitLab Duo Chat (cliquez sur l'icône Duo en haut à droite).
2. Assurez-vous que le mode Agentique (version bêta) est activé.
3. Sélectionnez l'agent GitLab Duo (par défaut).
4. Saisissez : « Donne-moi un aperçu de l'architecture de ce projet ».
5. Appuyez sur Entrée.

Ce qui se passe :

L'agent :

• Analyse la structure de votre dépôt
• Examine votre README, l'organisation du code et la documentation
• Fournit un aperçu complet avec les composants clés

Vous pouvez poser des questions de suivi pour clarifier.

Exemple 2 : une merge request (flow)

Scénario : vous avez un ticket qui doit être résolu avec des modifications de code.

Étapes :

1. Ouvrez le ticket dans GitLab.
2. Cliquez sur le bouton Générer une MR avec Duo.
3. Une session d'agent démarre.
4. En quelques minutes, une merge request (MR) est créée avec :
   • Des modifications de code dans plusieurs fichiers
   • Un message de validation descriptif
   • Une explication des modifications dans la description de la merge request

Ce qui se passe :

Le flow Developer :

• Analyse le ticket
• Comprend la structure du dépôt, les modèles de conception et le contexte SDLC
• Effectue les modifications de code appropriées
• Ouvre une MR prête à être examinée

Questions fréquemment posées

Q : Mes conversations avec les agents sont-elles privées ?

R : Oui. Les conversations suivent les modèles de confidentialité et de sécurité standard de GitLab. En savoir plus.

Q : Puis-je utiliser GitLab Duo Agent Platform avec des modèles auto-hébergés ?

R : Oui. Cette approche requiert une configuration supplémentaire à partir de GitLab 18.8. Voir la documentation GitLab.

Perspectives

Maintenant que vous avez compris les bases de GitLab Duo Agent Platform, vous êtes prêt à approfondir chaque composant :

• Partie 2 : démarrer avec GitLab Duo Agentic Chat. Maîtrisez le panneau de chat persistant, découvrez les stratégies pour sélectionner un modèle, comprenez comment changer d'agent et utilisez le chat efficacement dans l'interface utilisateur web et tous les IDE pris en charge.
• Partie 3 : comprendre les agents. Explorez les agents par défaut construits par GitLab, créez des agents personnalisés avec des prompts spécialisés pour les workflows de votre équipe et intégrez les agents CLI externes de fournisseurs comme Claude Code et OpenAI Codex.
• Partie 4 : comprendre les flows. Découvrez comment les flows orchestrent plusieurs agents pour résoudre des problèmes complexes, créez des workflows personnalisés définis en YAML et exploitez les fournisseurs d'IA externes pour l'exécution de pipeline automatisée.
• Partie 5 : découvrir le catalogue d'IA. Parcourez le dépôt centralisé pour découvrir les agents et les flows créés par GitLab et la communauté, ajoutez-les à vos projets et publiez vos propres solutions pour que d'autres les utilisent.
• Partie 6 : surveiller, gérer et automatiser les workflows d'IA. Surveillez toutes les activités d'agents et de flows via les sessions, configurez les déclencheurs basés sur les événements pour automatiser les workflows et gérez tout votre écosystème de GitLab Duo Agent Platform à partir d'un seul endroit central.
• Partie 7 : intégrer le Model Context Protocol (MCP). Exploitez les capacités de GitLab Duo sur d'autres systèmes en vous connectant à des outils externes comme Jira, Slack et AWS via la norme MCP ouverte et autorisez les outils d'IA externes à accéder à vos données GitLab.
• Partie 8 : personnaliser GitLab Duo Agent Platform. Configurez des règles de chat personnalisées, créez des prompts système pour les agents, configurez les outils des agents, intégrez des systèmes externes avec MCP et personnalisez les flows en fonction des besoins spécifiques de votre équipe.

Ressources

• Documentation concernant GitLab Duo Agent Platform
• Site de GitLab Duo Agent Platform
• Forum de GitLab

Article suivant : Partie 2 : démarrer avec GitLab Duo Agentic Chat

Les tâches routinières, de la refactorisation de code aux scans de sécurité en passant par la recherche, peuvent être déléguées à des agents d'IA spécialisés. Les équipes peuvent ainsi se concentrer sur la résolution de problèmes complexes et l'innovation.

La plateforme tire parti du rôle de GitLab en tant que plateforme DevSecOps centrale (englobant la gestion du code, les pipelines CI/CD, la gestion des tickets, les résultats des tests, les scans de sécurité, etc.) pour fournir à ces agents un contexte de projet complet et leur permettre de contribuer de manière significative tout en respectant les normes et pratiques de votre équipe.

Ce guide complet en huit parties vous guidera de votre première interaction jusqu'à la mise en place de workflows d'automatisation entièrement personnalisables et prêts pour la production.

Évolution de GitLab Duo Pro/Enterprise vers GitLab Duo Agent Platform

GitLab Duo Agent Platform est une évolution, et n'a pas pour objectif de remplacer GitLab Duo Pro et GitLab Duo Enterprise. Il s'agit d'un sur-ensemble qui s'éloigne des interactions entre un seul développeur et l'IA et privilégie une collaboration entre plusieurs équipes et agents.

• GitLab Duo Pro a amélioré la productivité individuelle des développeurs dans l'IDE avec des suggestions de code alimentées par l'IA et un chat.
• GitLab Duo Enterprise a permis d'offrir des capacités d'IA complètes tout au long du cycle de développement logiciel. Mais il s'agissait encore principalement d'une approche qui facilitait les interactions entre un seul utilisateur et un assistant d'IA, principalement lors d'une session de questions-réponses avec un seul cas d'usage à la fois.
• GitLab Duo Agent Platform relègue les interactions individuelles au second plan et se concentre sur une collaboration entre équipes et agents, où des agents spécialisés gèrent de manière autonome les tâches routinières tout au long du cycle de vie logiciel.

La série complète

Référence des concepts clés

Composants principaux

Terminologie essentielle

Prêt à commencer ?

Commencez par lire l'article Partie 1 : Introduction à GitLab Duo Agent Platform pour découvrir les principes fondamentaux de la plateforme.

Retours

Nous aimerions avoir vos retours ! Vous avez trouvé une erreur ? Vous avez une suggestion ?

• Ouvrir un ticket
• Contribuer
• Échanger

Les outils d'IA ont considérablement amélioré la capacité des équipes de développement à écrire du code, et dans certains cas, les développeurs signalent une productivité multipliée par dix. Malheureusement, puisque seulement environ 20% du temps d'un développeur est consacré à l'écriture de code, l'amélioration de la vélocité d'innovation totale et de la livraison obtenue par l'IA est progressive. C'est ce qu'on appelle souvent le paradoxe de l'IA dans la livraison logicielle.

De plus, pour de nombreuses équipes, l'accélération de la création de code entraîne de nouveaux goulots d'étranglement, notamment un retard important dans la revue de code, des failles de sécurité, des contrôles de conformité et des corrections de bogues en aval.

GitLab Duo Agent Platform résout le paradoxe de l'IA grâce à une orchestration intelligente et une automatisation avec l'IA agentique tout au long du cycle de vie logiciel.

Pour obtenir plus d'informations, visionnez la vidéo et lisez la suite.

💡 Rejoignez GitLab Transcend le 10 février pour découvrir comment l'IA agentique transforme la livraison logicielle. Apprenez des témoignages de nos clients et explorez comment accélérer votre propre parcours de modernisation. Inscrivez-vous dès maintenant.

Nous sommes également ravis d'annoncer que les clients GitLab disposant d'abonnements GitLab Premium et GitLab Ultimate actifs recevront 12 et 24 dollars, respectivement, en GitLab Credits par utilisateur sans frais supplémentaires.* Ces crédits se renouvelleront chaque mois et donneront aux utilisateurs un accès à toutes les fonctionnalités de GitLab Duo Agent Platform.

Voici comment les GitLab Credits fonctionnent : un GitLab Credit est une monnaie virtuelle utilisée pour les produits basés sur l'utilisation de GitLab. L'utilisation de GitLab Duo Agent Platform consommera des crédits disponibles, en commençant par les crédits inclus mentionnés ci-dessus. Les clients peuvent ensuite décider de s'engager dans un pool partagé de crédits pour toute leur organisation, ou les payer mensuellement, à la demande. Pour plus d'informations, veuillez consulter notre article présentant GitLab Credits.

Les clients avec un abonnement GitLab Duo Pro ou GitLab Duo Enterprise sont invités à continuer à utiliser ces produits, ou à migrer vers GitLab Duo Agent Platform à tout moment. La valeur restante du contrat GitLab Duo Enterprise peut être convertie en GitLab Credits à tout moment. Contactez votre représentant GitLab pour en savoir plus.

Voici des cas d'usage et des fonctionnalités intéressants que vous pouvez tester dès aujourd'hui :

Une expérience unifiée pour la collaboration humaine et agentique

GitLab Duo Agent Platform introduit une expérience utilisateur unifiée conçue pour une intégration transparente entre les humains et leurs agents IA dans GitLab. Les développeurs et leurs équipes peuvent utiliser GitLab Duo Agentic Chat sur chaque page ou presque, poser des questions en contexte, suivre les sessions agentiques asynchrones et interagir avec les agents dans les workflows familiers comme les tickets, les merge requests et les activités de pipeline afin d'assurer la transparence des actions d'IA et de faciliter leur intégration dans les tâches quotidiennes.

Agentic Chat : assistance intelligente et contextuelle

Gitlab Duo Agentic Chat apporte un véritable raisonnement multi-étapes dans l'interface Web de GitLab et les IDE, en utilisant le contexte complet du cycle de vie des tickets, des merge requests, des pipelines, des résultats des scans de sécurité, et bien plus. S'appuyant sur GitLab Duo Chat précédemment publié, Agentic Chat peut effectuer des actions en votre nom de manière autonome et vous aider à répondre à des questions complexes de manière plus complète. Il fournit à chaque membre de l'équipe de développement logiciel des conseils précis et contextuels qui aident à améliorer l'intégration, la qualité du code et la vitesse de livraison.

GitLab Duo Agentic Chat prend en charge de nombreux cas d'usage pour permettre la collaboration entre les développeurs et l'IA. Pour plus de détails sur la façon de commencer, veuillez consulter notre guide « Démarrez avec GitLab Duo Agent Platform » et consultez ces suggestions de prompts que nous alimentons régulièrement.

• Analyser : dans l'interface Web, Agentic Chat peut créer des tickets, des epics, des merge requests et fournir des résumés, mettre en évidence des résultats clés et offrir des conseils exploitables basés sur le contexte en temps réel du ticket, de l'epic et de la merge request spécifiques, et de bien d'autres types de contenu. Agentic Chat aide les équipes de développement à comprendre le code, les dépendances, l'architecture et la structure du projet qu'ils ne connaissent pas bien dans l'IDE ou dans un dépôt GitLab.
• Coder : Agentic Chat peut générer du code, des configurations et une Infrastructure as Code à travers un large éventail de langages et de frameworks. Il peut aider à corriger les bogues, moderniser l'architecture et le code, générer des tests et de la documentation pour une intégration plus rapide. Directement à portée de main des développeurs, Agentic Chat est leur partenaire de collaboration dans VS Code, les IDE JetBrains, Cursor et Windsurf, avec des règles optionnelles au niveau de l'utilisateur et du workspace pour adapter les réponses.
• CI/CD : Agentic Chat peut vous aider à mieux comprendre, configurer et dépanner les pipelines existants, ou en créer de nouveaux à partir de zéro.
• Sécuriser : Agentic Chat peut expliquer les vulnérabilités, prioriser les tickets en fonction de leur accessibilité et recommander des corrections pour vous faire gagner du temps.

Agents : des spécialistes qui collaborent à la demande

GitLab Duo Agent Platform permet aux développeurs de déléguer des tâches à des agents spécialisés. La plateforme offre une combinaison unique d'agents de base, personnalisables et externes, tous intégrés de manière transparente dans l'expérience utilisateur GitLab, ce qui facilite le choix de l'agent adapté en fonctiond de la tâche.

Les agents de base sont préconfigurés par les experts GitLab et sont prêts à l'emploi pour gérer les tâches les plus complexes du cycle de livraison logicielle. Les agents de base ci-dessous sont inclus dans le cadre de la disponibilité générale de GitLab Duo Agent Platform, et d'autres sont actuellement en version bêta et seront bientôt disponibles.

• L'agent Planner aide les équipes à structurer, hiérarchiser et décomposer les tâches directement dans GitLab, ce qui rend la planification plus claire, plus rapide et plus facile à mettre en œuvre.
• L'agent Security Analyst examine les vulnérabilités et les signaux de sécurité, explique leur impact en langage clair et aide les équipes à comprendre les tâches à traiter en priorité.

Les agents personnalisables peuvent être créés à l'aide du Catalogue d'IA, un dépôt central où les équipes créent, publient, gèrent et partagent des agents et des flows personnalisés dans toute l'organisation. Les équipes peuvent créer des agents et des flows avec un contexte et des capacités spécifiques pour reproduire la façon dont leur équipe d'ingénierie fonctionne et résoudre les problèmes en utilisant les normes et les garde-fous utilisés par leurs ingénieurs.

Les agents externes sont intégrés de manière transparente dans GitLab et comprennent certains des meilleurs outils d'IA disponibles, notamment Claude Code d'Anthropic et Codex CLI d'OpenAI. Les utilisateurs bénéficient d'un accès natif GitLab à ces outils depuis GitLab pour divers cas d'utilisation, notamment la génération de code, la revue de code et l'analyse avec une sécurité transparente et des abonnements LLM intégrés.

Ensemble, ces approches offrent aux équipes une adoption flexible de l'IA agentique, des agents spécialisés aux automatisations spécifiques à l'organisation en passant par l'intégration d'outils d'IA externes, le tout dans une seule plateforme gouvernée.

Flows : transformez le travail multi-étapes en résultats reproductibles et guidés

Les flows automatisent les tâches complexes avec plusieurs workflows agentiques, du début à la fin.

Notre équipe d'ingénierie a créé plusieurs flows inclus en disponibilité générale, avec d'autres à venir :

• Le flow Developer (Issue to Merge Request) crée une merge request structurée à partir d'un ticket bien défini afin que les équipes puissent commencer à travailler immédiatement.
• Le flow Convert to GitLab CI/CD aide les équipes à migrer ou à moderniser les configurations de pipeline sans réécriture manuelle.
• Le flow Fix CI/CD pipeline analyse les échecs, identifie les causes probables et prépare les modifications recommandées.
• Le flow Code Review analyse les modifications de code, les commentaires des merge requests, et plus encore afin de rationaliser les revues de code avec une analyse et des retours natifs de l'IA.
• Le flow Software development in IDE guide le travail des équipes dans les étapes de développement et de revue quotidiennes.

Client MCP : connectez GitLab Duo Agent Platform aux outils que vos équipes utilisent déjà

Dans les IDE, le Client MCP permet à GitLab Duo Agent Platform de se connecter de manière sécurisée à des systèmes externes comme Jira, Slack, Confluence et d'autres outils compatibles MCP pour extraire le contexte et prendre des mesures dans votre chaîne d'outils DevSecOps.

Au lieu que l'assistance d'IA soit isolée dans des outils individuels, le Client MCP permet à GitLab Duo Agent Platform de comprendre et d'opérer dans les systèmes où la planification, la collaboration et l'exécution se produisent réellement. Cela réduit le changement de contexte manuel et permet des workflows plus complets et de bout en bout alimentés par l'IA qui reflètent la façon dont les équipes travaillent en pratique.

Les fonctionnalités suivantes sont incluses en disponibilité générale :

• Connexion à des systèmes externes compatibles MCP tels que Jira, Confluence, Slack, Playwright et Grafana
• Configuration au niveau du workspace et de l'utilisateur
• Contrôles au niveau du groupe pour activer ou restreindre l'utilisation de MCP
• Flux d'approbation de l'utilisateur pour l'accès aux outils
• Prise en charge dans Agentic Chat dans les extensions IDE

Nous prévoyons d'ajouter d'autres fonctionnalités à la capacité du serveur MCP GitLab, qui est actuellement en version bêta et devrait être en disponibilité générale dans les versions à venir.

Choisissez le bon modèle pour votre équipe et vos charges de travail

GitLab Duo Agent Platform est construit sur une sélection de frameworks flexible qui permet aux équipes d'adapter la plateforme en fonction de leurs besoins en matière de confidentialité, de sécurité et de conformité. GitLab utilise par défaut un LLM optimal pour chaque fonctionnalité, mais les administrateurs ont la possibilité de choisir parmi les modèles pris en charge tels que les variantes OpenAI GPT-5, Mistral, Meta Llama et Anthropic Claude. Les équipes possèdent ainsi un contrôle et une flexibilité plus précis sur le modèle utilisé pour le chat, les tâches de codage et les interactions d'agent pour chaque cas d'usage spécifique, en fonction des normes de leur organisation. Pour une liste complète des modèles pris en charge et des détails sur la configuration de la sélection de modèles, consultez la section sélection d'un modèle de notre documentation.

Gouvernance, visibilité et flexibilité de déploiement

GitLab Duo Agent Platform offre aux organisations le contrôle et la transparence dont elles ont besoin pour adopter l'IA de manière responsable, avec des options de déploiement flexibles qui fonctionnent dans différents environnements.

Les fonctionnalités suivantes sont incluses en disponibilité générale :

• Disponibilité sur toutes les plateformes : GitLab.com, GitLab Self-Managed et GitLab Dedicated dans le cadre du cycle de release GitLab 18.8.
• Gouvernance et visibilité : les équipes peuvent voir comment les agents sont utilisés, quelles actions ils effectuent et comment ils contribuent aux tâches. Les détails d'utilisation et d'activité aident les dirigeants à comprendre l'adoption, à mesurer l'impact et à s'assurer que l'IA est utilisée de manière appropriée. Ces contrôles facilitent le déploiement de l'IA à grande échelle en toute confiance.
• Contrôles d'accès basés sur les groupes : les administrateurs peuvent définir des règles au niveau de l'espace de nommage qui prescrivent quels utilisateurs peuvent accéder aux fonctionnalités de GitLab Duo Agent Platform. Cette approche contribue à une adoption flexible, de l'activation immédiate à l'échelle de l'organisation aux déploiements progressifs. L'intégration du protocole LDAP (Lightweight Directory Access Protocol) et du langage SAML (Security Assertion Markup Language) permet une gouvernance à grande échelle sans configuration manuelle.
• Sélection de modèles et options auto-hébergées : la sélection de LLM est disponible pour toutes les fonctionnalités en disponibilité générale sur GitLab.com, GitLab Self-Managed et GitLab Dedicated. Les propriétaires d'espaces de nommage de niveau supérieur choisissent le modèle, et les sous-groupes héritent automatiquement de ces paramètres. Pour les organisations qui souhaitent davantage de contrôle, la plateforme prend en charge les modèles auto-hébergés pour les déploiements GitLab Self-Managed.

Découvrez une démonstration de GitLab Duo Agent Platform en action :

Maintenez votre instance GitLab à jour

Pour vous assurer de bénéficier des 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 à effectuer votre mise à niveau :

• Outil de chemin d'accès de mise à niveau : indiquez votre version actuelle et consultez les étapes de mise à niveau à suivre pour votre instance.
• Documentation de mise à niveau : guides détaillés pour chaque version prise en charge, y compris les prérequis, les instructions étape par étape et les meilleures pratiques à suivre.

En effectuant des mises à niveau régulières, 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 organisations 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.

* Les clients GitLab disposant d'un abonnement GitLab Premium et GitLab Ultimate actif recevront automatiquement 12 $ et 24 $ de crédits inclus par utilisateur, respectivement, qui seront renouvelés mensuellement. Ces crédits sont disponibles pour une durée limitée et sont susceptibles d'être modifiés (voir les conditions de la promotion).

Cet article de blog contient des déclarations de nature prospective au sens de la Section 27A du Securities Act de 1933, telle que modifiée, et de la Section 21E du Securities Exchange Act de 1934. Bien que nous pensions que les attentes reflétées dans ces déclarations sont raisonnables, elles sont soumises à des risques, incertitudes, hypothèses et autres facteurs connus et inconnus qui peuvent entraîner des résultats ou 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 de blog, sauf si la loi l'exige.

La tarification par siège crée une fracture entre les équipes d'ingénierie qui ont accès à l'IA et celles qui n'y ont pas accès, ce qui est en totale contradiction avec la manière dont l'IA agentique moderne devrait être utilisée tout au long du cycle de développement logiciel.

Aujourd'hui, vous devez acheter un siège pour chaque personne avant qu'elle ne puisse commencer à utiliser l'IA. Bien que cette tarification fonctionne pour les quelques utilisateurs intensifs, elle peut s'avérer trop coûteuse et injuste pour la majorité de l'équipe dont l'utilisation est ponctuelle. C'est pourquoi dans de nombreuses organisations, seule une partie de l'équipe dispose d'un « siège IA ».

Par ailleurs, GitLab Duo Agent Platform diffère de GitLab Duo Pro, de GitLab Duo Enterprise et des autres outils de développement d'IA sur le marché. Les agents et les flows agentiques peuvent être utilisés par votre équipe lorsque celle-ci a besoin d'une assistance IA et déclenchés par des événements SDLC qui s'exécutent en arrière-plan. Avec GitLab Duo Agent Platform, l'IA agentique n'est plus uniquement liée aux sièges utilisateurs.

GitLab Credits, notre nouvelle monnaie virtuelle pour la tarification à l'usage, permet de pallier ces différences d'utilisation, à commencer par GitLab Duo Agent Platform. Chaque membre de votre organisation avec un compte GitLab (Premium ou Ultimate) peut désormais utiliser les fonctionnalités d'IA agentique sans que vous ayez à payer pour un siège IA, que celles-ci soient utilisées directement ou configurées comme agents en arrière-plan.

Fonctionnement de GitLab Credits

Les crédits sont mutualisés dans l'ensemble de votre organisation. GitLab Duo Agent Platform, y compris l'usage synchrone et asynchrone des agents et des flows agentiques, requiert des GitLab Credits.

Les fonctionnalités suivantes consomment des GitLab Credits :

• Les agents de base tels que l'agent GitLab Duo Security Analyst, l'agent GitLab Duo Planner et l'agent GitLab Duo Data Analyst
• Les flows de base tels que le flow « revue de code », le flow flow « développeur » et le flow « correction de pipelines CI/CD »
• Les agents externes tels qu'Anthropic Claude Code et OpenAI Codex
• Les agents et les flows personnalisés que vous créez et publiez dans votre Catalogue d'IA
• Agentic Chat dans l'interface de GitLab et dans l'IDE.

Remarque : les agents externes sont disponibles gratuitement dans la version 18.8 et ne consomment pas de GitLab Credits. Nous présenterons la tarification le mois prochain, lors de la sortie de la version GitLab 18.9. Les flow personnalisés sont actuellement en version bêta et ne consomment pas de GitLab Credits.

Le nombre de crédits utilisés est basé sur le nombre de requêtes agentiques effectuées par les grands modèles de langage (LLM) (plus de détails ici). À mesure que le nombre de LLM disponibles augmentera, nous les certifierons pour une utilisation avec GitLab Duo Agent Platform et les ajouterons à cette liste afin d'offrir aux utilisateurs une vision transparente de leur consommation.

Le nombre total de crédits est calculé à la fin du mois en fonction de l'utilisation réelle. Ce modèle compense également automatiquement l'usage des utilisateurs intensifs par rapport à celui des utilisateurs occasionnels, afin de réduire ainsi efficacement le coût total de l'IA par personne (par rapport au paiement par siège pour chaque personne).

Par souci de simplicité, chaque crédit a un prix catalogue à la demande de 1 $. Vous pouvez utiliser GitLab Duo Agent Platform sans aucun engagement, et l'utilisation est facturée mensuellement (à la fin de chaque mois). Pour les clients Enterprise qui souscrivent à des engagements annuels, nous proposons des remises sur volume pour les crédits mensuels.

Dans le cadre d'une promotion à durée limitée*, tous les clients GitLab avec un abonnement GitLab Premium et GitLab Ultimate actif recevront automatiquement 12 $ et 24 $ de crédits inclus par utilisateur, respectivement. Ces crédits seront renouvelés chaque mois jusqu'à la fin de la période promotionnelle et permettront à votre équipe d'accéder à toutes les fonctionnalités de GitLab Duo Agent Platform sans frais supplémentaires. Lorsque vous acceptez nos conditions de facturation, toute utilisation supérieure à ces crédits inclus sera facturée via des crédits mensuels engagés ou des crédits à la demande.

Gouvernance des coûts avec GitLab Credits

Dimensionnement de GitLab Credits : votre équipe commerciale dispose d'un calculateur de dimensionnement dans le cadre de la disponibilité générale de GitLab Duo Agent Platform, pour estimer le nombre de crédits dont vous aurez besoin chaque mois. Ce calculateur a été conçu avec des modèles d'utilisation que nous avons observés pendant la période bêta. De plus, en tant que client existant ou nouveau client, vous pouvez demander un essai gratuit pour confirmer votre utilisation réelle estimée.

Visibilité de l'utilisation : avec la version 18.8, vous disposez d'informations détaillées sur l'utilisation via deux tableaux de bord complémentaires : un disponible dans le portail clients de GitLab pour les responsables de facturation à des fins de supervision financière, et l'autre intégré au produit pour les administrateurs à des fins de surveillance opérationnelle. Les deux fournissent une attribution de l'utilisation, des répartitions de coûts et des tendances historiques afin que vous sachiez toujours exactement comment vos crédits sont consommés. Si vous suivez une pratique de refacturation interne, vous pourrez utiliser les cumuls au niveau des projets et des groupes pour les allocations de coûts.

Contrôles d'utilisation : vous pouvez activer ou désactiver l'accès à GitLab Duo Agent Platform pour des équipes ou des projets spécifiques afin de garantir que seule l'utilisation approuvée peut être comptabilisée dans vos crédits. Nous prévoyons également d'ajouter des contrôles au niveau utilisateur peu après la disponibilité générale pour vous aider à gérer l'usage des fonctionnalités de GitLab Duo Agent Platform et des crédits.

Notifications automatiques d'utilisation : nous vous tiendrons informé de manière proactive de votre utilisation des crédits via des alertes par e-mail lorsque vous atteindrez 50 %, 80 % et 100 % de vos crédits mensuels engagés, afin que vous ayez le temps d'ajuster votre utilisation, d'acheter des engagements supplémentaires ou de planifier la facturation à la demande.

Mise à niveau de la tarification par siège GitLab Duo Pro/GitLab Enterprise vers GitLab Credits pour GitLab Duo Agent Platform

Si vous avez acheté et utilisez GitLab Duo Pro et GitLab Duo Enterprise, vous pouvez continuer à utiliser ces fonctionnalités comme options prises en charge. Vous pouvez passer à tout moment à GitLab Duo Agent Platform, afin d'utiliser la version « classique » de GitLab Duo, et accéder à de nouvelles fonctionnalités telles que l'Agentic Chat, des agents de base supplémentaires, des agents et des flows personnalisés, des agents externes et plus encore.

Au moment de la mise à niveau, nous transférerons votre investissement dans les sièges de GitLab Duo Pro et GitLab Duo Enterprise vers GitLab Credits pour GitLab Duo Agent Platform. Le montant restant des engagements de sièges sera échangé contre des GitLab Credits mensuels avec des remises basées sur le volume. Les crédits mensuels pourront ensuite être partagés entre tous les membres de votre organisation que vous autorisez, et non plus seulement les utilisateurs qui disposaient de sièges GitLab Duo assignés auparavant.

Comparaison concurrentielle : GitLab Credits vs tarification par siège

Configuration

1. Pour les clients GitLab Premium et GitLab Ultimate existants : avec la disponibilité générale, GitLab Duo Agent Platform sera disponible pour les clients disposant de licences GitLab Premium et GitLab Ultimate actives**. Les clients GitLab.com SaaS y auront accès automatiquement. Les clients GitLab Self-Managed y auront accès lorsqu'ils passeront à la version GitLab 18.8 (avec la disponibilité générale prévue de GitLab Duo Agent Platform). Les clients GitLab Dedicated seront mis à niveau vers GitLab 18.8 pendant leur fenêtre de maintenance programmée en février et pourront alors utiliser GitLab Duo Agent Platform.
2. Activez GitLab Duo : assurez-vous que GitLab Duo Agent Platform est activé dans les paramètres de votre espace de nommage.
3. Commencez à explorer : utilisez vos GitLab Credits mensuels inclus pour essayer les fonctionnalités de GitLab Duo Agent Platform.
4. Au-delà des crédits inclus : vous pourrez accepter GitLab Credits pour une utilisation étendue au-delà des crédits inclus au prix catalogue à la demande. Pour des remises sur volume avec engagement, veuillez nous contacter pour obtenir un devis pour votre niveau d'utilisation spécifique.

Consultez notre documentation pour en savoir plus sur la prise en main de GitLab Duo Agent Platform.

Remarques

* Ces crédits promotionnels inclus sont disponibles pour une durée limitée lors de la disponibilité générale, et peuvent être modifiés à la discrétion de GitLab.

** Exclut GitLab Duo avec Amazon Q et GitLab Dedicated pour les clients gouvernementaux.

Pour en savoir plus sur GitLab Duo Agent Platform et toutes les façons dont l'IA agentique peut transformer le travail de votre équipe, consultez notre page GitLab Duo Agent Platform. Si vous êtes un client GitLab existant, contactez votre gestionnaire de compte GitLab ou votre partenaire pour planifier une démonstration de nos fonctionnalités de plateforme.

FAQ sur GitLab Credits

1. Qu'est-ce que GitLab Credits et pourquoi GitLab les a-t-il introduits ?

GitLab Credits est une nouvelle monnaie virtuelle pour les fonctionnalités GitLab basées sur l'utilisation, à commencer par GitLab Duo Agent Platform. GitLab a introduit ce modèle car la tarification par siège forçait les organisations à rationner l'accès à l'IA au sein des équipes d'ingénierie, et l'utilisation de GitLab Duo Agent Platform n'est pas uniquement liée aux sièges. Les crédits sont mutualisés dans l'ensemble de votre organisation, vous permettant de donner à chaque membre de l'équipe un accès aux fonctionnalités d'IA, ou de configurer des workflows agentiques en arrière-plan, sans nécessiter l'achat de sièges individuels à l'avance.

2. Comment fonctionne la consommation de crédits ?

Les crédits sont déduits en fonction du nombre de requêtes agentiques effectuées, avec des taux différents selon le LLM utilisé. Par exemple, vous obtenez deux requêtes de modèle par crédit pour Claude-sonnet-4.5 (le modèle par défaut pour la plupart des fonctionnalités), et 20 requêtes par crédit pour des modèles comme gpt-5-mini ou claude-3-haiku.

3. Qu'est-ce qui est inclus pour les clients GitLab Premium et GitLab Ultimate existants ?

Dans le cadre d'une promotion à durée limitée, les clients disposant d'abonnements GitLab Premium et GitLab Ultimate actifs reçoivent automatiquement des crédits inclus gratuitement parallèlement à la version de disponibilité générale de GitLab Duo Agent Platform dans GitLab 18.8 :

• 12 $ de crédits par utilisateur par mois pour GitLab Premium
• 24 $ de crédits par utilisateur par mois pour GitLab Ultimate

Les crédits inclus sont au niveau utilisateur, se renouvellent mensuellement et permettent l'accès à toutes les fonctionnalités de GitLab Duo Agent Platform sans frais supplémentaires. Toute utilisation supplémentaire sera facturée séparément. Ces crédits promotionnels inclus sont disponibles pour une durée limitée après la disponibilité générale, et peuvent être modifiés à la discrétion de GitLab.

4. Comment puis-je contrôler et surveiller l'utilisation des crédits ?

GitLab fournit plusieurs outils de gouvernance : tableaux de bord d'utilisation détaillés dans le portail clients et au sein du produit, possibilité d'activer et de désactiver l'accès pour des équipes ou des projets spécifiques, contrôles au niveau utilisateur à venir, et alertes e-mail automatisées à 50 %, 80 % et 100 % des crédits mensuels engagés. Nous prévoyons également de proposer un calculateur de dimensionnement pour estimer vos besoins mensuels en crédits.

5. Comment puis-je commencer à utiliser GitLab Duo Agent Platform ?

Une fois en disponibilité générale, pour les clients GitLab Premium et GitLab Ultimate existants, l'accès est automatique sur GitLab.com SaaS. Les clients Self-Managed obtiennent l'accès lors de la mise à niveau vers GitLab 18.8 avec la disponibilité générale prévue de GitLab Duo Agent Platform. Activez simplement GitLab Duo Agent Platform dans les paramètres de votre espace de nommage et commencez à explorer GitLab Duo Agent Platform en utilisant vos crédits mensuels inclus. Pour une utilisation au-delà des crédits inclus, vous pouvez accepter la facturation à la demande ou contacter GitLab pour des remises sur volume avec engagements annuels.

Cet article 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, incertitudes, hypothèses et autres facteurs connus et inconnus qui peuvent entraîner des résultats ou des issues réels sensiblement différents. Des informations supplémentaires 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 à mettre à jour ou à réviser ces déclarations après la date de cet article de blog, sauf si la loi l'exige.

Pourquoi cette mesure a-t-elle été prise ?

Cette mesure fait partie intégrante de notre engagement envers les principes Secure by Design. L'authentification multifacteur offre une protection essentielle contre les attaques par « credential stuffing » (bourrage d’identifiant) et les tentatives de prise de contrôle de compte, qui restent des menaces persistantes dans le secteur du développement logiciel.

Informations clés à connaître

Qu'est-ce qui change ?

GitLab rend l'authentification multifacteur obligatoire pour les utilisateurs qui s'authentifient avec un nom d'utilisateur et un mot de passe. Cette mesure ajoute une deuxième couche de sécurité essentielle au-delà du simple mot de passe.

Cette mesure s'applique-t-elle à mon compte ?

1. Oui, elle s'applique si : vous vous connectez à GitLab.com avec un nom d'utilisateur et un mot de passe, ou si vous utilisez un mot de passe pour vous authentifier auprès de l'API.
2. Non, elle ne s'applique pas si : vous utilisez exclusivement une connexion via un réseau social (comme Google) ou une authentification unique (SSO) pour accéder à la plateforme. (Veuillez noter que si vous utilisez une authentification unique, mais que vous disposez également d'un mot de passe pour une connexion directe, vous aurez toujours besoin de l'authentification multifacteur pour toute connexion basée sur un mot de passe sans SSO.)

Quel est le calendrier de déploiement ?

1. La mise en œuvre se fera par étapes au cours des prochains mois afin de minimiser les interruptions inattendues et les pertes de productivité pour les utilisateurs, ainsi que de prévenir les blocages de compte. Des groupes d'utilisateurs seront invités à activer l'authentification multifacteur : chaque groupe sera sélectionné en fonction des actions qu'il a entreprises ou du code auquel il a contribué. Vous serez notifié de la manière suivante :
   • ✉️ Notification par e-mail : avant la phase qui vous concerne
   • 🔔 Rappels réguliers dans le produit : 14 jours auparavant
   • ⏱️ Après une période spécifique (qui sera communiquée par e-mail) : accès à GitLab bloqué jusqu'à ce que vous activiez l'authentification multifacteur

Quelle action dois-je entreprendre ?

1. Si vous vous connectez à GitLab.com avec un nom d'utilisateur et un mot de passe :
   • Nous vous recommandons vivement de configurer de manière proactive l'une des méthodes d'authentification multifacteur disponibles dès aujourd'hui (clés d'accès, application d'authentification, appareil WebAuthn, vérification par e-mail) afin de garantir la transition la plus sécurisée et la plus fluide possible :
   • Accédez à vos Paramètres utilisateur sur GitLab.com.
   • Sélectionnez la section Compte.
   • Activez l'authentification à deux facteurs et configurez la méthode de votre choix (par exemple, une application d'authentification ou un appareil WebAuthn).
   • Enregistrez de manière sécurisée vos codes de récupération pour vous assurer de pouvoir configurer à nouveau votre accès si nécessaire.
2. Si vous utilisez un mot de passe pour vous authentifier auprès de l'API :
   • Nous vous recommandons vivement de passer de manière proactive à un jeton d'accès personnel (PAT). Consultez notre documentation pour en savoir plus.

FAQ

Que se passe-t-il si je n'active pas l'authentification multifacteur avant la date limite ?

• Vous serez tenu de configurer l'authentification multifacteur avant de pouvoir vous connecter.

Cela affecte-t-il les pipelines CI/CD ou l'automatisation ?

• Oui, sauf si vous utilisez des jetons d'accès personnels (PAT) ou des jetons de déploiement à la place des mots de passe.

J'utilise l’authentification unique (SSO) mais je me connecte parfois directement, ai-je besoin de l'authentification multifacteur ?

• Oui, l'authentification multifacteur est requise pour toute authentification basée sur un mot de passe, y compris les scénarios de secours.

Un calendrier spécifique et d'autres ressources seront communiqués à l'approche des dates de déploiement. Nous vous remercions d'avance pour votre coopération.

Pourtant, 63 % des professionnels DevSecOps français déclarent que l'IA complexifie la gestion de la conformité, et 78 % estiment que l'IA agentique créera des défis de sécurité sans précédent.

C'est le paradoxe de l'IA : elle accélère le codage, mais la livraison logicielle ralentit car les équipes peinent à tester, sécuriser et déployer tout ce code.

Pour accéder à notre rapport DevSecOps complet dédié à « L'ère du développement logiciel intelligent », cliquez ici.

Les gains de productivité se heurtent à des goulots d'étranglement dans les workflows

Le problème n'est pas l'IA en elle-même, mais la façon dont les logiciels sont développés aujourd'hui. Le cycle de vie DevSecOps traditionnel comporte des centaines de petites tâches que les équipes de développement doivent gérer manuellement : mise à jour des tickets, exécution des tests, demandes de revue, attente des approbations, résolution des conflits de merge, traitement des problèmes de sécurité. Ces tâches mobilisent en moyenne six heures par semaine pour chaque membre de l'équipe, selon notre étude, sans compter les 14 heures mensuelles dédiées à la conformité.

Les équipes de développement génèrent du code plus vite que jamais. D'ailleurs, 100 % des professionnels interrogés affirment que l'IA leur a permis de gagner en productivité. Parmi les domaines où les outils d'IA ont permis les gains d'efficacité les plus importants, nous retrouvons l'automatisation des tâches répétitives (44 %), les tests/assurance qualité (38 %) et la génération de code (37 %).

Mais ce code continue de passer par des chaînes d'outils fragmentées, des transferts manuels et des processus déconnectés.

En France, 52 % des équipes DevSecOps utilisent plus de cinq outils pour le développement logiciel, et 47 % utilisent plus de cinq outils d'IA. Plus préoccupant encore, 48 % des professionnels utilisent des outils d'IA non officiellement approuvés par leur entreprise.

Cette fragmentation crée des obstacles à la collaboration : 96 % des professionnels DevSecOps font face à des éléments qui limitent la collaboration dans le cycle de vie du développement logiciel, notamment le manque de communication interfonctionnelle (34 %), les effets de silo organisationnels (31 %) et la multiplication des outils utilisés (29 %).

La solution n'est pas d'ajouter davantage d'outils. Il s'agit plutôt d'une orchestration intelligente qui rassemble les équipes logicielles et leurs agents d'IA à travers les projets et les cycles de release, avec une sécurité, une gouvernance et une conformité de niveau entreprise intégrées nativement.

Vers un partenariat humain-IA renforcé

Les professionnels DevSecOps ne veulent pas que l'IA prenne le contrôle. Ils veulent des partenariats fiables. 75 % affirment que l'utilisation de l'IA agentique augmenterait leur satisfaction au travail, et 39 % envisagent un avenir idéal avec une répartition équitable entre les contributions humaines et l'IA. Ils sont prêts à confier 33 % de leurs tâches quotidiennes à l'IA sans révision humaine, notamment pour la documentation (48 %), la création de tests (48 %) et les revues de code (44 %).

Ce que nous avons entendu de manière unanime de la part des professionnels DevSecOps, c'est que l'IA ne les remplacera pas, mais qu'elle transformera fondamentalement leurs rôles. 80 % pensent que l'IA modifiera significativement leur travail dans les cinq prochaines années. Et fait notable, 68 % estiment que cela créera même davantage d'emplois d'ingénieurs. À mesure que le codage devient plus facile avec l'IA, les ingénieurs capables de concevoir des systèmes, d'assurer la qualité et d'apporter un contexte métier seront très demandés. 83 % des répondants affirment d'ailleurs que les ingénieurs qui adoptent l'IA assurent la pérennité de leur carrière.

Point important : 85 % s'accordent à dire qu'il existe des qualités humaines essentielles que l'IA ne remplacera jamais totalement, notamment l'innovation (42 %), la vision stratégique (42 %), la créativité (41 %) et la collaboration (38 %).

Alors comment les organisations peuvent-elles combler le fossé entre la promesse de l'IA et la réalité des workflows fragmentés ?

Vous souhaitez en savoir plus ? Téléchargez notre rapport complet dédié à « L'ère du développement logiciel intelligent ».

Participez à GitLab Transcend

Participez le 10 février prochain à notre événement GitLab Transcend, où nous dévoilerons comment l'orchestration intelligente transforme le développement logiciel alimenté par l'IA. Vous découvrirez en avant-première la roadmap produit de GitLab et apprendrez comment les équipes résolvent des défis concrets en modernisant leurs workflows de développement avec l'IA.

Les organisations qui réussissent dans cette nouvelle ère trouvent un équilibre entre l'adoption de l'IA et la sécurité, la conformité et la consolidation des plateformes. L'IA offre de véritables gains de productivité lorsqu'elle est implémentée de manière réfléchie. 81 % des professionnels estiment que l'adoption systématique de l'IA générera plus de retours à long terme que son utilisation pour des solutions tactiques rapides. Non pas en remplaçant les développeurs humains, mais en libérant les professionnels DevSecOps pour qu'ils se concentrent sur la réflexion stratégique et l'innovation créative.

Inscrivez-vous dès aujourd'hui à GitLab Transcend et découvrez comment l'orchestration intelligente peut aider vos équipes logicielles.

Qu’est-ce que le DevOps ?

Le terme DevOps désigne une approche unifiée du développement logiciel et des opérations informatiques. Elle vise à supprimer les silos organisationnels entre les équipes de développement (Dev) et d'opérations (Ops) pour créer une culture de la collaboration et améliorer la rapidité et la fiabilité des livraisons logicielles.

Le DevOps ne se limite pas à une méthodologie ou à un ensemble d’outils : c’est avant tout une culture et un cadre opérationnel fondé sur trois piliers essentiels :

1. L’automatisation du cycle de vie applicatif.
2. La communication et la collaboration entre les équipes.
3. L’amélioration continue des processus et des produits.

Cette approche s’inscrit pleinement dans les pratiques CI/CD (Intégration et Livraison continues) modernes où vitesse, qualité et sécurité sont combinées.

Pourquoi adopter le DevOps ?

Le DevOps répond directement aux enjeux liés aux cycles de développement qui se raccourcissent et à l’exigence accrue de fiabilité, en unifiant les processus de bout en bout : de la planification au déploiement, en passant par les tests et la supervision.

1. Des équipes alignées

Le DevOps élimine les silos historiques entre les équipes chargées du développement et des opérations. Les équipes collaborent sur un même pipeline, avec des objectifs partagés et des indicateurs communs. Cette approche collaborative réduit les transferts d’information, les malentendus et les délais liés aux validations successives.

GitLab renforce cette collaboration en centralisant tout le cycle de vie logiciel, du commit à la mise en production, au sein d’une seule et même plateforme.

2. L’automatisation comme levier de fiabilité

Les pipelines CI/CD exécutent automatiquement les étapes critiques : build, tests, contrôle qualité, sécurité et déploiement et chaque livraison suit un processus standardisé et documenté.

Cette industrialisation réduit la dépendance aux actions manuelles, tout en garantissant la stabilité et la traçabilité du code.

Résultat : des déploiements plus fréquents, reproductibles et sûrs, avec un taux d’échec nettement inférieur.

3. Des environnements stables, des incidents réduits

Les pratiques DevOps s’appuient sur l’Infrastructure as Code (IaC) pour garantir la cohérence entre le développement, les tests et la mise en production. Les configurations ne sont plus gérées manuellement, mais sont versionnées, validées et déployées via les pipelines.

Ce modèle élimine la plupart des erreurs liées aux différences d’environnement et en cas de défaillance, les équipes peuvent revenir à une version précédente en quelques secondes.

L’effet sur les opérations est immédiat : un MTTR (mean time to repair) réduit, une meilleure prévisibilité et une confiance accrue dans chaque déploiement.

4. Une culture d’amélioration continue

Le DevOps repose sur une logique d’apprentissage permanent. Les performances sont mesurées à l’aide des métriques DORA qui incluent la fréquence de déploiement, le délai de mise en production, le taux d’échec des changements, et le temps moyen de restauration. Ces indicateurs permettent aux équipes de mesurer et d'améliorer leurs performances DevOps.

En utilisant les rapports personnalisés DORA dans GitLab, les équipes transforment leurs pipelines en levier de performance mesurable.

5. Sécurité intégrée, agilité préservée

Le DevOps évolue progressivement vers une approche DevSecOps, où la sécurité est intégrée à chaque étape du cycle de développement logiciel.

Les contrôles de code, l’analyse des dépendances et l’analyse des conteneurs s’exécutent automatiquement dans les pipelines CI/CD.

Cette approche « shift-left » détecte et corrige les vulnérabilités avant qu’elles n’atteignent la production. Les équipes gagnent ainsi en efficacité : elles maintiennent la cadence des livraisons et renforcent la conformité.

GitLab automatise l’ensemble de ces contrôles à chaque commit, garantissant un équilibre entre vitesse et sécurité.

6. Des cycles de livraison plus courts

Le DevOps accélère radicalement le passage du code à la production. Les itérations sont plus courtes, les versions plus fréquentes et les feedbacks plus rapides. Les entreprises peuvent ainsi expérimenter, ajuster et livrer au rythme du marché.

Les équipes les plus matures déploient jusqu'à plusieurs centaines de fois plus souvent que les modèles traditionnels. Cette vitesse maîtrisée transforme la mise en production en un processus régulier plutôt qu’en un événement risqué.

7. Une efficacité opérationnelle mesurable

En automatisant les processus et en centralisant les outils, l’approche DevOps réduit la complexité opérationnelle. Les ressources humaines et matérielles sont optimisées, et la productivité des équipes augmente significativement.

Les gains ne se limitent pas à la technique : la réduction du temps passé sur la maintenance libère du temps pour permettre aux équipes d’innover. Chaque heure économisée sur la coordination manuelle est une heure investie dans l’innovation et la création de valeur.

8. Une meilleure expérience utilisateur

Le DevOps raccourcit la distance entre les équipes techniques et les utilisateurs finaux. Des livraisons plus fréquentes permettent d’intégrer rapidement les retours utilisateurs, d’ajuster les fonctionnalités et de corriger les anomalies avant qu’elles ne deviennent critiques.

La stabilité des environnements garantit une expérience d’utilisation cohérente et fiable. Les utilisateurs bénéficient d’un produit plus fiable, plus réactif et en amélioration constante, preuve que l’excellence technique sert directement la satisfaction client.

Comment mesurer les avantages du DevOps ?

Le succès d’une transformation DevOps se mesure par des indicateurs concrets, généralement regroupés dans le modèle DORA :

• Délai de mise en production : délai moyen pour déployer un changement en production.
• Fréquence de déploiement : fréquence de mise en production.
• Taux d’échec des changements : pourcentage de déploiements entraînant un incident.
• Temps moyen de restauration (MTTR) : temps moyen de restauration après un incident.

Ces métriques permettent d’évaluer objectivement la maturité DevOps d’une organisation et d’identifier les axes d’amélioration prioritaires.

GitLab fournit ces indicateurs directement dans son interface, permettant un suivi en temps réel et une visibilité complète sur les performances CI/CD.

Adoptez une approche DevOps avec GitLab

GitLab offre une plateforme DevSecOps unifiée qui centralise le code, les pipelines CI/CD, la sécurité et le déploiement dans un seul espace de travail.

Cette approche intégrée supprime la fragmentation des outils et facilite la collaboration entre les équipes.

Les équipes peuvent :

• gérer le code, les tests et la sécurité dans un même environnement,
• automatiser les déploiements via des pipelines CI/CD complets,
• suivre les métriques DORA pour mesurer l’efficacité de leur travail,
• appliquer une gouvernance unifiée à l’échelle de l’organisation.

Grâce à cette intégration, GitLab aide les entreprises à concrétiser rapidement les bénéfices du DevOps sans complexité additionnelle.

Conclusion

Adopter une approche DevOps, c’est transformer la manière dont les organisations conçoivent, livrent et sécurisent leurs logiciels. Les avantages sont clairs : plus de rapidité, de fiabilité, de sécurité et de collaboration entre les équipes.

En combinant ces principes à une plateforme complète comme GitLab, les entreprises peuvent accélérer leur innovation tout en maîtrisant la qualité et les coûts.

→ Essayez GitLab Ultimate gratuitement et découvrez comment une plateforme DevSecOps intégrée peut amplifier les avantages de votre démarche DevOps.

Je me suis récemment entretenu avec un ingénieur plateforme d'une entreprise du classement Fortune 500 qui m'a confié : « Je passe plus de temps à gérer les dépôts d'artefacts qu'à améliorer réellement la plateforme. » Cette conversation m'a rappelé à quel point il était nécessaire de se pencher sur les coûts réels de la gestion fragmentée des artefacts et sur les mesures réalistes que les équipes plateforme peuvent prendre à ce sujet. Cet article vous aidera à mieux comprendre le problème et comment GitLab peut vous aider à le résoudre grâce à une consolidation stratégique.

Impact concret : les chiffres

D'après les données de nos clients et les recherches dans le secteur, la gestion fragmentée des artefacts entraîne généralement les coûts suivants pour une organisation de taille moyenne (plus de 500 développeurs) :

• Licences : 50 000 $ à 200 000 $ par an répartis sur plusieurs outils
• Coûts opérationnels : 2 à 3 équivalents temps plein consacrés aux tâches de gestion des artefacts
• Inefficacité du stockage : 20 % à 30 % de coûts de stockage supplémentaires en raison de la duplication et d'une mauvaise gestion du cycle de vie
• Perte de productivité des développeurs : 15 à 20 minutes par jour et par développeur en raison des difficultés liées aux artefacts

Pour les grandes entreprises, ces chiffres peuvent être multipliés considérablement. Un client a calculé qu'il dépensait plus de 500 000 $ par an uniquement pour les coûts opérationnels liés à la gestion de sept systèmes de stockage d'artefacts différents.

Les coûts cachés s'accumulent chaque jour :

Multiplication du temps : chaque politique de cycle de vie, règle de sécurité ou modification de contrôle d'accès doit être mise en œuvre sur plusieurs systèmes. Une configuration qui devrait prendre 15 minutes requiert au final plusieurs heures de travail.

Risques de failles de sécurité : la gestion des politiques de sécurité sur des systèmes disparates crée des espaces vulnérables. L'analyse des vulnérabilités, les contrôles d'accès et les pistes d'audit deviennent fragmentés.

Coût du changement de contexte : les développeurs perdent en productivité lorsqu'ils ne trouvent pas les artefacts ou doivent se rappeler quel système stocke quoi.

Quand la multiplication des outils devient un problème

L'environnement de la gestion des artefacts a explosé. Là où les équipes de plateforme géraient autrefois un seul dépôt Maven, elles doivent aujourd'hui jongler avec :

• Des registres de conteneurs (Docker Hub, ECR, GCR, Azure ACR)
• Des dépôts de paquets (JFrog Artifactory, Sonatype Nexus)
• Des registres spécifiques au langage (npm, PyPI, NuGet, Conan)
• Des artefacts d'infrastructure (modules Terraform, charts Helm)
• Des registres de modèles ML (MLflow, Weights & Biases)

Chaque outil possède son propre système d'authentification, ses politiques de cycle de vie, son analyse de sécurité et ses exigences opérationnelles. Pour les organisations qui comptent des centaines ou des milliers de projets, la gestion devient un fardeau exponentiel.

L'approche stratégique de GitLab

Lorsque nous avons commencé à développer les fonctionnalités de gestion des artefacts de GitLab il y a six ans, nous avons été confrontés à une décision produit classique : prendre en charge tous les formats d'artefacts imaginables ou approfondir les formats les plus importants pour les équipes d'entreprise. Nous avons choisi la deuxième approche, et cette décision a façonné tout ce que nous avons construit depuis.

Nos priorités

Au lieu de créer une prise en charge superficielle pour plus de 20 formats, nous nous sommes engagés à fournir des capacités de niveau entreprise pour une sélection de formats stratégiques :

• Maven (écosystème Java)
• npm (JavaScript/Node.js)
• Docker/OCI (images de conteneurs)
• PyPI (paquets Python)
• NuGet (paquets C#/.NET)
• Paquets génériques (tout artefact binaire)
• Modules Terraform (Infrastructure as Code)

Ces sept formats représentent environ 80 % de l'utilisation des artefacts dans les environnements d'entreprise, d'après nos données clients.

Le niveau entreprise

En nous concentrant sur moins de formats, nous pouvons fournir des capacités qui fonctionnent dans des environnements de production avec des centaines de développeurs, des téraoctets d'artefacts et des exigences strictes en matière de conformité :

Registres virtuels : proxy et mise en cache des dépendances en amont pour des builds fiables et un contrôle de la chaîne d'approvisionnement. Actuellement en production pour Maven, avec npm et Docker prévus pour début 2026.

Gestion du cycle de vie : politiques de nettoyage automatisées qui empêchent l'augmentation des coûts de stockage et préservent les artefacts à des fins de conformité. Disponible au niveau du projet aujourd'hui, avec des politiques au niveau de l'organisation prévues pour mi-2026.

Intégration de la sécurité : analyse des vulnérabilités intégrée, analyse des dépendances et application des politiques. Notre future fonctionnalité Dependency Firewall (prévu pour fin 2026) fournira un contrôle de sécurité de la chaîne d'approvisionnement sur tous les formats.

Intégration CI/CD approfondie : traçabilité complète du commit source à l'artefact déployé, avec provenance du build et résultats d'analyse de sécurité intégrés dans les métadonnées d'artefact.

Capacités actuelles : des fonctionnalités éprouvées

Registres virtuels Maven : notre capacité phare au niveau entreprise, une solution éprouvée et utilisée par plus de 15 entreprises clientes. Deux mois suffisent pour configurer un registre virtuel Maven avec une assistance GitLab minimale.

Dépôts hébergés localement : les sept formats pris en charge offrent des capacités complètes d'importation, de téléchargement, de gestion des versions et de contrôle d'accès qui prennent en charge des charges de travail critiques dans des organisations avec des milliers de développeurs.

Artefacts protégés : protection complète qui empêche les modifications non autorisées, avec prise en charge de contrôles d'accès précis sur tous les formats.

Politiques de cycle de vie au niveau du projet : politiques automatisées de nettoyage et de rétention pour le contrôle des coûts de stockage et la conformité.

Performances et mise à l'échelle

D'après les déploiements en production actuels :

• Débit : plus de 10 000 téléchargements d'artefacts par minute/par instance
• Stockage : clients avec une gestion efficace de plus de 50 To d'artefacts
• Utilisateurs simultanés : accès simultané de plus de 1 000 développeurs aux artefacts
• Disponibilité : disponibilité de 99,99 % pour GitLab.com depuis plus de 2 ans

Roadmap stratégique : 18 prochains mois

T1 2026

• Registres virtuels npm : proxy/cache d'entreprise pour les paquets JavaScript
• Registres virtuels Docker : capacités de proxy de registres de conteneurs

T2 2026

• Politiques de cycle de vie au niveau de l'organisation (version bêta) : politiques de nettoyage centralisées avec remplacements au niveau du projet
• Registres virtuels NuGet (version bêta) : prise en charge du proxy de paquets .NET
• Registres virtuels PyPI (version bêta) : finalisation de la prise en charge du registre virtuel pour Python

T3 2026

• Tableau de bord d'analyse avancée : informations sur l'optimisation du stockage et l'utilisation

T4 2026

• Dependency Firewall (version bêta) : contrôle de sécurité de la chaîne d'approvisionnement pour tous les types d'artefacts

Quand choisir GitLab : framework de décision

GitLab est probablement le bon choix si :

• 80 % ou plus de vos artefacts sont dans nos sept formats pris en charge
• Vous utilisez déjà GitLab pour le code source ou le CI/CD
• Vous privilégiez les workflows intégrés plutôt que la richesse des fonctionnalités autonomes
• Vous souhaitez réduire la complexité opérationnelle liée à la gestion de plusieurs systèmes
• Vous avez besoin d'une traçabilité complète de la source au déploiement

Déroulement d'une migration

Calendrier typique : 2 à 4 mois pour une migration complète depuis Artifactory/Nexus

Défis courants : configuration du registre virtuel, mappage du contrôle d'accès et modifications des workflows des équipes de développement

Facteurs de réussite : approche progressive, tests complets et formation des développeurs

Les migrations réussies suivent ce modèle :

1. Évaluation (2 à 4 semaines) : inventaire des artefacts actuels et des modèles d'utilisation
2. Phase pilote (4 à 6 semaines) : migration d'une équipe/d'un projet de bout en bout
3. Déploiement (6 à 12 semaines) : migration progressive avec systèmes parallèles
4. Optimisation (en continu) : mise en œuvre de fonctionnalités et de politiques avancées

Une meilleure gestion des artefacts dès aujourd'hui

La gestion des artefacts de GitLab n'a pas pour objectif de convenir à toutes les entreprises. Nous avons fait des compromis stratégiques : des capacités approfondies pour les formats d'entreprise de base plutôt qu'une prise en charge superficielle.

Si vos besoins en matière d'artefacts correspondent à nos formats pris en charge et que vous privilégiez les workflows intégrés, nous pouvons réduire considérablement vos coûts opérationnels et améliorer l'expérience des équipes de développement.

Nous souhaitons vous aider à prendre des décisions éclairées sur votre stratégie de gestion des artefacts grâce à une compréhension claire des fonctionnalités et de notre roadmap.

N'hésitez pas à me contacter à l'adresse trizzi@gitlab.com pour en savoir plus sur la gestion des artefacts chez GitLab. Nous pourrons aborder vos exigences spécifiques et vous mettre en relation avec notre équipe technique pour une évaluation plus approfondie.

Cet article de blog contient des informations relatives aux produits, fonctionnalités et caractéristiques à venir. Il est important de noter qu'elles ne sont fournies qu'à titre informatif. Veuillez ne pas vous fier à ces informations à des fins d'achat ou de planification. Comme pour tout projet, les éléments mentionnés dans cet article sont susceptibles de changer ou d’être retardés. Le développement, la sortie et le calendrier de tout produit ou de toute fonctionnalité restent à la seule discrétion de GitLab.

L'intégration de GitLab avec CodeSonar (d'AdaCore) relève ce défi grâce à une automatisation des workflows de conformité et une vérification continue tout au long du cycle de développement logiciel.

Scan spécialisé pour les systèmes critiques

Les systèmes critiques nécessitent une analyse approfondie du code C/C++ compilé avec des outils embarqués spécialisés. Ces systèmes doivent démontrer leur conformité aux normes de codage (MISRA C/C++, CERT C/C++, AUTOSAR C++) et aux frameworks de sécurité fonctionnelle (ISO 26262, DO-178C, IEC 61508) qui exigent des pistes d'audit détaillées. Outre l'alignement avec les normes de codage, les équipes doivent également traiter les incidents de sécurité et tester les problèmes de mémoire, les variables non initialisées et l'injection de commandes.

CodeSonar effectue une analyse complète du programme avec des capacités d'analyse spécialisées pour ces normes. L'association de CodeSonar avec GitLab permet aux équipes d'automatiser les workflows de conformité et de maintenir des pistes d'audit complètes tout au long du cycle de développement.

Automatisation de la conformité du commit au merge

L'intégration de GitLab et CodeSonar offre une approche Compliance-as-Code qui automatise l'application des politiques dès les premières étapes du développement. CodeSonar fonctionne comme un scanner supplémentaire au sein des pipelines CI/CD GitLab et analyse le code à chaque commit et merge request.

Conçu spécifiquement pour les systèmes embarqués, CodeSonar effectue une analyse approfondie du flux de contrôle et de données sur l'ensemble des programmes. Il identifie les vulnérabilités telles que les dépassements de mémoire tampon, la contamination des données, les variables non initialisées, les conditions « use-after-free » (tentative d'accès à la mémoire) et l'injection de commandes : il s'agit là des causes profondes de la plupart des incidents de sécurité dans les systèmes embarqués.

L'intégration fonctionne via la configuration CI/CD de GitLab. Lorsque les équipes de développement effectuent un push des modifications de code, le pipeline déclenche le scan CodeSonar. Pour les firmwares C et C++, CodeSonar observe les invocations du compilateur pendant le processus de build réel et crée une représentation interne du code en vue d'une analyse sophistiquée. Les résultats sont convertis du format SARIF au format de test statique de sécurité des applications (SAST) de GitLab et affichés directement dans les merge requests, où ils alimentent le tableau de bord de sécurité de GitLab Ultimate, la gestion des vulnérabilités et les frameworks de conformité.

Exemple de workflow : conformité à la norme ISO 26262 ASIL-D

La vidéo de démonstration ci-dessous présente le workflow complet pour un système embarqué soumis aux exigences de la norme ISO 26262 ASIL-D. Le scénario illustre comment les équipes de développement embarqué peuvent mettre en œuvre une conformité continue sans compromettre la vélocité de développement.

Le workflow commence lorsqu'un développeur soumet une merge request afin de modifier le firmware. Le pipeline CI/CD de GitLab déclenche automatiquement le scan CodeSonar, qui effectue une analyse approfondie C/C++ des politiques ISO 26262 personnalisées configurées dans le pipeline. Lorsque CodeSonar identifie une vulnérabilité pertinente pour ASIL-D, le pipeline s'arrête automatiquement conformément à la politique de conformité et fournit une documentation claire du problème. Les résultats complets du scan, le suivi des tickets et le workflow d'approbation sont conservés dans GitLab comme source unique de vérité pour les pistes d'audit.

Les équipes de développement peuvent utiliser à la fois l'interface hub de CodeSonar et GitLab Duo pour comprendre la vulnérabilité. CodeSonar fournit des informations détaillées sur le chemin dans le code source qui mène au problème, ainsi que des fonctionnalités de navigation dans le code pour isoler la cause profonde. GitLab Duo explique la vulnérabilité et fournit des recommandations de correction spécifiques. Une fois la correction implémentée et la résolution validée, le code est fusionné, et les équipes disposent également de preuves de conformité qui ont été automatiquement collectées tout au long du processus.

Avantages de l'intégration

Les organisations qui mettent en œuvre cette conformité intégrée avec GitLab et CodeSonar constateront des améliorations significatives tant au niveau de la vélocité de développement que de la confiance en matière de conformité.

• Gains d'efficacité : les équipes de développement réduisent le délai de mise sur le marché, car elles détectent les problèmes de conformité aux normes de codage tôt, lorsqu'ils sont moins coûteux à corriger. L'application automatisée des politiques de sécurité réduit la charge de travail liée aux revues de sécurité manuelles et permet aux spécialistes de se concentrer sur des problèmes complexes plutôt que sur des vérifications routinières. La préparation aux audits s'améliore grâce à la collecte automatisée de preuves. Les artefacts de conformité sont générés comme un sous-produit du développement normal plutôt que lors de tâches de documentation séparées.
• Maturité de la conformité : cette approche intégrée aide les organisations à maintenir une conformité continue avec les normes et réglementations du secteur. En intégrant la vérification dans chaque modification de code, les équipes construisent des pistes d'audit complètes qui démontrent l'adhésion aux normes ISO 26262, DO-178C, MISRA C/C++ et d'autres exigences. Le workflow automatisé transforme la conformité d'un point de contrôle périodique en un processus de vérification continu.

Considérations relatives à l'implémentation

La mise en œuvre de l'intégration GitLab et CodeSonar nécessite un accès à GitLab Ultimate, un hub CodeSonar, des runners GitLab où le code peut être compilé et analysé, ainsi que des mécanismes appropriés pour la gestion des fichiers de données d'analyse. GitLab et CodeSonar prennent tous deux entièrement en charge les environnements sur site et air-gapped et peuvent également être déployés dans des environnements cloud auto-évolutifs.

Les équipes doivent configurer des frameworks de conformité personnalisés dans GitLab pour définir des politiques spécifiques à leurs normes pertinentes : ISO 26262 pour l'automobile, DO-178C pour l'aérospatiale, IEC 62304 pour les dispositifs médicaux, et bien d'autres encore. Ces frameworks permettent l'application automatisée des exigences de conformité via des règles d'approbation de merge request, des seuils de vulnérabilité et des portes relatives aux politiques de scans.

Lancez-vous

Le composant CI CodeSonar pour GitLab est disponible via le catalogue CI/CD de GitLab. Une documentation d'intégration détaillée fournit des instructions de configuration spécifiques à chaque plateforme pour les environnements Linux, Docker et Windows. Pour les organisations qui évaluent cette solution, l'implémentation démontre comment des outils spécialisés pour systèmes embarqués peuvent s'intégrer à une plateforme DevSecOps moderne afin d'offrir à la fois vélocité de développement et rigueur de conformité.

Pour plus d'informations sur l'implémentation de GitLab avec CodeSonar pour votre développement de systèmes embarqués, consultez la documentation d'intégration CodeSonar. Vous pouvez également demander un essai de CodeSonar.