Blog

Comment nous avons réduit le temps d’attente de notre CI de 30 minutes à 5 minutes

La CI lente est l’une de ces choses qui agacent les équipes d’ingénierie. Les ingénieurs attendent plus longtemps les retours, les changements de contexte se multiplient, et la tentation de regrouper les modifications augmente, ce qui ne fait qu’aggraver la situation. Nous avons passé quelques semaines à optimiser nos workflows GitHub Actions et avons réduit nos vérifications de PR de 30 minutes à 5 minutes. Cela représente une réduction de 83 % du temps d’attente, obtenue sans sacrifier la moindre couverture de test ni les garde-fous de qualité.

Il n’y a pas eu de solution miracle unique. Nous avons regardé où le temps partait réellement et appliqué trois principes : des dépendances de jobs intelligentes, un cache agressif et le sharding des tests. Voici ce que nous avons appris.

Cal.com open source code example in an editor window

Les fondations : migration vers Blacksmith

Nous avions déjà essayé de migrer vers Blacksmith auparavant, mais nous avions rencontré des problèmes. Avec une branche main aussi active que la nôtre, nous ne voulions pas gérer l’instabilité de la CI. Cette fois, la migration s’est faite sans difficulté (#26247) : remplacer les runners buildjet-*vcpu-ubuntu-2204 par blacksmith-*vcpu-ubuntu-2404 dans 28 fichiers de workflow, remplacer les actions cache et setup-node, puis ajuster les allocations de vCPU. Le seul vrai problème que nous avons rencontré a été le problème de cache corrompu avec les fichiers .next (nous y revenons dans la section sur le cache).

Une fois la mise à niveau effectuée, nous avons constaté immédiatement un gain de vitesse x2 pour le chargement du cache. Avec un yarn install de 1,2 Go, cela fait environ 22 secondes gagnées sur chaque job qui en a besoin, ce qui est le cas de la plupart d’entre eux. Nous utilisons aussi le cache de conteneurs de Blacksmith pour les services utilisés dans de nombreux jobs (Postgres, Redis, Mailhog). Le job Initialize containers a maintenant baissé de plus de 50 %, passant de 20 secondes à 9 secondes.

jobs:
  build:
    name: Build Web App
    runs-on: blacksmith-4vcpu-ubuntu-2404
    steps:
      - uses: actions/checkout@v4
      - uses: ./.github/actions/yarn-install
      - uses: ./.github/actions/cache-build

Ce que nous avons dû corriger

Les runners Blacksmith exposent le nombre de CPU de la machine hôte plutôt que les vCPU alloués (généralement 4). Playwright, toujours serviable, lançait alors autant de workers, ce qui provoquait des contentions de ressources et des échecs de test intermittents. Il nous a simplement fallu limiter explicitement les workers avec --workers=4 pour correspondre à notre allocation réelle.

Nous avons également découvert qu’un parallélisme plus élevé révélait des conditions de course dans notre logique de nettoyage des tests. Les tests d’intégration qui fonctionnaient parfaitement en séquentiel entraient en collision lorsqu’ils s’exécutaient en parallèle, ce qui produisait des erreurs idempotencyKey. La solution a exigé de repenser la façon dont les tests se nettoient eux-mêmes : interroger les bookings par eventTypeId plutôt que de suivre des identifiants de booking individuels, ce qui laissait de côté les bookings créés indirectement par le code testé (#26269, #26278, #26283).

Même nos tests de capture d’écran ont dû être ajustés (#26247). Les différents runners ont de subtiles différences de rendu des polices, alors nous avons ajouté deviceScaleFactor: 1 pour un rendu cohérent et légèrement augmenté notre seuil de différence de 0.05 à 0.07 afin de tenir compte des variations d’anticrénelage sans masquer de vraies régressions.

Aller plus vite révèle souvent des couplages cachés dans votre système. Le couplage a toujours été là ; vous ne pouviez simplement pas le voir à des vitesses plus faibles. Corriger ces problèmes est ce qui permet des gains de vitesse durables.

Principe 1 : réduire le chemin critique grâce à la conception des dépendances

Pour nous, un gros problème était que le lint bloquait des choses qu’il n’aurait pas dû bloquer. Quand vos tests E2E prennent 7 à 10 minutes, les bloquer à cause de 2 à 3 minutes de lint et de vérifications de types ne fait qu’allonger tout le workflow. Le lint se termine bien avant les E2E, alors pourquoi ne pas les faire tourner en parallèle ?

Découpler les suites de tests sans lien

Nos tests d’intégration et notre suite E2E principale n’ont pas besoin du build API v2, nous avons donc supprimé cette dépendance (#26170). À l’inverse, les tests E2E de l’API v2 n’ont pas besoin du build web principal. Chaque suite de tests ne dépend désormais que de ce dont elle a réellement besoin, ce qui permet un parallélisme maximal.

Regrouper les jobs de préflight

Nous avions des jobs séparés pour la détection des changements de fichiers (changes) et la vérification du label E2E (check-label). Chaque job a un coût de démarrage : lancer un runner, récupérer le code, restaurer le contexte. En fusionnant ces étapes dans un seul job prepare, nous avons supprimé des surcoûts redondants (#26101). Nous sommes allés plus loin en déplaçant aussi nos étapes d’installation des dépendances dans le job prepare, ce qui a permis de gagner encore 20 secondes par workflow en supprimant une autre frontière de job (#26320).

Rendre le reporting non bloquant

Les rapports de tests E2E sont précieux, mais ils ne devraient pas se trouver sur le chemin critique. Nous avons déplacé les jobs merge-reports, publish-report et cleanup-report dans un workflow distinct déclenché par workflow_run (#26157). Les ingénieurs peuvent maintenant relancer immédiatement les jobs en échec sans attendre la génération des rapports.

name: E2E Report

on:
  workflow_run:
    workflows: ["PR Update"]
    types:
      - completed

La règle est simple : soyez souples et laissez les jobs E2E démarrer plus tôt plutôt que plus tard. Ne bloquez pas les jobs longs sur des prérequis courts, sauf s’il existe une véritable dépendance. Le temps d’exécution de votre CI est déterminé par le chemin critique, et chaque dépendance inutile l’allonge.

Principe 2 : le cache est roi (mais seulement s’il sert)

Un cache efficace exige des clés qui s’invalident quand il faut, restent stables quand il faut, et un magasin de cache qui reste sain dans le temps.

Utiliser lookup-only

Notre amélioration de cache la plus spectaculaire est venue d’une observation simple : nous téléchargions environ 1,2 Go de données en cache même quand nous n’avions rien à installer. Le cache existait, le hit était réussi, mais nous payions quand même le coût du téléchargement avant de découvrir que nous pouvions sauter l’étape d’installation.

La solution a été d’utiliser des vérifications de cache lookup-only (#26314). Nous avons des étapes dédiées qui s’exécutent avant tous les jobs pour garantir que les dépendances sont installées, donc au moment où les jobs individuels s’exécutent, nous savons que le cache existe. Avant d’essayer de restaurer le cache complet, nous vérifions d’abord s’il existe sans le télécharger. Si tous les caches sont trouvés, nous sautons entièrement le flux de restauration et d’installation. Aucun téléchargement, aucune installation, on passe directement au travail réel. À lui seul, cela a fait gagner un temps considérable sur chaque scénario de cache hit, ce qui, avec une bonne conception des clés de cache, devrait représenter la majorité des exécutions.

- name: Check yarn cache (lookup-only)
  if: ${{ inputs.skip-install-if-cache-hit == 'true' }}
  uses: actions/cache/restore@v4
  id: yarn-download-cache-check
  with:
    path: ${{ steps.yarn-config.outputs.CACHE_FOLDER }}
    key: yarn-download-cache-${{ hashFiles('yarn.lock') }}
    lookup-only: true

Nous avons appliqué la même logique à l’installation du navigateur Playwright (#26060). Comme nous avons une étape dédiée qui garantit que les navigateurs Playwright sont mis en cache avant l’exécution des jobs de test, nous pouvons utiliser la même approche lookup-only. Si le cache Playwright est trouvé, l’installation est complètement sautée. Désormais, nous vérifions d’abord, puis nous décidons s’il faut télécharger quoi que ce soit.

Nous avons étendu ce modèle à notre cache de base de données également (#26344). Grâce aux vérifications lookup-only, nous pouvons éviter de reconstruire le cache DB lorsqu’il existe déjà. Nous avons aussi simplifié la clé de cache en supprimant le numéro de PR et le SHA, ce qui la rend beaucoup plus réutilisable d’une exécution à l’autre.

Exactitude du cache

L’exactitude du cache compte autant que sa vitesse. Nous avons découvert que notre motif glob **/node_modules/ capturait apps/web/.next/node_modules/, qui correspond à une sortie de build Next.js contenant des liens symboliques et des fichiers générés qui changent pendant les builds. Cela a conduit à des archives de cache corrompues avec des erreurs d’extraction tar (#26268). La correction a été un simple motif d’exclusion, mais le trouver a exigé de comprendre précisément ce qui était mis en cache et pourquoi.

Nous avons également mis en place un nettoyage automatique du cache (#26312). Lorsqu’une PR est fusionnée ou fermée, nous supprimons désormais ses caches de build associés. Cela allège notre magasin de cache et empêche l’accumulation d’entrées obsolètes qui ne seraient plus jamais utilisées. Nous avons au passage simplifié le format de nos clés de cache, en supprimant des segments inutiles comme runner.os et node_version qui ajoutaient de la complexité sans améliorer les taux de hit.

delete-cache-build-on-pr-close:
  if: github.event_name == 'pull_request' && github.event.action == 'closed'
  runs-on: blacksmith-2vcpu-ubuntu-2404
  env:
    CACHE_NAME: prod-build
  steps:
    - name: Delete cache-build cache
      uses: useblacksmith/cache-delete@v1
      with:
        key: ${{ env.CACHE_NAME }}-${{ github.event.pull_request.head.ref }}
        prefix: "true"

Turbo Remote Caching

Nous sommes passés à Next.js 16 (#26093), ce qui a réduit nos builds de plus de 6 minutes à environ 1 minute (merci à l’équipe Next.js pour ces énormes améliorations). Avec Turbo Remote Caching activé, les builds suivants prennent seulement 7 secondes pour être récupérés depuis le cache, contre environ 1 minute pour un build complet.

Nous avons également activé Turbo Remote Caching pour nos tests E2E API v2 (#26331). Auparavant, chaque shard E2E reconstruisait les packages de la plateforme depuis zéro. Désormais, chaque shard bénéficie du cache distant de Turbo, et nous avons optimisé la compilation TypeScript de Jest en activant isolatedModules et en désactivant les diagnostics dans la CI, ce qui accélère nettement le démarrage des tests.

Principe 3 : faire évoluer les tests avec le sharding

Quand vous avez plus de 1 100 cas de test répartis sur 82 fichiers de tests E2E, les exécuter séquentiellement revient à laisser de la performance sur la table. Le test sharding, qui répartit votre suite de tests sur plusieurs runners parallèles, est la façon la plus directe de réduire le temps de passage pour les grandes suites de tests. Nous avions déjà le sharding en place pour notre suite E2E principale, mais nous l’avons augmenté de 4 à 8 shards (#26342), ce qui a réduit encore d’une minute le temps total de la suite E2E. Nos tests E2E API v2 s’exécutaient toujours en un seul job.

Nous avons découpé nos tests E2E API v2 en 4 jobs parallèles à l’aide de l’option --shard intégrée à Jest (#26183). Chaque shard s’exécute de manière indépendante avec ses propres services Postgres et Redis, et les artefacts sont nommés de façon unique pour chaque shard. Ce qui prenait auparavant plus de 10 minutes en un seul job s’achève désormais bien plus vite grâce à la répartition du travail sur quatre runners.

- name: Run Tests
  working-directory: apps/api/v2
  run: |
    yarn test:e2e:ci --shard=${{ matrix.shard }}/${{ strategy.job-total }}
    EXIT_CODE=$?
    echo "yarn test:e2e:ci --shard=${{ matrix.shard }}/${{ strategy.job-total }} command exit code: $EXIT_CODE"
    exit $EXIT_CODE

Le sharding à grande échelle fait aussi ressortir des problèmes d’infrastructure que vous ne remarqueriez peut-être pas avec une exécution séquentielle. Quand plusieurs jobs essaient de remplir le même cache de base de données en même temps, vous obtenez des conditions de course. Nous avons résolu cela en créant un job dédié setup-db qui s’exécute avant tous les jobs de test E2E et d’intégration (#26171). Ce job unique remplit le cache de base de données une seule fois, et tous les jobs en aval s’y restaurent. Pas de course, pas de travail dupliqué.

Nous avons également créé un workflow dédié pour les tests unitaires API v2, en les séparant de la suite de tests principale (#26189). Cela leur permet de s’exécuter en parallèle avec d’autres vérifications plutôt que de se battre pour les ressources dans un job de test monolithique.

L’effet composé

Aucun de ces changements pris isolément n’aurait réduit notre temps de CI de 83 %. Les gains viennent de leur combinaison.

Des dépendances intelligentes permettent aux jobs de démarrer plus tôt. Un cache efficace signifie que ces jobs passent moins de temps en préparation. Le sharding signifie que l’exécution réelle des tests se fait en parallèle. Ensemble, ils compressent le chemin critique dans toutes les directions.

L’investissement se cumule avec le temps. Chaque PR reçoit désormais des retours plus rapides. Les ingénieurs restent plus longtemps en flow. La tentation de regrouper les changements diminue, ce qui signifie des diffs plus petits et plus faciles à relire. La qualité du code s’améliore parce que la boucle de rétroaction est plus serrée.

Nous continuerons d’investir dans la performance de la CI parce que les bénéfices sont réels et mesurables. L’objectif n’est pas la vitesse pour la vitesse ; il s’agit de permettre aux ingénieurs de livrer plus vite des logiciels de qualité. Quand la CI est rapide, aller vite et maintenir des standards élevés vont de pair au lieu de s’opposer.

Pull Requests mentionnées

Fondations : migration de Buildjet vers Blacksmith

  • #26247 - Migrer les workflows GitHub de Buildjet vers Blacksmith

Stabilité des tests

  • #26269 - Corriger les tests e2e instables avec des sessions utilisateur isolées

  • #26278 - Stabiliser les tests e2e avec des localisateurs ciblés et des plannings déterministes

  • #26283 - Améliorer l’isolation des tests pour les tests e2e des managed scheduling links

Turbo Remote Caching

  • #26093 - Passer à Next 16 (builds réduits de plus de 6 minutes à environ 1 minute)

  • #26331 - Activer Turbo Remote Caching (les builds suivants prennent 7 s)

Dépendances des jobs et optimisation des workflows

  • #26101 - Regrouper les jobs changes et check-label dans prepare

  • #26170 - Découpler les tests hors API v2 du build API v2

  • #26157 - Rendre les jobs de rapport E2E non bloquants en les déplaçant dans un workflow séparé

  • #26320 - Déplacer l’étape de job deps vers le job prepare pour économiser environ 20 s par workflow

Utiliser lookup-only

  • #26314 - Utiliser la vérification de cache lookup-only pour ignorer les téléchargements du job deps

  • #26060 - Sauter l’installation de Playwright en cas de cache hit

  • #26344 - Utiliser lookup-only pour le cache DB et simplifier la clé de cache

Exactitude du cache

  • #26268 - Exclure .next/node_modules du cache yarn pour éviter la corruption

  • #26312 - Supprimer les entrées du cache-build à la fermeture de la PR

Sharding des tests et infrastructure

  • #26342 - Augmenter les shards E2E principaux de 4 à 8 (gain d’1 minute)

  • #26183 - Répartir les tests E2E API v2 en 4 jobs parallèles

  • #26171 - Ajouter un job dédié setup-db pour éliminer la condition de course du cache

  • #26189 - Créer un nouveau workflow pour les tests unitaires API v2

Keith Williams

Post by

Keith Williams

Head of Engineering