# Cache-Größenlimit in GitHub Actions: warum dein Cache verdrängt, langsam wiederhergestellt oder verfehlt wird

> Der Actions-Cache von GitHub fasst 10 GB pro Repository, löscht beim Überschreiten die am längsten nicht gelesenen Einträge und entfernt jeden Eintrag, der 7 Tage ungenutzt war. Selbst ein Treffer ist ein Download auf eine neue VM. Was jede Lösung kostet und warum ein Runner, der seine Festplatte behält, den Cache größtenteils überflüssig macht, pauschal für $39 im Monat.

GitHub Actions gibt jedem Repository 10 GB Cache. Überschreitet das Repository das, speichert GitHub den neuen Eintrag trotzdem und löscht die am längsten nicht gelesenen Einträge, bis es wieder unter dem Limit liegt, und es löscht jeden Eintrag, den 7 Tage lang kein Job gelesen hat. Ein Branch liest nur seine eigenen Caches und die des Default-Branches, also verfehlt der erste Lauf eines neuen Branches oft. Und ein Treffer ist trotzdem ein Download: Jeder Job auf einem von GitHub gehosteten Runner startet auf einer neuen VM, also lädt er das Archiv erneut herunter und entpackt es. Du kannst das Limit erhöhen, für $0,07 pro GB und Monat über 10 GB, und deine Keys feinjustieren, aber der Download bleibt.

Skipbox beseitigt den Download. Deine Jobs laufen auf der dedizierten Maschine deines Kontos, die zwischen den Jobs bestehen bleibt, also liegen die Caches von npm, pnpm, Gradle, Go und Cargo und die Docker-Layer noch vom letzten Job auf ihrer Festplatte (80 GB bei S, gegenüber 14 GB auf dem Runner von GitHub). Was actions/cache speichert, bleibt neben der Maschine, also ist eine Wiederherstellung ein lokales Lesen. Ändere eine Zeile, `runs-on: skipbox`, pauschal für $39 im Monat mit unbegrenzten Minuten.

- GitHub: 10 GB pro Repository, Einträge nach 7 Tagen ohne Nutzung gelöscht, jeder Treffer erneut heruntergeladen
- Skipbox: Paket-Caches und die Docker-Layer bleiben auf der Festplatte deiner Maschine, mit mindestens 7× so viel Cache-Speicher wie bei GitHub
- 20.000 Minuten im Monat auf 4 vCPU: $222 bei GitHub, $39 bei Skipbox

**GitHub Actions zum Festpreis, unbegrenzte Minuten** Skipbox führt deine GitHub-Actions-Jobs auf deiner eigenen dedizierten Maschine aus: $39 im Monat, egal wie viele Minuten du nutzt. Docker-Layer und Caches für Abhängigkeiten bleiben zwischen den Jobs erhalten, sodass der nächste Job sofort startet.

Ein Runner mit 4 vCPU, 20.000 Minuten im Monat: GitHub $222 → Skipbox $39. Du sparst jeden Monat $183.

Der Wechsel braucht eine Zeile: `runs-on: skipbox`.

[7-tägige Testphase kostenlos starten](https://app.skipbox.dev/sign-in?ref=g-github-actions-cache-size-limit-de)

## Die Cache-Regeln von GitHub

Aus der [Referenz zum Caching von Abhängigkeiten](https://docs.github.com/en/actions/reference/workflows-and-actions/dependency-caching) von GitHub, der [Abrechnung von Actions](https://docs.github.com/en/billing/concepts/product-billing/github-actions) und seinem Changelog zu [Caches über 10 GB](https://github.blog/changelog/2025-11-20-github-actions-cache-size-can-now-exceed-10-gb-per-repository/):

| Regel | Was GitHub tut |
|---|---|
| Größe | Standardmäßig 10 GB pro Repository, geteilt von allen Branches und Workflows |
| Über der Größe | Speichert den neuen Eintrag und löscht dann Einträge nach dem letzten Zugriff, die ältesten zuerst, bis das Repository unter dem Limit liegt. Die Verdrängung läuft stündlich |
| Ungenutzte Einträge | Löscht jeden Eintrag, der über 7 Tage nicht gelesen wurde |
| Ein höheres Limit | In einem Pro-, Team- oder Enterprise-Konto können Admins Größe und Tage erhöhen. Über 10 GB $0,07 pro GB und Monat, nach der Spitze jeder Stunde. Ein erreichtes Budget macht den Cache bis zum nächsten Abrechnungszeitraum schreibgeschützt |
| Branches | Ein Lauf stellt Caches aus seinem Branch und dem Default-Branch wieder her; der Lauf eines Pull Requests auch aus seinem Base-Branch. Nie aus einem Schwester- oder Unter-Branch |
| Pull Requests | Die Caches eines Pull Requests gelten für seine Merge-Ref: Nur erneute Läufe dieses Pull Requests lesen sie |
| Einträge | Lassen sich nicht ändern. Ein Key, den es schon gibt, wird nicht erneut gespeichert |
| Treffer | `cache-hit` ist nur bei einem exakten Treffer des `key` `true`; ein Treffer über `restore-keys` ist `false` |
| Rate | Bis zu 200 Uploads und 1.500 Downloads pro Minute und Repository |

## Warum der Cache verdrängt wird

Ein einziges Kontingent von 10 GB fasst alles, was das Repository speichert. Jeder Branch und jeder Pull Request speichert eigene Einträge. Eine Matrix aus drei Node-Versionen auf zwei Betriebssystemen speichert sechs. Der `type=gha`-Build-Cache von Docker landet in denselben 10 GB. Summieren sich die Speichervorgänge eines Tages über das Limit, löscht jedes neue Speichern einen älteren Eintrag, oft genau den, den der nächste Job braucht. GitHub nennt das Cache Thrashing.

Um zu sehen, was ihn füllt, liste die Einträge nach Größe auf:

```bash
gh cache list --sort size_in_bytes --limit 20
```

Die Seite Actions › Caches des Repositorys zeigt dasselbe, mit dem Branch und der letzten Nutzung jedes Eintrags.

## Warum die Wiederherstellung langsam ist

Ein Cache-Treffer auf einem von GitHub gehosteten Runner ist ein Download auf eine neue VM, gefolgt vom Entpacken. Die Zeit wächst mit dem Archiv, also kann ein Cache, der auf mehrere GB gewachsen ist, so lange dauern wie die Installation, die er ersparen sollte. Ein hängender Download wird vom Segment-Timeout von actions/cache abgebrochen, standardmäßig nach 10 Minuten (`SEGMENT_DOWNLOAD_TIMEOUT_MINS`).

Die meisten Setups stellen außerdem weniger wieder her, als man denkt. Die Eingabe `cache:` von [setup-node](https://github.com/actions/setup-node) speichert den Download-Cache des Paketmanagers, nicht `node_modules`: Nach dem Wiederherstellen installiert `npm ci` trotzdem jedes Paket. Beim pip-Cache von setup-python ist es genauso: Die Downloads kommen zurück, die Umgebung wird neu installiert.

## Warum der Cache verfehlt

- **Der Key hat sich geändert.** Ein Key mit `hashFiles('**/package-lock.json')` verfehlt bei jeder Änderung am Lockfile. `restore-keys` liefert einen Teiltreffer, und `cache-hit` ist dann `false`.
- **Ein neuer Branch.** Er kann die Caches des Default-Branches lesen, nicht die eines anderen Feature-Branches. Hat der Default-Branch den Workflow nie ausgeführt, gibt es nichts zu lesen.
- **Verdrängt.** Das Limit oder die 7 Tage haben ihn geholt.
- **Er wurde nie gespeichert.** Einträge lassen sich nicht ändern, also wird ein vorhandener Key nie erneut gespeichert, und der gecachte Inhalt bleibt so alt wie sein erstes Speichern. Ein Pull Request aus einem Fork darf womöglich gar nicht speichern.

**Dateien an den nächsten Job desselben Laufs weitergeben** ist ein anderes Werkzeug. Der Cache ist für den nächsten Lauf; Build-Ausgabe, die ein späterer Job desselben Workflows braucht, geht über `actions/upload-artifact` und `actions/download-artifact`. Artefakte haben ihren eigenen Speicher, getrennt von den 10 GB, und auch sie sind ein Download auf eine neue VM.

## Was jede Lösung auf den Runnern von GitHub kostet

- **Das Limit erhöhen.** Weniger Verdrängung, für $0,07 pro GB und Monat über 10 GB (das eigene Beispiel von GitHub: 200 GB voll genutzt kosten $13,30 im Monat), in einem Pro-, Team- oder Enterprise-Konto. Wiederherstellungen bleiben Downloads, und größere Caches brauchen länger zum Herunterladen.
- **Weniger speichern.** `~/.npm` oder den pnpm-Store cachen, nicht `node_modules` oder Build-Ausgabe. Nur auf dem Default-Branch speichern, mit `actions/cache/restore` in jedem Job und `actions/cache/save` in einem. Das kostet deine Zeit, und ein kleinerer Cache stellt weniger wieder her.
- **Die Keys reparieren.** Den Key am Lockfile festmachen, `restore-keys` ergänzen und den Workflow bei Pushes auf den Default-Branch laufen lassen, damit neue Branches etwas zu lesen haben.
- **Ein selbstgehosteter Runner, der seine Festplatte behält.** Kein Download, keine 10 GB. Du betreibst die Maschine: Betriebssystem-Updates, Aufräumen zwischen den Jobs, ohne die Caches zu löschen, und Reparieren, wenn sie ausfällt.

## Wenn die Lösung eine Maschine ist, die ihre Festplatte behält

Den Cache gibt es, weil die Maschine vergisst. Ein von GitHub gehosteter Runner ist für jeden Job eine neue VM, also speichert der Job seinen Zustand im Speicher von GitHub und holt ihn beim nächsten Mal zurück. Auf einer Maschine, die bleibt, liegt dieser Zustand schon auf ihrer Festplatte: der Cache des Paketmanagers, der Tool-Cache, die Images und der Build-Cache von Docker, sogar die Build-Ausgabe.

Der Unterschied zeigt sich in der CI echter Projekte, aus [unseren Läufen ihrer eigenen Jobs](https://skipbox.dev/de/guides/rust-cache-slow-rust-ci):

- **astro (Node.js, Turborepo):** 528 s bei GitHub, 30 s auf einer dedizierten Skipbox-Maschine, die den Cache von turbo behält, sodass ihre warmen Läufe 40 Build-Tasks wiederverwenden, statt sie auszuführen.
- **helix (Rust):** Der Step für Toolchain und Cache brauchte auf der dedizierten Maschine 9-10 s, gegenüber 41-46 s bei GitHub.
- **tauri (Rust):** 246 s bei GitHub, 53 s auf der dedizierten Maschine, mit `target/` zwischen den Jobs behalten.

## Skipbox behält den Cache auf deiner Maschine

Zu jedem Tarif gehört die dedizierte Maschine deines Kontos, die zwischen den Jobs bestehen bleibt:

- **Paket-Caches bleiben auf der Festplatte:** `~/.npm`, der pnpm-Store, das `~/.cache` jedes Tools und die Caches von Go, Gradle, Cargo und Maven, dazu die Tools, die `setup-*` installiert hat. Nichts wiederherzustellen.
- **Auch die Images, Layer und der Build-Cache von Docker bleiben.** `docker build` verwendet die Layer des letzten Builds wieder ([Docker-Layer-Cache](https://skipbox.dev/de/guides/docker-layer-cache-github-actions)).
- **actions/cache, setup-* und rust-cache brauchen keine Änderung.** Was sie speichern, bleibt neben der Maschine statt im Speicher von GitHub, mit mehr Platz als die 10 GB pro Repository bei GitHub, und eine Wiederherstellung liest es lokal.
- **Kein Ablauf nach 7 Tagen auf der Festplatte.** Gelöscht wird erst, wenn die Festplatte nach einem Job fast voll ist; dann geht zuerst, was am längsten ungenutzt war.

Mindestens 7× so viel Cache-Speicher wie bei GitHub schon auf S. Ein Job wählt seine Größe per Label:

| Label | Maschine | Festplatte | Tarif |
|---|---|---|---|
| `skipbox` | 4 vCPU · 16 GB | 80 GB | S, $39 im Monat |
| `skipbox-8x16` | 8 vCPU · 16 GB | 160 GB | M, $79 im Monat |
| `skipbox-16x32` | 16 vCPU · 32 GB | 320 GB | L, $149 im Monat |

Das `ubuntu-latest` eines privaten Repositorys hat 2 CPUs, 8 GB und 14 GB SSD. Auf Skipbox sind die Minuten unbegrenzt. Bei 20.000 Minuten im Monat auf 4 vCPU berechnet GitHub $222; Skipbox S kostet $39, $183 weniger.

## Der Wechsel ist eine Zeile

```yaml
jobs:
  test:
    runs-on: skipbox # was ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: 22
          cache: npm
      - run: npm ci && npm test
```

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.

Lass deine Cache-Steps, wie sie sind. Der zweite Lauf findet die Caches des ersten auf der Maschine.

## 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. „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 VM, die deine Caches liest, aber nicht ändern kann.

Die Einzelheiten stehen unter [Wie Jobs isoliert werden](https://docs.skipbox.dev/de/isolation).

## Probier es mit dem Job, dessen Cache verfehlt

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

## FAQ

### Wie groß ist das Cache-Limit von GitHub Actions?

Standardmäßig 10 GB pro Repository, für alle Branches und Workflows zusammen. Darüber speichert GitHub den neuen Eintrag trotzdem und löscht Einträge nach dem letzten Zugriff, die ältesten zuerst, bis das Repository wieder unter dem Limit liegt. Einträge, die 7 Tage lang kein Job gelesen hat, werden unabhängig von der Größe gelöscht. In einem Pro-, Team- oder Enterprise-Konto können Admins das Limit und die Tage erhöhen; Speicher über 10 GB wird mit $0,07 pro GB und Monat berechnet, gemessen an der Spitze jeder Stunde, und ist ein Budget erreicht, wird der Cache bis zum nächsten Abrechnungszeitraum schreibgeschützt.

### Warum wird mein GitHub-Actions-Cache so oft verdrängt?

Weil sich alles im Repository dieselben 10 GB teilt: Jeder Branch, jeder Pull Request, jeder Matrix-Job und jedes Betriebssystem speichert eigene Einträge, und der type=gha-Cache von Docker landet am selben Ort. Summieren sich die Speichervorgänge eines Tages über das Limit, löscht jedes Speichern einen älteren Eintrag, und der nächste Job verfehlt den, den er gebraucht hätte. GitHub nennt das Cache Thrashing. Liste die Einträge nach Größe auf (gh cache list --sort size_in_bytes), um zu sehen, was ihn füllt.

### Warum dauert das Wiederherstellen des Caches so lange wie eine Installation von null?

Weil ein Treffer trotzdem ein Download ist. Jeder Job auf einem von GitHub gehosteten Runner startet auf einer neuen VM, also lädt actions/cache das Archiv jedes Mal herunter und entpackt es, und je größer der Cache, desto länger dauert das. Der Cache von setup-node bringt den Download-Cache des Paketmanagers zurück, nicht node_modules, also installiert npm ci nach dem Wiederherstellen trotzdem jedes Paket. Auf einem Runner, der seine Festplatte behält, sind die Caches schon da, und nichts wird heruntergeladen.

### Warum verfehlt actions/cache auf einem neuen Branch?

Ein Lauf kann Caches aus seinem eigenen Branch und aus dem Default-Branch wiederherstellen, der Lauf eines Pull Requests auch aus seinem Base-Branch. Die Caches eines Schwester-Branches kann er nicht lesen. Der erste Lauf eines Feature-Branches trifft also nur, wenn der Default-Branch diesen Key gespeichert hat. Lass den Workflow bei Pushes auf den Default-Branch laufen, damit er speichert, und ergänze restore-keys für einen Teiltreffer; cache-hit ist nur bei einem exakten Treffer des key true.

### Wie viel Actions-Cache behält Skipbox?

Mehr als die 10 GB pro Repository bei GitHub, neben deiner Maschine statt im Speicher von GitHub. Auf einer Cloud-Maschine bleibt, was Jobs mit actions/cache, setup-* und rust-cache speichern, auf der eigenen Festplatte der Maschine, bis zur Hälfte dieser Festplatte (80 GB bei S, 160 GB bei M, 320 GB bei L); auf einem Skipbox-Host behält der Cache des Hosts 20 GB pro Repository. So oder so bleibt ein Eintrag 7 Tage nach seiner letzten Nutzung erhalten, mit den Branch-Regeln von GitHub. Paket-Caches und die Docker-Layer laufen nicht darüber: Sie bleiben direkt auf der Festplatte.

### Was leert die Caches auf einer Skipbox-Maschine?

Zwischen den Jobs nichts: Die Caches bleiben auf der Maschine, und erst wenn ein Job die Festplatte fast voll hinterlässt, geht zuerst, was am längsten ungenutzt war. Sauber neu startet die Maschine bei einem Zurücksetzen: wenn du auf „Maschine zurücksetzen“ drückst, wenn ihr Image aktualisiert wird (mindestens einmal im Monat), wenn sie nach einem Job ihren Health Check nicht besteht und wenn ein Job das Limit von 6 Stunden erreicht. Mit dem Ende des Tarifs wird die Maschine samt Festplatte gelöscht.

### 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 den Job, dessen Cache verfehlt oder langsam wiederhergestellt wird, auf runs-on: skipbox, führe ihn zweimal aus und vergleiche die Wiederherstellungs- und Installations-Steps des zweiten Laufs mit denen von GitHub.

Aktualisiert am 2026-11-19 · https://skipbox.dev/de/guides/github-actions-cache-size-limit
