Zum Inhalt springen

Rust Cargo in GitHub Actions beschleunigen

Zuletzt aktualisiert am

Um Rust und Cargo in GitHub Actions zu beschleunigen, cachen Sie das target-Verzeichnis und die Cargo-Registry mit Swatinem/rust-cache, schalten Sie die inkrementelle Kompilierung mit CARGO_INCREMENTAL=0 ab, führen Sie Tests mit cargo-nextest aus und stellen Sie dem Build mehr Kerne zur Verfügung. Rust-CI ist vor allem deshalb langsam, weil die Kompilierung der Abhängigkeiten aufwendig ist und auf jeder frischen VM erneut anfällt.

Dieser Leitfaden zeigt einen funktionierenden Workflow und erläutert die Abwägungen. Die allgemeine Variante finden Sie unter GitHub Actions beschleunigen.

Abhängigkeiten mit rust-cache cachen

Swatinem/rust-cache ist die gängige Wahl. Die README beschreibt, was gecacht wird: ~/.cargo (Registry, Cache, Git-Abhängigkeiten, installierte Binaries) und ./target (Build-Artefakte der Abhängigkeiten). Vor dem Speichern entfernt das Tool Dinge, die beim nächsten Mal nichts bringen: inkrementelle Artefakte, Workspace-Crates, nicht genutzte Abhängigkeiten und Dateien, die älter als eine Woche sind. So bleibt der Cache klein.

- uses: actions/checkout@v7
- uses: dtolnay/rust-toolchain@stable
- uses: Swatinem/rust-cache@v2

Wissenswerte Eingaben, alle aus der README:

  • shared-key: Verwenden Sie einen Schlüssel für Jobs, die dasselbe bauen, etwa build und test, damit sie einen Cache teilen. Ohne ihn ist die Job-ID Teil des Schlüssels.
  • workspaces: Ordnen Sie Workspaces Target-Verzeichnissen zu, zum Beispiel . -> target. Nötig bei nicht standardmäßigen Layouts.
  • save-if: Setzen Sie ${{ github.ref == 'refs/heads/main' }}, damit nur main den Cache schreibt und PRs ihn nur lesen. So füllen PR-Caches Ihr Kontingent nicht.
  • cache-on-failure: Auf true setzen, um den Cache auch bei einem fehlgeschlagenen Test zu speichern, damit ein roter Build den nächsten Lauf trotzdem vorwärmt.
  • cache-all-crates und cache-workspace-crates: Beide sind standardmäßig auf false gesetzt. Aktivieren Sie die zweite Option nur bei einem großen Workspace mit stabilen internen Crates.
- uses: Swatinem/rust-cache@v2
  with:
    shared-key: ci
    save-if: ${{ github.ref == 'refs/heads/main' }}
    cache-on-failure: true

Inkrementelle Kompilierung in der CI abschalten

Die inkrementelle Kompilierung spart auf einem Entwicklerrechner Zeit beim Neubauen, indem sie zusätzliche Daten auf der Festplatte ablegt. In der CI bauen Sie einmal aus einem weitgehend sauberen Zustand, daher entsteht dabei nur Mehraufwand und große Artefakte ohne Nutzen. Schalten Sie sie für den gesamten Job ab:

env:
  CARGO_INCREMENTAL: 0
  CARGO_TERM_COLOR: always
  RUSTFLAGS: "-D warnings"

rust-cache entfernt inkrementelle Daten bereits vor dem Speichern, aber CARGO_INCREMENTAL=0 spart zusätzlich deren Erzeugung. Betrachten Sie -D warnings als optional: Es lässt Warnungen den Build fehlschlagen, was eine Richtlinienentscheidung ist und die Build-Flags verändert. Halten Sie es deshalb in jedem Job, der einen Cache teilt, gleich.

Compiler-Caching mit sccache

mozilla-actions/sccache-action ergänzt eine zweite Ebene: sccache cacht einzelne rustc-Ausgaben. Setzen Sie laut README SCCACHE_GHA_ENABLED: "true" und RUSTC_WRAPPER: "sccache" in env und fügen Sie den Action-Schritt hinzu:

env:
  SCCACHE_GHA_ENABLED: "true"
  RUSTC_WRAPPER: "sccache"
steps:
  - uses: mozilla-actions/sccache-action@v0.0.11

sccache und rust-cache überschneiden sich. Verwenden Sie zuerst rust-cache. sccache hilft vor allem in diesen Fällen: ein großer Workspace, in dem eine Änderung an einem Crate viel von target ungültig macht, Builds vieler verschiedener Feature-Kombinationen oder ein Team mit einem gemeinsamen Remote-Speicher. Es hat Grenzen: Die Ausgabe der inkrementellen Kompilierung wird nicht gecacht (ein weiterer Grund für CARGO_INCREMENTAL=0), und manche Crate-Typen sind nicht cachebar. Messen Sie beide Varianten, bevor Sie den zusätzlichen Baustein behalten.

Tests mit cargo-nextest ausführen

cargo-nextest führt jeden Test in einem eigenen Prozess aus und verteilt sie auf alle Kerne. Bei Suiten mit vielen Test-Binaries ist es oft schneller als cargo test, und es unterstützt Partitionierung für Sharding. Die nextest-Dokumentation zeigt die Installation mit taiki-e/install-action:

- uses: taiki-e/install-action@v2
  with:
    tool: nextest
- run: cargo nextest run --workspace --profile ci

Beachten Sie, dass nextest keine Doctests ausführt. Behalten Sie cargo test --doc daher als eigenen Schritt. Für Sharding über Jobs hinweg bietet nextest --partition count:1/4 (sowie den Modus hash:); legen Sie den Index in einer Matrix ab. Siehe Test-Sharding in GitHub Actions.

Linker und Build-Profil

  • Schnellerer Linker. Das Linken läuft einkernig und ist bei großen Binaries langsam. Mit lld oder mold über RUSTFLAGS oder .cargo/config.toml lässt sich die Link-Zeit spürbar senken. Aktuelle stabile Toolchains auf x86_64-Linux liefern eventuell bereits standardmäßig einen schnelleren Linker aus. Prüfen Sie daher vor dem Hinzufügen von Flags die Release-Notes Ihrer Version.
  • Debug-Informationen. Setzen Sie für CI-Builds [profile.dev] debug = "line-tables-only" oder debug = false. Weniger Debug-Informationen bedeuten weniger zu schreiben und zu linken.
  • Erst prüfen, dann bauen. cargo clippy führt bereits eine Typprüfung durch. Führen Sie es in einem Job zusammen mit den Tests aus, statt cargo check und cargo build direkt hintereinander zu starten.
  • Release-Builds. Bauen Sie --release nur dort, wo Sie ausliefern. lto = "thin" ist günstiger als "fat".

Was mehr CPU-Kerne bringen

rustc parallelisiert über Crates und Codegen-Units, und nextest parallelisiert über Tests, sodass Rust bis zum Link-Schritt mit der Anzahl der Kerne skaliert. Unsere Benchmarks enthalten eine Rust-Zeile: React + Rust (Axum) + Postgres benötigte auf einem GitHub-gehosteten Runner 2m37s und auf compiler.dev 1m45s (1.5x). Gemessen wurde ein vollständiger CI-Lauf mit 10 Test-Shards und einer echten Datenbank, Stand 8. Oktober 2026. Das liegt unter den Werten der Go- und Gradle-Stacks, und ein warmer Cache trägt dazu bei: Ein gecachter Build hat nur noch wenig zu kompilieren.

Sie können Ihren eigenen Workflow testen, indem Sie eine Zeile zu runs-on: [self-hosted, Linux, compiler-ci] ändern. Siehe Preise und den Runner-Größen-Auswahl. Verwandt: die Rust-Vorlage, Caching in GitHub Actions und Docker-Layer-Caching für Container-Builds.

FAQ

Brauche ich sowohl rust-cache als auch sccache?

In der Regel nicht. Beginnen Sie mit rust-cache. Ergänzen Sie sccache, wenn große Workspaces oder viele Feature-Kombinationen noch zu viel neu bauen.

Warum CARGO_INCREMENTAL=0 in der CI setzen?

Inkrementelle Daten helfen bei wiederholten lokalen Neubauten. In der CI erhöhen sie Schreibvorgänge und Cache-Größe, ohne einem sauberen Build zu nutzen.

Ist cargo-nextest schneller als cargo test?

Oft bei Suiten mit vielen Tests, weil er die Tests über Kerne hinweg in separaten Prozessen verteilt. Doctests überspringt er, daher müssen diese separat ausgeführt werden.

Wie verhindere ich, dass PRs den Cache füllen?

Verwenden Sie save-if: ${{ github.ref == 'refs/heads/main' }} bei rust-cache, damit PRs den Cache nur wiederherstellen, aber nie speichern.

Diesen Rust-Build auf compiler.dev ausführen Keine Karte nötig · 200 kostenlose Minuten

Kostenlos testen