Chargement en cours
Vercel-CI-Beta-Pipeline.webp
Développement webPar SDX Development

Partager cet article

LinkedInFacebookXWhatsAppE-mail

Dans un SaaS Next.js, une petite modification de composant peut déclencher les mêmes contrôles que la refonte d’un package partagé : installation des dépendances, lint, TypeScript, tests et compilation. Ces vérifications sont indispensables, mais les relancer inutilement finit par ralentir chaque pull request. Vercel CI, lancé en bêta publique le 28 octobre 2026, propose d’exécuter seulement les tâches pertinentes à partir du graphe Turborepo, avec cache distant et ressources ajustables.

La promesse est séduisante : conserver les contrôles de qualité tout en évitant un second système de configuration YAML pour les tâches simples. Mais Vercel CI ne remplace pas encore toutes les automatisations GitHub Actions. Cette première version repose sur GitHub, les événements git push, un dépôt relié à Vercel et des images Linux. Voici son fonctionnement, un exemple de configuration, une comparaison honnête et les éléments à mesurer avant de migrer.

À retenir

Moins de tâches inutiles, pas une accélération garantie

Vercel CI lit les tâches déclarées dans turbo.json, exécute celles marquées "tags": ["ci"] et leurs dépendances, restaure les résultats valides depuis Vercel Remote Cache et lance les autres tâches dans des environnements isolés. Le service est en bêta ; les chiffres de rapidité publiés par Vercel proviennent de ses propres dépôts.

Dans cet article

Ce que Vercel a réellement annoncé le 28 octobre 2026

Vercel a présenté Vercel CI en bêta publique le 28 octobre 2026. Contrairement à son hébergement de prévisualisations déjà existant, ce produit vise l’exécution des contrôles de qualité du dépôt : lint, typage, tests unitaires, vérifications et tâches définies par les équipes.

Sur ses dépôts internes, Vercel rapporte un temps entre git push et l’état « CI passed » de deux à six fois plus court qu’avec sa solution précédente. Il s’agit d’une mesure interne annoncée par l’éditeur, sur un ensemble de dépôts et une configuration qui ne sont pas ceux des lecteurs. Elle ne suffit pas à prédire les gains d’un projet Next.js particulier.

L’entreprise indique aussi avoir exécuté près de huit millions de tâches sur ses dépôts et pendant la bêta privée. Cela renseigne sur les usages testés, mais ne démontre ni un gain universel, ni une disponibilité générale : la fonctionnalité reste en bêta au 29 octobre 2026.

Attention au titre

« Sans GitHub Actions » signifie « pour certaines vérifications »

Une fois la configuration mise en place, les tâches Turborepo sélectionnées n’exigent pas de workflow GitHub Actions dédié. Pour les publications npm, matrices Windows/macOS, validations manuelles ou automatisations non déclenchées par un push, GitHub Actions ou une autre solution CI peut rester nécessaire. Les deux outils peuvent coexister.

Comment Vercel CI choisit les tâches à exécuter

Le cœur du mécanisme est le graphe de dépendances Turborepo. Turborepo connaît les packages du dépôt, les scripts disponibles et les relations entre les tâches. Vercel CI utilise ce graphe pour choisir des travaux pertinents plutôt que de relancer aveuglément une liste de commandes.

Du push GitHub au résultat de la pull request

  1. Déclenchement. Un développeur pousse un commit sur le dépôt GitHub connecté au projet Vercel.
  2. Sélection. Vercel CI repère les tâches déclarées avec le tag ci et leurs dépendances.
  3. Calcul du travail utile. Turborepo identifie les packages et les tâches affectés par le changement.
  4. Cache. Les tâches dont les résultats correspondent à une entrée déjà mise en cache peuvent être restaurées sans réexécution.
  5. Exécution. Les autres tâches sont lancées sur des ressources isolées, dans l’ordre imposé par leurs dépendances, avec parallélisation lorsque c’est possible.
  6. Retour dans GitHub. Le résultat remonte dans la pull request sous forme de check utilisable par les règles de protection de branche.

Le Remote Cache est activé par défaut. Il faut néanmoins comprendre ce qu’il met en cache : des résultats de tâches déterminés par leurs entrées et leur environnement, pas une garantie que chaque test pourra être sauté. Un test utilisant une donnée externe mutable, une base distante ou une horloge doit être conçu pour ne pas produire de faux succès.

Vercel CI installe les dépendances une fois par exécution puis partage cette installation avec les environnements des tâches. L’organisation change donc autant le temps de préparation que l’exécution elle-même.

Cas pratique : une application Next.js et un package TypeScript partagé

Prenons un dépôt représentatif d’un SaaS comprenant un frontend Next.js, une bibliothèque UI et un package de fonctions métier. Cet exemple n’est pas un dépôt que SDX aurait déjà benchmarké : il sert à montrer une configuration reproductible à adapter à une application réelle.

monorepo/
├── apps/
│   └── web/                  # application Next.js
│       └── package.json
├── packages/
│   ├── ui/                   # composants partagés
│   └── core/                 # logique métier TypeScript
├── package.json
├── pnpm-workspace.yaml
├── pnpm-lock.yaml
└── turbo.json

Chaque package fournit les scripts qui le concernent. Pour l’application Web, on peut par exemple utiliser :

{
  "name": "web",
  "private": true,
  "scripts": {
    "lint": "eslint .",
    "typecheck": "tsc --noEmit",
    "test": "vitest run",
    "build": "next build"
  }
}

Ces scripts supposent que Next.js, TypeScript, ESLint et Vitest sont déjà installés et configurés dans le projet. Une bibliothèque packages/ui aura ses propres scripts et sorties de compilation. Les tâches que l’on veut sélectionner doivent exister dans les packages pertinents.

Déclarer les dépendances et le tag CI dans Turborepo

Dans le turbo.json racine, la configuration suivante signale trois contrôles et la dépendance de certains contrôles aux builds des bibliothèques utilisées :

{
  "$schema": "https://turborepo.com/schema.json",
  "tasks": {
    "build": {
      "dependsOn": ["^build"],
      "outputs": ["dist/**", ".next/**", "!.next/cache/**"]
    },
    "lint": {
      "tags": ["ci"]
    },
    "typecheck": {
      "dependsOn": ["^build"],
      "tags": ["ci"]
    },
    "test": {
      "dependsOn": ["^build"],
      "tags": ["ci"]
    }
  }
}

dependsOn: ["^build"] signifie que les builds nécessaires des packages dépendants doivent être terminés avant le contrôle concerné. Les tags ci indiquent les tâches à sélectionner. Un build utilisé comme dépendance peut donc s’exécuter même sans tag ci. Selon votre projet, il faudra ajuster les sorties de build, les entrées des tâches et les variables d’environnement pour préserver un cache correct.

Exemple de comportement attendu : modifier uniquement une page dans apps/web ne devrait pas forcer les tâches d’un package sans rapport. Modifier packages/ui peut au contraire affecter les applications qui en dépendent. Modifier le lockfile ou la configuration commune peut invalider davantage de résultats. Ce sont des scénarios à vérifier dans les logs, pas des promesses absolues.

Il est possible de désactiver une sélection dans un package particulier avec "tags": ["!ci"]. Attention : cette exclusion ne retire pas les tâches qui demeurent nécessaires comme dépendances d’autres tâches. Pour personnaliser les ressources, Vercel documente aussi "ci:cpus:8", avec un maximum actuellement indiqué de 32 CPU par tâche.

Installer et activer Vercel CI sur un dépôt existant

La bêta nécessite Turborepo 2.11.7 ou plus récent et Vercel CLI 64.3.1 ou plus récent. Elle fonctionne également avec un dépôt mono-package : dans ce cas, ajouter Turborepo peut avoir moins d’intérêt si les contrôles sont déjà très rapides.

1. Vérifier les versions et les scripts locaux

Sur un monorepo pnpm disposant déjà de son workspace et de ses scripts, vérifiez d’abord :

pnpm add --workspace-root --save-dev turbo@^2.11.7
pnpm exec turbo --version
vercel --version
pnpm exec turbo run lint typecheck test

La dernière commande permet de vérifier le graphe localement. Elle suppose que les scripts concernés existent ; corrigez d’abord tout échec de lint, de typage ou de test avant d’activer la CI. Mettez à jour Vercel CLI si la version affichée est antérieure à 64.3.1.

2. Connecter le dépôt GitHub à Vercel

Reliez le dépôt GitHub à au moins un projet Vercel de l’équipe choisie. Un même dépôt ne doit pas être connecté à des projets appartenant à plusieurs équipes Vercel pour utiliser cette bêta. L’activation de Vercel CI est explicite : elle n’est pas automatique lors du seul ajout de turbo.json.

vercel ci enable

La commande est documentée par Vercel et doit être exécutée depuis un clone local déjà relié à un projet approprié. Les autorisations GitHub/Vercel nécessaires restent à vérifier dans l’organisation.

3. Pousser la configuration et consulter le check

Versionnez turbo.json, les scripts et le lockfile, puis effectuez un git push. Vercel CI crée l’exécution correspondant aux tâches sélectionnées. La pull request GitHub affiche son résultat, qui peut être utilisé dans une règle de protection de branche afin d’empêcher une fusion si le check échoue.

Évitez d’activer immédiatement deux systèmes exécutant les mêmes contrôles sans raison. Durant une migration, conserver les deux sur quelques commits peut être utile pour comparer, mais les doublons de vérifications consomment également des ressources.

Consulter les tâches, les échecs et les logs

Le tableau de bord Vercel regroupe les exécutions de CI de l’équipe. Vercel fournit aussi des commandes CLI pour inspecter une exécution et isoler l’erreur d’une tâche. L’annonce utilise notamment les exemples suivants avec l’alias vc :

vc ci ls
vc ci inspect <identifiant-execution>
vc ci logs <identifiant-execution>
vc ci logs <identifiant-execution> --task web#test --level=error
vc ci grep "WARNING"

Les chevrons dans cet extrait désignent un emplacement à remplacer par l’identifiant de l’exécution. L’intérêt, pour une équipe, est de retrouver une erreur sur web#test sans lire l’ensemble des logs d’un pipeline monolithique. Les résultats sont également accessibles via Vercel MCP pour les outils et agents compatibles.

Un échec plus facile à diagnostiquer n’est pas nécessairement un échec plus rare : les tests instables, les dépendances externes et les courses entre processus doivent toujours être corrigés dans l’application et sa suite de tests.

Vercel CI ou GitHub Actions : quelles différences pour un SaaS ?

GitHub Actions reste un moteur d’automatisation généraliste : il sait exécuter des jobs sur différents événements et systèmes, orchestrer des matrices, publier des packages ou lancer des workflows manuels. Vercel CI, dans cette première bêta, optimise un problème plus ciblé : l’exécution des tâches définies dans Turborepo lors de pushes GitHub.

Critère Vercel CI (bêta) GitHub Actions
Déclaration des vérifications Tags dans turbo.json Workflows YAML, jobs et étapes
Sélection des tâches du monorepo Graphe Turborepo et cache intégrés À construire avec filtres, Turborepo ou actions dédiées
Déclencheurs Actuellement git push sur GitHub Push, PR, manuel, planifié et nombreux autres événements
Environnements Image de base Linux actuellement Linux, Windows, macOS et runners personnalisés
Cache Vercel Remote Cache intégré Actions Cache ou Remote Cache Turborepo à configurer
Retour dans GitHub Check sur la pull request Checks et statuts du workflow
Facturation Minutes CPU Vercel selon le forfait Modèle de facturation GitHub Actions selon plan/runners
Usages non liés aux tests Portée limitée de la bêta Publication, automatisation, matrices, tâches planifiées

Il serait faux d’opposer un Vercel CI « intelligent » à un GitHub Actions qui relancerait nécessairement tout. Un GitHub Actions bien conçu peut lui aussi utiliser Turborepo, Remote Cache, des filtres de chemins et des jobs parallèles. La comparaison doit donc se faire avec le workflow actuel du projet, pas avec un exemple volontairement inefficace.

Un workflow GitHub Actions minimal pour comparer

Voici un exemple de référence simple à adapter (les versions des actions doivent suivre la politique d’épinglage de votre organisation) :

name: Checks
on: [push, pull_request]

jobs:
  checks:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: pnpm/action-setup@v4
        with:
          version: 10
      - uses: actions/setup-node@v4
        with:
          node-version: 24
          cache: pnpm
      - run: pnpm install --frozen-lockfile
      - run: pnpm exec turbo run lint typecheck test

Cette version laisse Turborepo gérer une partie du travail local au job, mais elle ne reproduit pas automatiquement le mode d’exécution par tâche isolée de Vercel CI. Pour un benchmark équitable, comparez également avec vos workflows GitHub Actions réellement optimisés, et pas uniquement avec cet exemple pédagogique.

Vercel CI : combien coûtent réellement les tests ?

La documentation de tarification, mise à jour le 28 octobre 2026, annonce pour Vercel Pro un prix de 0,0035 $ par minute CPU. Le tarif Enterprise est personnalisé. La disponibilité de la bêta sur tous les plans ne doit pas être confondue avec des ressources illimitées ou gratuites : la page de tarification consultée ne donne pas de prix universel pour Hobby.

La facturation n’est pas basée uniquement sur la durée affichée d’une pipeline. La formule documentée est :

Minutes CPU = nombre de CPU alloués × durée d’exécution en minutes, puis application du prix unitaire du forfait. Vercel arrondit le temps d’un environnement à la seconde supérieure, avec au minimum une seconde.

Par défaut, la phase de préparation des dépendances utilise 4 CPU et 8 Go de RAM. Chaque tâche utilise ensuite 2 CPU et 4 Go de RAM, sauf personnalisation. Les tâches évitées ou restaurées du cache ne consomment pas de minutes CPU d’exécution de tâche.

Exemple de calcul

Un scénario illustratif, pas une facture constatée

Supposons 2 minutes de préparation à 4 CPU, puis deux tâches de 90 secondes à 2 CPU chacune. Cela représente 8 + 3 + 3 = 14 minutes CPU, soit 0,049 $ au tarif Pro documenté, hors tout autre poste éventuel de facturation. Une exécution réelle peut différer : tâches supplémentaires, durées variables, changement de ressources ou de tarif.

Pour décider si Vercel CI est avantageux, regardez la facture mensuelle, le volume de pushes, le taux de cache, les ressources demandées et le temps d’attente d’un développeur. Un pipeline qui dure moins longtemps ne coûte pas automatiquement moins cher, surtout si l’on augmente les CPU pour accélérer les contrôles.

La tarification peut évoluer pendant la bêta : vérifiez toujours les détails du forfait et les paramètres de suivi des dépenses avant la mise en service.

Comment mesurer honnêtement les gains de Vercel CI

SDX ne présente pas ici de benchmark réalisé sur un dépôt de production. Pour produire des chiffres exploitables, il faut comparer les deux outils sur la même application, les mêmes commits et un périmètre de tests équivalent.

Un protocole de test reproductible

  1. Fixer le périmètre. Même version de Node.js et pnpm, mêmes tests et dépendances, même verrouillage du lockfile.
  2. Définir trois changements. Une page Next.js, une bibliothèque TypeScript partagée, puis une dépendance commune ou configuration racine.
  3. Comparer cache froid et cache chaud. Distinguer premier passage, relance identique et nouveau commit modifiant un package.
  4. Faire plusieurs répétitions. Mesurer sur une série de commits, plutôt que sur une seule exécution favorable.
  5. Collecter les métriques. Temps entre push et check terminé, durée de préparation, nombre de tâches, cache hits/misses, erreurs et consommation CPU.
  6. Publier les limites. Détailler les versions des outils, les conditions réseau, les ressources et les optimisations déjà présentes dans GitHub Actions.

Le résultat devrait présenter les durées médianes, les cas les plus lents et les coûts associés. On saura alors si le gain vient surtout du cache, de l’ordonnancement, de la parallélisation ou de l’installation des dépendances. On pourra aussi identifier les cas dans lesquels Vercel CI ne fait pas mieux que le pipeline existant.

Trois situations à observer dans un monorepo

Modification testée Ce qu’il faut observer Risque d’interprétation
Fichier dans apps/web Exécution du lint et des tests Web ; tâches sans rapport évitées Une config partagée peut invalider davantage de tâches
Composant dans packages/ui Tâches du package et dépendances applicatives affectées Les dépendances mal déclarées faussent le graphe
Lockfile racine Cache invalidé et installation potentiellement plus longue Ne pas attribuer toute la durée au moteur de CI

Ce que la bêta ne prend pas encore en charge

Avant d’adopter Vercel CI, il faut vérifier les contraintes publiées au lancement :

  • GitHub uniquement : GitLab et les autres plateformes ne sont pas annoncés comme compatibles à ce stade.
  • Déclenchement par git push : pas de remplacement annoncé des planifications, déclenchements manuels ou événements GitHub spécialisés.
  • Linux comme image de base : les contrôles propres à Windows ou macOS restent à exécuter ailleurs.
  • Projet Vercel nécessaire : le dépôt doit être associé à au moins un projet Vercel et ne peut pas dépendre de projets rattachés à plusieurs équipes Vercel.
  • Configuration en évolution : il s’agit d’une bêta ; les fonctions, schémas et limitations peuvent évoluer avant la disponibilité générale.

Tests e2e, bases de données et variables secrètes

La documentation Vercel propose des guides pour les tests de bout en bout et les tests d’intégration utilisant une base de données. Ils nécessitent davantage de configuration qu’un simple "tags": ["ci"] : services, conteneurs, URLs de déploiements, permissions et confiance des certificats peuvent entrer en jeu.

Les secrets de CI doivent être déclarés dans l’espace prévu par Vercel. Avec le mode strict de Turborepo, une variable d’environnement n’arrive pas automatiquement jusqu’à la tâche : elle doit aussi figurer dans env ou passThroughEnv. N’inscrivez jamais de clés dans turbo.json ni dans vercel.json.

Autre vigilance : une tâche contenant des effets de bord (écriture externe, envoi de mails, migration d’une base partagée) ne doit pas être traitée comme un simple test mis en cache. Distinguez les contrôles déterministes des tâches d’exploitation.

Vercel annonce travailler sur une observabilité plus avancée, une exécution distribuée via vc ci avant le push et une sélection de tests plus fine. Ces éléments relèvent de la feuille de route, ils ne sont pas tous disponibles dans la bêta actuelle.

Faut-il migrer ses vérifications de GitHub Actions vers Vercel CI ?

Bon candidat à la bêta

Monorepo Next.js / TypeScript déjà sur Vercel

Plusieurs packages, des tâches répétitives, des pushes fréquents et un graphe Turborepo correctement déclaré : c’est le terrain où le cache et la sélection peuvent justifier un pilote ciblé.

Conserver GitHub Actions

CI multi-plateforme ou automatisation complexe

Si vous dépendez de Windows/macOS, de publications, de validations manuelles, de schedules ou d’un système indépendant de Vercel, GitHub Actions reste une solution plus complète. Les deux outils peuvent coexister.

La décision raisonnable n’est pas forcément « migrer toute la CI ». Commencez par un bloc simple : lint, typage et tests unitaires d’un sous-ensemble du monorepo. Vérifiez les checks GitHub, la stabilité, les coûts et les gains mesurés. Étendez ensuite seulement si les résultats le justifient.

Pour un projet client, l’objectif reste de livrer des corrections fiables plus vite, pas de multiplier les outils d’infrastructure. C’est ce compromis — maintenabilité, fiabilité des contrôles, coût et délai de livraison — qui doit guider le choix.

FAQ sur Vercel CI

Vercel CI remplace-t-il GitHub Actions ?

Il peut prendre en charge des vérifications Turborepo liées aux pushes sans workflow YAML séparé. En revanche, la bêta ne couvre pas tous les événements ni toutes les plateformes de GitHub Actions. Une architecture hybride reste possible.

Vercel CI fonctionne-t-il seulement avec Next.js ?

Non. Il s’appuie sur Turborepo et peut être utilisé dans un dépôt mono-package ou monorepo disposant des scripts appropriés. Next.js constitue un cas naturel, mais n’est pas une condition exclusive.

Quels sont les prérequis de la bêta ?

Turborepo 2.11.7 minimum, Vercel CLI 64.3.1 minimum, un dépôt GitHub associé à un projet Vercel, puis l’activation explicite via vercel ci enable.

Quel est le prix de Vercel CI ?

Le tarif public documenté pour Pro est de 0,0035 $ par minute CPU ; Enterprise bénéficie d’une tarification personnalisée. La consommation inclut la préparation et les tâches réellement exécutées selon leurs ressources.

Les gains de vitesse sont-ils garantis ?

Non. Vercel annonce des gains de deux à six fois sur ses propres dépôts. Le résultat sur un autre projet dépend des scripts, du cache, des dépendances et du pipeline existant. Il faut le mesurer.

Peut-on utiliser Vercel CI pour Playwright et les tests d’intégration ?

Oui, Vercel documente ces cas d’usage, avec une configuration supplémentaire selon le déploiement, les services utilisés et les conteneurs. Le tag ci seul ne règle pas toutes ces dépendances.

Consulter les sources officielles 8 références

DÉVELOPPEMENT WEB

Préparez les évolutions de votre application web.

Migration PHP, mise à jour de CMS ou évolution de framework : identifiez les points de compatibilité et validez les parcours essentiels avant la mise en ligne.

  • Compatibilité des dépendances vérifiée
  • Parcours essentiels testés en préproduction
  • Mise en ligne avec possibilité de retour arrière