Skipbox

Pourquoi rust-cache ne rend pas votre CI Rust rapide (tauri : de 246 s à 53 s)

Swatinem/rust-cache, l'étape de cache de la plupart des CI Rust, enregistre vos dépendances et laisse volontairement de côté les crates de votre espace de travail. Il règle aussi CARGO_INCREMENTAL=0. Sur les exécuteurs de GitHub, chaque tâche démarre sur une nouvelle VM : chaque tâche à chaud, succès de cache complet compris, recompile donc vos propres crates. Aucun réglage de rust-cache n'y change rien. Ce qui y change quelque chose, c'est un target/ encore présent depuis la dernière tâche : Cargo saute alors chaque crate qui n'a pas changé.

Skipbox le garde pour vous. Votre tâche tourne sur la machine dédiée à votre compte, qui garde le checkout et le target/ de Cargo entre les tâches. La tâche CI de tauri prenait 246 s sur GitHub et 53 s là, sans compiler aucune de ses crates dès la première exécution à chaud, sans autre modification de son workflow que runs-on: skipbox, pour un prix fixe de $39 par mois.

Ce que garde rust-cache, et ce qu'il laisse de côté

D'après le README de rust-cache et son code source :

  • Ce qu'il met en cache : ~/.cargo (le registre, les dépendances git, les binaires installés) et ./target avec la sortie de build de vos dépendances.
  • Ce qu'il laisse de côté : selon son README, les crates de l'espace de travail elles-mêmes ne sont pas mises en cache. Avant l'enregistrement, son nettoyage supprime de target/ tout ce qui n'est pas une dépendance : les artefacts de vos crates sont donc retirés de target/ lui-même.
  • La compilation incrémentale : l'étape de restauration exporte CARGO_INCREMENTAL=0 pour le reste de la tâche.
  • Quand il enregistre : seulement quand aucun cache n'a encore la clé de la tâche. La clé vient de la chaîne d'outils, de l'environnement, et de vos Cargo.lock et Cargo.toml. Vos fichiers source n'en font pas partie.

Sur une VM neuve, tout cela revient à une seule chose. Une tâche à chaud restaure vos dépendances, puis compile les crates de votre espace de travail et tout ce qui est construit dessus, entièrement, à chaque fois.

Le mécanisme, dans les logs de tauri

La tâche test de tauri exécute cinq étapes cargo test sous Ubuntu, avec rust-cache. Voici ses exécutions à chaud, chacune avec un succès de cache complet (full match: true dans le log) :

Les 32 lignes, ce sont les propres crates de tauri, et deux plugins construits dessus. Les dépendances n'apparaissent jamais : elles viennent du cache. Le temps de build de Cargo, ce sont les durées Finished … in des cinq étapes, additionnées.

La VM neuve a les CPU de la machine dédiée au compte et le même cache, et elle a compilé les mêmes 32 crates que GitHub : son target/ ne contenait que ce que le cache avait restauré. Sur la machine dédiée au compte, la première exécution à chaud n'affiche déjà plus aucune ligne Compiling. Cargo a seulement vérifié que rien n'avait changé, et chaque Finished a pris de 0,2 à 0,7 s.

La première exécution à chaud de la machine dédiée au compte recompilait auparavant les 32 crates (une tâche de 114 s), parce que l'enregistrement de rust-cache après l'exécution à froid les avait supprimées de target/. Depuis le 13 novembre 2026, les machines dédiées au compte annulent ce que la restauration et l'enregistrement de rust-cache suppriment du disque, une fois l'étape terminée. Le cache enregistré est le même, et vos crates restent dans target/.

Durées des tâches : trois projets Rust, six autres

Les tâches CI de vrais projets, à un commit figé, les étapes identiques octet pour octet ; seuls le déclencheur et runs-on ont changé. Une exécution à froid, puis deux à chaud, de chaque côté :

  • GitHub : ubuntu-24.04, l'exécuteur standard d'un dépôt public : 4 vCPU, 16 Go.
  • Skipbox, VM neuve : une nouvelle VM par tâche à partir de l'image d'exécuteur de production, 4 vCPU et 8 Go, caches restaurés par le cache de Skipbox.
  • Skipbox, machine dédiée au compte : la même taille sur les mêmes CPU hôtes, conservée entre les tâches, avec le principe « garder et effacer » qu'appliquent les machines dédiées au compte depuis le 13 novembre 2026 : le checkout et target/ restent, et ce que rust-cache supprime est remis en place.

Les exécutions Skipbox ont eu lieu sur un hôte Skipbox, dans un projet de laboratoire séparé des machines des clients. Les durées vont du début à la fin de chaque tâche, d'après l'API de GitHub. Chaque chiffre est la médiane des deux exécutions à chaud. Les exécutions à froid de la machine dédiée au compte ont pris 285 s pour tauri, 161 s pour ripgrep et 442 s pour helix.

ripgrep compile dans l'image Docker de cross. cross crée target/ lui-même et le marque « created by cross ». Les machines dédiées au compte prenaient auparavant ce target/ pour autre chose que celui de Cargo et le supprimaient après chaque tâche : Cargo recompilait donc chaque crate à chaque exécution (une tâche de 108 s). Désormais, le target/ de cross reste : les exécutions à chaud n'affichent aucune ligne Compiling, et chaque Finished prend de 0,04 à 0,05 s. GitHub télécharge aussi l'image de cross à chaque exécution (30 s lors de la deuxième exécution à chaud) ; la machine dédiée au compte la garde sur le disque.

helix va lui aussi 1,5× plus vite. Parmi ses crates, seule helix-term (et xtask, qui en dépend) est reconstruite, parce que le script de build de helix-term s'exécute à chaque tâche : 16 s dans le profil test et 61 s dans le profil integration. Aucune autre crate ne compile. L'essentiel de la tâche de helix, ce sont ses tests : sa suite de tests d'intégration tourne à elle seule 112 s. Son étape de préparation, chaîne d'outils et restauration du cache, a pris de 9 à 10 s contre 41 à 46 s sur GitHub.

Les autres langages :

astro, c'est la même histoire que target/, avec Turborepo : la machine dédiée au compte garde le cache de turbo (turbo 2), et ses exécutions à chaud rejouent depuis celui-ci les 40 tâches de build et la tâche de test au lieu de les exécuter (31 s, 28 s).

L'ubuntu-latest d'un dépôt privé a 2 CPU et 8 Go : la moitié des cœurs des exécutions GitHub ci-dessus.

Vérifiez votre propre CI

  1. Ouvrez une exécution à chaud de votre tâche Rust, une dont l'étape rust-cache affiche full match: true dans le log.
  2. Dans les étapes de build et de test, comptez les lignes Compiling. Les dépendances venues du cache n'en affichent aucune. Chacune des crates de votre espace de travail en affiche une, tout comme chaque crate construite dessus.
  3. Additionnez les durées Finished … in des étapes. C'est ce que vos propres crates coûtent à chaque exécution, et ce qu'un target/ conservé économise quand elles n'ont pas changé.

Ce que vous pouvez faire sur les exécuteurs de GitHub

  • cache-workspace-crates: true (rust-cache v2.8.0 et ultérieures). Vos crates entrent aussi dans le cache. Mais une exécution dont la clé existe saute l'enregistrement, et la clé ne change pas avec votre code source : les crates en cache ont donc l'âge du dernier enregistrement. La compilation incrémentale reste désactivée, et le cache grossit dans les 10 Go par dépôt de GitHub.
  • sccache. Il met en cache chaque compilation selon ses entrées : une crate de bibliothèque inchangée revient du stockage. Les crates qui appellent l'éditeur de liens ne peuvent pas être mises en cache : les binaires, les crates dylib, cdylib et proc-macro compilent à chaque fois, et chaque succès de cache est un téléchargement.
  • Un exécuteur auto-hébergé qui garde target/. C'est vous qui gérez la machine : la corriger, la nettoyer entre les tâches sans supprimer target/, et régler clean: false sur actions/checkout, dont le git clean -ffdx par défaut supprime target/ avec tous les autres fichiers ignorés.

Skipbox garde target/ pour vous

Chaque forfait est livré avec la machine dédiée à votre compte, conservée entre les tâches. Depuis le 13 novembre 2026, elle garde votre checkout, avec les dates de ses fichiers, et le target/ de Cargo :

  • Le nettoyage d'actions/checkout s'exécute comme d'habitude, sauf qu'il laisse tranquilles les dossiers target/ de Cargo.
  • rust-cache reste dans votre workflow. Sa restauration n'écrit plus les artefacts plus anciens du cache par-dessus les plus récents du disque.
  • Ce que l'enregistrement et la restauration de rust-cache suppriment de target/ et de ~/.cargo, la machine le remet en place une fois l'étape terminée. Le cache enregistré est le même, et dès la tâche qui suit l'exécution à froid, les crates qui n'ont pas changé ne sont pas compilées.
  • Le target/ que crée cross (marqué « created by cross ») reste aussi.
  • actions/checkout réécrit .git/HEAD à chaque tâche. Tant qu'il désigne toujours le même commit, le fichier retrouve son ancienne date : un script de build qui surveille .git/HEAD (c'est le cas de vergen) ne se réexécute pas pour cette seule raison.

La machine garde aussi les images Docker, les caches de paquets et les outils installés : le reste de la tâche accélère avec elle. Une tâche choisit sa taille par le label :

Les minutes sont illimitées. À 20 000 minutes par mois sur 4 vCPU, GitHub facture $222 ; Skipbox S coûte $39, soit $183 de moins.

Le passage tient en une ligne

jobs:
  test:
    runs-on: skipbox # was ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: dtolnay/rust-toolchain@stable
      - uses: Swatinem/rust-cache@v2
      - run: cargo test --workspace
  1. Connectez-vous à Skipbox avec GitHub.
  2. Installez l'application GitHub Skipbox et choisissez les dépôts.
  3. Modifiez runs-on et faites un push.

Sécurité

  • La machine appartient à votre seul compte. Aucune tâche d'une autre entreprise n'y tourne.
  • Après chaque tâche, les identifiants de l'exécuteur, ses processus et ses conteneurs sont effacés, ainsi que les identifiants git, les hooks et les fichiers non suivis du checkout conservé. « Nouvelle VM pour chaque tâche » donne plutôt une nouvelle machine à chaque tâche.
  • Le code des personnes sans accès en écriture (comme les pull requests venant de forks) s'exécute sur une nouvelle machine jetable, sans target/ conservé.

Les détails sont dans Comment les tâches sont isolées.

Essayez-le sur votre tâche Rust

L'essai est gratuit pendant 7 jours ou 3 000 minutes de tâches, selon ce qui arrive en premier, et ne demande pas de carte. Passez votre tâche Rust sur runs-on: skipbox, exécutez-la deux fois, et mettez les lignes Compiling de la deuxième exécution à côté de celles de GitHub.

FAQ

Swatinem/rust-cache met-il en cache les crates de mon espace de travail ?

Non, pas par défaut. Son README indique que les crates de l'espace de travail elles-mêmes ne sont pas mises en cache, et son étape d'enregistrement supprime leur sortie de build de target/ avant de téléverser le cache. Il met en cache ~/.cargo et la sortie de build de vos dépendances, et règle CARGO_INCREMENTAL=0 pour le reste de la tâche. Sur une VM GitHub neuve, chaque exécution à chaud recompile donc les crates de votre espace de travail, même avec un succès de cache complet. Dans la CI de tauri sur GitHub, cela faisait 32 lignes Compiling à chaque exécution à chaud.

Faut-il régler cache-workspace-crates: true ?

Cela met aussi vos crates dans le cache (rust-cache v2.8.0 et ultérieures), mais la clé de cache vient de votre chaîne d'outils, de votre environnement et de vos Cargo.lock et Cargo.toml, pas de votre code source. Une exécution dont la clé existe déjà saute l'enregistrement : la copie en cache de vos crates a donc l'âge du dernier enregistrement et s'éloigne de votre code à chaque commit. La compilation incrémentale reste désactivée. Vérifiez le log d'une exécution à chaud : si vos crates affichent encore Compiling, cela n'aide pas.

sccache règle-t-il la lenteur de la CI Rust sur GitHub Actions ?

Il aide pour les crates de bibliothèque dont les entrées n'ont pas changé. sccache ne peut pas mettre en cache les crates qui appellent l'éditeur de liens (crates bin, dylib, cdylib et proc-macro), et chaque succès de cache est un téléchargement depuis son stockage. Un target/ conservé entre les tâches n'a besoin d'aucun téléchargement : une crate que Cargo considère comme inchangée n'est pas compilée du tout.

Dois-je modifier mon workflow pour garder target/ sur Skipbox ?

Non. Remplacez runs-on par skipbox et laissez rust-cache et actions/checkout tels quels. Votre machine dédiée garde le checkout et le target/ de Cargo entre les tâches, et le nettoyage de checkout laisse les dossiers target/ tranquilles. Quand l'enregistrement de rust-cache supprime vos crates de target/, la machine les remet en place, et sa restauration n'écrit plus d'artefacts plus anciens par-dessus des plus récents. Dès la première exécution à chaud, les crates qui n'ont pas changé ne sont donc pas compilées.

Combien coûte l'essai ?

Rien. L'essai dure 7 jours ou 3 000 minutes de tâches, selon ce qui arrive en premier, sans carte. Passez votre tâche Rust sur runs-on: skipbox, exécutez-la deux fois, et comparez les lignes Compiling et les étapes de build de la deuxième exécution avec celles de GitHub.

Mis à jour le 19 novembre 2026

Une CI/CD plus rapide, avec un cache toujours chaud

Votre exécuteur toujours chaud, à prix fixe

Nous les hébergeons. Vous changez une ligne. 1/12 du coût de GitHub à pleine charge. Prix fixe : faites-le tourner toute la journée. 7× l'espace de cache de GitHub.

  • Sans carte
  • Se connecter avec GitHub
  • Résiliable à tout moment