Skipbox

Warum rust-cache deine Rust-CI nicht schnell macht (tauri: 246 s auf 53 s)

Swatinem/rust-cache, der Cache-Step in den meisten Rust-CIs, speichert deine Abhängigkeiten und lässt deine Workspace-Crates bewusst weg. Außerdem setzt es CARGO_INCREMENTAL=0. Auf den Runnern von GitHub startet jeder Job auf einer neuen VM, also kompiliert jeder warme Job, voller Cache-Treffer hin oder her, deine eigenen Crates erneut. Keine Einstellung von rust-cache ändert das. Was es ändert, ist ein target/, das vom letzten Job noch da ist: Cargo überspringt dann jedes Crate, das sich nicht geändert hat.

Skipbox behält es für dich. Dein Job läuft auf der dedizierten Maschine deines Kontos, die den Checkout und das target/ von Cargo zwischen den Jobs behält. Der CI-Job von tauri brauchte auf GitHub 246 s und dort 53 s, ohne ab dem ersten warmen Lauf eins seiner Crates zu kompilieren, ohne jede Änderung am Workflow außer runs-on: skipbox, pauschal für $39 im Monat.

Was rust-cache behält und was es weglässt

Aus der README von rust-cache und seinem Quellcode:

  • Was es cacht: ~/.cargo (die Registry, Git-Abhängigkeiten, installierte Binaries) und ./target mit der Build-Ausgabe deiner Abhängigkeiten.
  • Was es weglässt: „the workspace crates themselves are not cached“, die Workspace-Crates selbst werden also nicht gecacht. Vor dem Speichern löscht sein Aufräumen alles in target/, was keine Abhängigkeit ist, also werden die Artefakte deiner Crates aus target/ selbst entfernt.
  • Inkrementelle Kompilierung: Der Restore-Step exportiert CARGO_INCREMENTAL=0 für den Rest des Jobs.
  • Wann es speichert: nur, wenn noch kein Cache den Key des Jobs hat. Der Key ergibt sich aus der Toolchain, der Umgebung und deinen Cargo.lock und Cargo.toml. Deine Quelldateien gehören nicht dazu.

Auf einer frischen VM läuft das auf eins hinaus. Ein warmer Job stellt deine Abhängigkeiten wieder her und kompiliert dann deine Workspace-Crates und alles, was darauf aufbaut, komplett, jedes Mal.

Der Mechanismus, in den Logs von tauri

Der test-Job von tauri führt fünf cargo test-Steps auf Ubuntu aus, mit rust-cache. Hier seine warmen Läufe, jeder ein voller Cache-Treffer (full match: true im Log):

Die 32 Zeilen sind die eigenen Crates von tauri und zwei Plugins, die darauf aufbauen. Die Abhängigkeiten tauchen nie auf: Sie kommen aus dem Cache. Die Build-Zeit von Cargo sind die Finished … in-Zeiten der fünf Steps, zusammengezählt.

Die frische VM hat die CPUs der dedizierten Maschine und denselben Cache, und sie kompilierte dieselben 32 Crates wie GitHub: Ihr target/ enthielt nur, was der Cache wiederhergestellt hatte. Auf der dedizierten Maschine gibt schon der erste warme Lauf keine Compiling-Zeile aus. Cargo prüfte nur, dass sich nichts geändert hatte, und jedes Finished dauerte 0,2–0,7 s.

Der erste warme Lauf der dedizierten Maschine kompilierte früher alle 32 Crates erneut (ein Job mit 114 s), weil das Speichern von rust-cache nach dem kalten Lauf sie aus target/ gelöscht hatte. Seit dem 13. November 2026 machen dedizierte Maschinen rückgängig, was die Wiederherstellung und das Speichern von rust-cache von der Festplatte löschen, sobald der Step endet. Der gespeicherte Cache ist derselbe, und deine Crates bleiben in target/.

Job-Zeiten: drei Rust-Projekte, sechs andere

Die eigenen CI-Jobs echter Projekte auf einem festen Commit, die Steps Byte für Byte; geändert wurden nur der Trigger und runs-on. Ein kalter Lauf, dann zwei warme, auf jeder Seite:

  • GitHub: ubuntu-24.04, der Standard-Runner eines öffentlichen Repositorys: 4 vCPU, 16 GB.
  • Skipbox, frische VM: eine neue VM pro Job aus dem Produktions-Runner-Image, 4 vCPU und 8 GB, Caches über den Cache von Skipbox wiederhergestellt.
  • Skipbox, dedizierte Maschine: dieselbe Größe auf denselben Host-CPUs, zwischen den Jobs erhalten, mit dem Behalten und Löschen, das dedizierte Maschinen seit dem 13. November 2026 ausführen: Der Checkout und target/ bleiben, und was rust-cache löscht, wird zurückgelegt.

Die Skipbox-Läufe liefen auf einem Skipbox-Host, in einem Laborprojekt, das von den Maschinen der Kunden getrennt ist. Die Zeiten laufen vom Start jedes Jobs bis zu seinem Ende, aus der API von GitHub. Jede Zahl ist der Median der beiden warmen Läufe. Die kalten Läufe der dedizierten Maschine dauerten 285 s für tauri, 161 s für ripgrep und 442 s für helix.

ripgrep baut im Docker-Image von cross. cross legt target/ selbst an und markiert es mit „created by cross“. Dedizierte Maschinen hielten dieses target/ früher für etwas anderes als das von Cargo und löschten es nach jedem Job, also kompilierte Cargo bei jedem Lauf jedes Crate erneut (ein Job mit 108 s). Jetzt bleibt das target/ von cross erhalten: Die warmen Läufe geben keine Compiling-Zeile aus, und jedes Finished dauert 0,04–0,05 s. GitHub lädt außerdem bei jedem Lauf das Image von cross herunter (30 s im zweiten warmen Lauf); die dedizierte Maschine behält es auf der Festplatte.

Auch helix läuft 1,5× schneller. Von seinen Crates baut nur helix-term (und xtask, das davon abhängt) neu, weil das Build-Skript von helix-term bei jedem Job läuft: 16 s im test-Profil und 61 s im integration-Profil. Kein anderes Crate wird kompiliert. Der Großteil des Jobs von helix sind Tests: Allein die Integrationstest-Suite läuft 112 s. Sein Setup-Step, Toolchain und Cache-Wiederherstellung, dauerte 9–10 s gegenüber 41–46 s auf GitHub.

Die anderen Sprachen:

Bei astro ist es dieselbe Geschichte wie bei target/, mit Turborepo: Die dedizierte Maschine behält den Cache von turbo (turbo 2), also spielen seine warmen Läufe alle 40 Build-Tasks und die Test-Task daraus wieder ab, statt sie auszuführen (31 s, 28 s).

Das ubuntu-latest eines privaten Repositorys hat 2 CPUs und 8 GB: die Hälfte der Kerne der GitHub-Läufe oben.

Prüf deine eigene CI

  1. Öffne einen warmen Lauf deines Rust-Jobs, einen, dessen rust-cache-Step full match: true ins Log schreibt.
  2. Zähl in den Build- und Test-Steps die Compiling-Zeilen. Abhängigkeiten aus dem Cache geben keine aus. Jedes deiner Workspace-Crates gibt eine aus, ebenso jedes Crate, das darauf aufbaut.
  3. Zähl die Finished … in-Zeiten der Steps zusammen. Das kosten dich deine eigenen Crates bei jedem Lauf, und das spart ein behaltenes target/, wenn sie sich nicht geändert haben.

Was du auf den Runnern von GitHub tun kannst

  • cache-workspace-crates: true (ab rust-cache v2.8.0). Deine Crates kommen mit in den Cache. Aber ein Lauf, dessen Key existiert, überspringt das Speichern, und der Key ändert sich nicht mit deinem Quellcode, also sind die gecachten Crates so alt wie das letzte Speichern. Die inkrementelle Kompilierung bleibt aus, und der Cache wächst innerhalb der 10 GB von GitHub pro Repository.
  • sccache. Es cacht jede Kompilierung nach ihren Eingaben, also kommt ein unverändertes Library-Crate aus dem Speicher zurück. Crates, die den Linker aufrufen, lassen sich nicht cachen: Binaries, dylib-, cdylib- und proc-macro-Crates werden jedes Mal kompiliert, und jeder Treffer ist ein Download.
  • Ein selbstgehosteter Runner, der target/ behält. Du betreibst die Maschine: patchen, zwischen den Jobs aufräumen, ohne target/ zu löschen, und clean: false in actions/checkout setzen, dessen standardmäßiges git clean -ffdx target/ mit jeder anderen ignorierten Datei löscht.

Skipbox behält target/ für dich

Zu jedem Tarif gehört die dedizierte Maschine deines Kontos, die zwischen den Jobs bestehen bleibt. Seit dem 13. November 2026 behält sie deinen Checkout, mit den Zeitstempeln seiner Dateien, und das target/ von Cargo:

  • Das Aufräumen von actions/checkout läuft wie gewohnt, außer dass es die target/-Verzeichnisse von Cargo in Ruhe lässt.
  • rust-cache bleibt in deinem Workflow. Seine Wiederherstellung schreibt die älteren Artefakte des Caches nicht mehr über die neueren auf der Festplatte.
  • Was das Speichern und die Wiederherstellung von rust-cache aus target/ und ~/.cargo löschen, legt die Maschine zurück, sobald der Step endet. Der gespeicherte Cache ist derselbe, und ab dem Job nach dem kalten Lauf werden Crates, die sich nicht geändert haben, nicht kompiliert.
  • Das target/, das cross anlegt (markiert mit „created by cross“), bleibt ebenfalls erhalten.
  • actions/checkout schreibt .git/HEAD bei jedem Job neu. Solange die Datei noch denselben Commit nennt, bekommt sie ihren alten Zeitstempel zurück, also läuft ein Build-Skript, das .git/HEAD beobachtet (vergen tut das), nicht allein deshalb erneut.

Die Maschine behält auch Docker-Images, Paket-Caches und installierte Tools, also wird der Rest des Jobs mit schneller. Ein Job wählt seine Größe per Label:

Die Minuten sind unbegrenzt. Bei 20.000 Minuten im Monat auf 4 vCPU berechnet GitHub $222; Skipbox S kostet $39, $183 weniger.

Der Wechsel ist eine Zeile

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. Melde dich bei Skipbox mit GitHub an.
  2. Installiere die GitHub-App von Skipbox und wähle die Repositorys.
  3. Ändere runs-on und pushe.

Sicherheit

  • Die Maschine gehört nur deinem Konto. Keine Jobs eines anderen Unternehmens laufen darauf.
  • Nach jedem Job werden die Zugangsdaten, Prozesse und Container des Runners gelöscht, ebenso die Git-Zugangsdaten, Hooks und nicht versionierten Dateien im behaltenen Checkout. „Frische VM für jeden Job“ gibt stattdessen jedem Job eine frische Maschine.
  • Code von Personen ohne Schreibzugriff (etwa Pull Requests aus Forks) läuft auf einer frischen Maschine, die danach weggeworfen wird, ohne behaltenes target/.

Die Einzelheiten stehen unter Wie Jobs isoliert werden.

Probier es mit deinem Rust-Job

Die Testphase ist kostenlos für 7 Tage oder 3.000 Job-Minuten, je nachdem, was zuerst erreicht ist, und braucht keine Karte. Verschieb deinen Rust-Job auf runs-on: skipbox, führe ihn zweimal aus und leg die Compiling-Zeilen des zweiten Laufs neben die von GitHub.

FAQ

Cacht Swatinem/rust-cache meine Workspace-Crates?

Nein, nicht standardmäßig. Seine README sagt, dass die Workspace-Crates selbst nicht gecacht werden, und sein Save-Step löscht ihre Build-Ausgabe aus target/, bevor er den Cache hochlädt. Es cacht ~/.cargo und die Build-Ausgabe deiner Abhängigkeiten und setzt CARGO_INCREMENTAL=0 für den Rest des Jobs. Also kompiliert auf einer frischen GitHub-VM jeder warme Lauf deine Workspace-Crates erneut, selbst bei einem vollen Cache-Treffer. In der CI von tauri auf GitHub waren das bei jedem warmen Lauf 32 Compiling-Zeilen.

Sollte ich cache-workspace-crates: true setzen?

Es legt deine Crates mit in den Cache (ab rust-cache v2.8.0), aber der Cache-Key ergibt sich aus deiner Toolchain, deiner Umgebung und deinen Cargo.lock und Cargo.toml, nicht aus deinem Quellcode. Ein Lauf, dessen Key schon existiert, überspringt das Speichern, also ist die gecachte Kopie deiner Crates so alt wie das letzte Speichern und entfernt sich mit jedem Commit weiter von deinem Code. Die inkrementelle Kompilierung bleibt aus. Prüf das Log eines warmen Laufs: Zeigen deine Crates immer noch Compiling, hilft es nicht.

Behebt sccache langsame Rust-CI auf GitHub Actions?

Es hilft bei Library-Crates, deren Eingaben sich nicht geändert haben. sccache kann keine Crates cachen, die den Linker aufrufen (bin-, dylib-, cdylib- und proc-macro-Crates), und jeder Treffer ist ein Download aus seinem Cache-Speicher. Ein target/, das zwischen den Jobs erhalten bleibt, braucht keinen Download: Ein Crate, das Cargo als unverändert ansieht, wird gar nicht kompiliert.

Muss ich meinen Workflow ändern, damit target/ auf Skipbox erhalten bleibt?

Nein. Ändere runs-on auf skipbox und lass rust-cache und actions/checkout, wie sie sind. Deine dedizierte Maschine behält den Checkout und das target/ von Cargo zwischen den Jobs, und das Aufräumen von checkout lässt die target/-Verzeichnisse in Ruhe. Löscht das Speichern von rust-cache deine Crates aus target/, legt die Maschine sie zurück, und seine Wiederherstellung schreibt keine älteren Artefakte mehr über neuere. Also werden ab dem ersten warmen Lauf Crates, die sich nicht geändert haben, nicht kompiliert.

Was kostet es, das auszuprobieren?

Nichts. Die Testphase dauert 7 Tage oder 3.000 Job-Minuten, je nachdem, was zuerst erreicht ist, ohne Karte. Verschieb deinen Rust-Job auf runs-on: skipbox, führe ihn zweimal aus und vergleich die Compiling-Zeilen und Build-Steps des zweiten Laufs mit denen von GitHub.

Aktualisiert am 19. November 2026

Schnellere CI/CD mit immer warmem Cache

Dein warmer Runner zum Festpreis

Wir hosten sie. Du änderst eine Zeile. 1/12 der Kosten von GitHub bei voller Auslastung. Zum Festpreis den ganzen Tag laufen lassen. 7× so viel Cache-Speicher wie bei GitHub.

  • Keine Karte
  • Mit GitHub anmelden
  • Jederzeit kündbar