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

> Swatinem/rust-cache met en cache vos dépendances, pas les crates de votre espace de travail, et désactive la compilation incrémentale. Sur la VM neuve de GitHub, chaque tâche à chaud recompile donc vos propres crates. Un target/ conservé sur une machine qui reste règle le problème : la tâche CI de tauri est passée de 246 s à 53 s sur Skipbox, pour un prix fixe de $39 par mois.

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.

- La tâche CI de tauri : 246 s sur GitHub, 53 s sur Skipbox (4,6× plus rapide). Chaque exécution est publique
- Avec `target/` conservé, Cargo n'a compilé aucune des crates de tauri : son temps de build est passé de 62 s à moins de 2 s
- 20 000 minutes par mois sur 4 vCPU : $222 sur GitHub, $39 sur Skipbox

**GitHub Actions à prix fixe, minutes illimitées** Skipbox exécute vos tâches GitHub Actions sur votre propre machine dédiée : $39 par mois, quel que soit le nombre de minutes. Les couches Docker et les caches de dépendances restent d'une tâche à l'autre : la tâche suivante démarre tout de suite.

Un exécuteur de 4 vCPU, 20 000 minutes par mois: GitHub $222 → Skipbox $39. Vous économisez $183 chaque mois.

Le changement tient en une ligne : `runs-on: skipbox`.

[Commencer mon essai gratuit de 7 j](https://app.skipbox.dev/sign-in?ref=g-rust-cache-slow-rust-ci-fr)

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

D'après le [README de rust-cache](https://github.com/Swatinem/rust-cache#cache-details) 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) :

| Exécution à chaud | Lignes `Compiling` | Temps de build de Cargo | Tâche |
|---|---|---|---|
| [GitHub](https://github.com/skipbox-dev/tauri/actions/runs/43234522982) | 32 | 118 s | 271 s |
| [Skipbox, VM neuve](https://github.com/skipbox-dev/tauri/actions/runs/43291768486) | 32 | 62 s | 146 s |
| [Skipbox, machine dédiée au compte, 1re exécution à chaud](https://github.com/skipbox-dev/tauri/actions/runs/43340142076) | **0** | **environ 1,5 s** | **53 s** |
| [Skipbox, machine dédiée au compte, 2e exécution à chaud](https://github.com/skipbox-dev/tauri/actions/runs/43340289959) | **0** | **environ 1,9 s** | **53 s** |

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](https://github.com/skipbox-dev/tauri/actions/runs/43307552081)), 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](https://github.com/skipbox-dev/tauri/actions/runs/43339483384) pour tauri, [161 s](https://github.com/skipbox-dev/ripgrep/actions/runs/43340538466) pour ripgrep et [442 s](https://github.com/skipbox-dev/helix/actions/runs/43336739720) pour helix.

| Projet | GitHub | Skipbox, VM neuve | Skipbox, machine dédiée au compte | GitHub ÷ machine dédiée au compte |
|---|---|---|---|---|
| tauri | 246 s ([220](https://github.com/skipbox-dev/tauri/actions/runs/43233861304), [271](https://github.com/skipbox-dev/tauri/actions/runs/43234522982)) | 210 s ([273](https://github.com/skipbox-dev/tauri/actions/runs/43290912312), [146](https://github.com/skipbox-dev/tauri/actions/runs/43291768486)) | **53 s** ([53](https://github.com/skipbox-dev/tauri/actions/runs/43340142076), [53](https://github.com/skipbox-dev/tauri/actions/runs/43340289959)) | **4,6×** |
| ripgrep | 200 s ([194](https://github.com/skipbox-dev/ripgrep/actions/runs/43220584380), [206](https://github.com/skipbox-dev/ripgrep/actions/runs/43221108547)) | 156 s ([155](https://github.com/skipbox-dev/ripgrep/actions/runs/43292759363), [156](https://github.com/skipbox-dev/ripgrep/actions/runs/43293273127)) | **40 s** ([39](https://github.com/skipbox-dev/ripgrep/actions/runs/43340925562), [40](https://github.com/skipbox-dev/ripgrep/actions/runs/43341036341)) | **5,0×** |
| helix | 330 s ([293](https://github.com/skipbox-dev/helix/actions/runs/43227916673), [366](https://github.com/skipbox-dev/helix/actions/runs/43228816343)) | 350 s ([439](https://github.com/skipbox-dev/helix/actions/runs/43287815770), [260](https://github.com/skipbox-dev/helix/actions/runs/43289134146)) | **224 s** ([222](https://github.com/skipbox-dev/helix/actions/runs/43337749813), [226](https://github.com/skipbox-dev/helix/actions/runs/43338273330)) | **1,5×** |

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 :

| Projet | Langage | GitHub | Skipbox, machine dédiée au compte |
|---|---|---|---|
| [astro](https://github.com/skipbox-dev/astro/actions) | Node.js | 528 s | **30 s** |
| [vite](https://github.com/skipbox-dev/vite/actions) | Node.js | 141 s | 100 s |
| [prometheus](https://github.com/skipbox-dev/prometheus/actions) | Go | 335 s | 273 s |
| [cli](https://github.com/skipbox-dev/cli/actions) | Go | 163 s | 137 s |
| [pytest](https://github.com/skipbox-dev/pytest/actions) | Python | 416 s | 365 s |
| [guava](https://github.com/skipbox-dev/guava/actions) | Java | 818 s | 651 s |

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](https://github.com/skipbox-dev/astro/actions/runs/43351547473), [28 s](https://github.com/skipbox-dev/astro/actions/runs/43351638436)).

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 :

| Label | Machine | Forfait |
|---|---|---|
| `skipbox` | 4 vCPU · 16 Go | S, $39 par mois |
| `skipbox-8x16` | 8 vCPU · 16 Go | M, $79 par mois |
| `skipbox-16x32` | 16 vCPU · 32 Go | L, $149 par mois |

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

```yaml
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](https://docs.skipbox.dev/fr/isolation).

## 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 2026-11-19 · https://skipbox.dev/fr/guides/rust-cache-slow-rust-ci
