# „No space left on device“ in GitHub Actions: finden, was die Festplatte füllt, Platz schaffen oder eine größere bekommen

> GitHub garantiert auf seinem Standard-Linux-Runner nur 14 GB freien Platz, und Docker-Images, wiederhergestellte Caches und Build-Verzeichnisse füllen ihn. Wie du siehst, was die Festplatte füllt, was du aus dem Runner-Image löschen kannst und woher eine größere Festplatte kommt: von den größeren Runnern von GitHub auf Team und Enterprise oder von der dedizierten Skipbox-Maschine mit 80 GB bei S, 160 GB bei M und 320 GB bei L zum Festpreis.

„No space left on device“ in GitHub Actions heißt, dass der Job mehr geschrieben hat, als auf dem Runner frei war, und auf dem Standard-Linux-Runner von GitHub sind das etwa 14 GB: Ein Maintainer der runner-images schrieb, dass GitHub „guarantee[s] only 14GB of free space for both private & public repos“, also für private und öffentliche Repositorys nur 14 GB freien Platz garantiert, weil die vorinstallierten Tools des Images den Rest belegen (die Auflistung eines Nutzers auf `ubuntu-latest`: 12 GB Android SDK, 8,5 GB gehosteter Tool-Cache, 5,5 GB GHC). Docker-Images, ein auf der Festplatte entpackter Cache und Build-Verzeichnisse füllen 14 GB schnell. Behebe es in dieser Reihenfolge: sehen, was die Festplatte füllt (`df -h`, `df -i`, `du`, `docker system df`), weniger schreiben, vorinstallierte Tools löschen, die der Job nicht nutzt, und passt es dann immer noch nicht, den Job auf einer größeren Festplatte ausführen. Die größeren Runner von GitHub haben 75 GB und mehr, nur auf GitHub Team und Enterprise Cloud.

Skipbox führt deine Jobs auf der dedizierten Maschine deines Kontos aus, mit 80 GB Festplatte bei S, 160 GB bei M und 320 GB bei L, zum Festpreis mit unbegrenzten Minuten. Die Caches, die es zwischen den Jobs behält, liegen auf dieser Festplatte, und es stutzt die ältesten davon zurück, wenn die Festplatte voll wird, also muss am Anfang eines Jobs nichts gelöscht werden.

- 80 GB Festplatte bei S, 160 GB bei M, 320 GB bei L, gegenüber etwa 14 GB frei auf dem Standard-Runner von GitHub
- Die Images und Layer von Docker und die Paket-Caches bleiben zwischen den Jobs auf dieser Festplatte
- Über 85 % nach einem Job wird die Festplatte auf 75 % zurückgestutzt, das am längsten Ungenutzte zuerst

**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-no-space-left-on-device-de)

## Wie viel Festplatte ein GitHub-Runner hat

[Von GitHub gehostete Runner](https://docs.github.com/en/actions/reference/runners/github-hosted-runners) nennt 14 GB SSD für den Standard-Linux-Runner, in privaten und öffentlichen Repositorys. In der [Diskussion #9329 der runner-images](https://github.com/actions/runner-images/discussions/9329), nachdem eine Image-Änderung den freien Platz auf Ubuntu-Runnern von über 31 GB auf über 17 GB gesenkt hatte, antwortete ein Maintainer: „We indeed guarantee only 14GB of free space for both private & public repos.“ Garantiert sind also nur 14 GB. Plane mit 14 GB.

Der Rest der Festplatte ist das Image. Im [Issue #10386](https://github.com/actions/runner-images/issues/10386) („Free space left: 72 MB“) zeigte das `du` eines Nutzers auf `ubuntu-latest`:

| Verzeichnis | Größe |
|---|---|
| `/usr/local/lib/android` | 12 GB |
| `/opt/hostedtoolcache` | 8,5 GB (CodeQL allein 5 GB) |
| `/usr/local/.ghcup` | 5,5 GB |

## 1. Sehen, was die Festplatte füllt

Füge nach dem fehlschlagenden Step einen hinzu, mit `if: always()`:

```yaml
- name: Disk usage
  if: always()
  run: |
    df -h
    df -i /
    sudo du -xh --max-depth=1 / 2>/dev/null | sort -rh | head -15
    docker system df || true
```

- `df -h` zeigt jedes Dateisystem und wie voll es ist. Achte darauf, wohin dein Job schreibt: in den Workspace, in die Daten von Docker unter `/var/lib/docker` oder ins Temp-Verzeichnis.
- `df -i` zeigt die Inodes. Einer Festplatte können die Inodes (einer pro Datei) ausgehen, obwohl noch Bytes frei sind, und der Fehler ist derselbe.
- `du` zeigt die größten Verzeichnisse.
- [`docker system df`](https://docs.docker.com/reference/cli/docker/system/df/) zeigt, wie viel die Images, Container, Volumes und der Build-Cache von Docker belegen.

## 2. Weniger schreiben

- **Docker zwischen den Builds aufräumen.** [`docker system prune`](https://docs.docker.com/reference/cli/docker/system/prune/) entfernt gestoppte Container, ungenutzte Netzwerke, verwaiste Images und ungenutzten Build-Cache; `-a` entfernt alle ungenutzten Images und `--volumes` auch anonyme Volumes.
- **Cachen, was sich lohnt.** Ein wiederhergestellter Cache wird auf der Festplatte des Runners entpackt, also belegt ein großes Cache-Archiv mehr Platz als sein Download. Teil es pro Job auf, oder lass weg, was sich schnell neu holen lässt.
- **Build-Verzeichnisse aufräumen**, die ein späterer Step nicht braucht, vor dem Step, der den Platz braucht.

## 3. Die vorinstallierten Tools löschen, die der Job nicht nutzt

Aus dem [Issue #2875](https://github.com/actions/runner-images/issues/2875) und #10386:

```yaml
- name: Free disk space
  run: |
    sudo rm -rf /usr/local/lib/android /usr/local/.ghcup /opt/hostedtoolcache/CodeQL
    sudo rm -rf /usr/share/dotnet /usr/local/share/boost
    df -h /
```

Zwei Kosten. Gigabytes zu löschen kostet bei jedem Lauf Zeit, weil die VM des nächsten Jobs sie wieder hat. Und `$AGENT_TOOLSDIRECTORY` (den ganzen gehosteten Tool-Cache) zu entfernen schafft mehr Platz, macht aber, wie der Autor von #2875 feststellte, die Tools kaputt, die Steps dort erwarten. Die Action [free-disk-space](https://github.com/marketplace/actions/free-disk-space-ubuntu) bündelt diese Löschungen; ihr Autor fügte die Option für den Tool-Cache nach dem Thread hinzu, mit dem Hinweis, dass sie „saves an extra 6GB“, also weitere 6 GB spart.

## 4. Den Job auf einer größeren Festplatte ausführen

| Runner | Festplatte | Wer ihn nutzen kann |
|---|---|---|
| Standard-Linux-Runner von GitHub | 14 GB SSD, etwa 14 GB frei | Alle |
| Größerer Runner von GitHub, 2 bis 96 vCPU | 75 GB bei 2 vCPU, 150 GB bei 4, 300 GB bei 8, bis zu 2.040 GB ([größere Runner](https://docs.github.com/en/actions/reference/runners/larger-runners)) | Organisationen auf GitHub Team und Enterprise Cloud, pro Minute ([über größere Runner](https://docs.github.com/en/actions/concepts/runners/larger-runners)) |
| Selbstgehosteter Runner | Was du ihm gibst; ein Runner, der zwischen den Jobs bestehen bleibt, füllt sich mit Images und alten Workspaces, wenn nichts ihn aufräumt | Alle, und du betreibst ihn |
| Dedizierte Skipbox-Maschine | 80 GB bei S, 160 GB bei M, 320 GB bei L, zurückgestutzt, wenn sie voll ist | Organisationen und persönliche Konten, Festpreis |

## Was Skipbox mit der Festplatte macht

Zu jedem Tarif gehört die dedizierte Maschine deines Kontos, die zwischen den Jobs bestehen bleibt, mit der Festplatte ihrer Größe:

- **Die Festplatte hat 80 GB bei S, 160 GB bei M, 320 GB bei L.**
- **Was darauf bleibt, ist dein Zustand:** die Images, Layer und der Build-Cache von Docker, `~/.npm`, der pnpm-Store, `~/.cache`, die Caches von Go, Gradle, Maven und Cargo und die Tools, die `setup-*` installiert hat. Was `actions/cache` speichert, bleibt neben der Maschine, bis zur Hälfte der Festplatte.
- **Sie läuft nicht voll.** Gelöscht wird erst, wenn die Festplatte nach einem Job zu mehr als 85 % voll ist. Dann wird sie auf 75 % zurückgestutzt, das am längsten Ungenutzte zuerst: verwaiste Images, dann der Build-Cache von Docker, dann ganze Paket-Caches und behaltene Builds. Nur wenn sie dann immer noch über 85 % liegt, wird die Maschine zurückgesetzt.
- **Mehr Festplatte ist ein Tarif höher.** Ein Job, der selbst Dutzende Gigabyte schreibt, etwa große Images oder ein großes Build-Verzeichnis, bekommt 160 GB auf M und 320 GB auf L.

| 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 |

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

## Der Wechsel ist eine Zeile

```yaml
jobs:
  build:
    runs-on: skipbox-8x16 # was ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      # the "Free disk space" step can go
      - run: docker build -t app .
```

`skipbox-8x16` läuft mit einem M-Tarif; `runs-on: skipbox` läuft auf S und in der Testphase.

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 Dateien mit Zugangsdaten im Home-Verzeichnis. „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, dem der Platz ausgeht

Die Testphase ist kostenlos für 7 Tage oder 3.000 Job-Minuten, je nachdem, was zuerst erreicht ist, und braucht keine Karte. Sie führt `runs-on: skipbox` auf der Maschine von S mit 80 GB aus. Verschieb den Job dorthin, streich den Step, der vorinstallierte Tools löscht, und führe ihn aus.

## FAQ

### Wie viel Festplattenplatz hat ein GitHub-Actions-Runner?

Die Doku von GitHub nennt 14 GB SSD für den Standard-Linux-Runner, in privaten und öffentlichen Repositorys gleichermaßen, und ein Maintainer der runner-images schrieb, dass GitHub für beide nur 14 GB freien Platz garantiert. Die Festplatte selbst ist größer, aber die vorinstallierten Tools des Runner-Images füllen den Rest, also plane mit 14 GB.

### Wie behebe ich No space left on device in GitHub Actions?

Sieh zuerst nach, was sie gefüllt hat: df -h für jedes Dateisystem, df -i für Inodes, sudo du -xh --max-depth=1 / für die größten Verzeichnisse und docker system df für die Images und den Build-Cache von Docker. Dann schreib weniger (Docker zwischen den Builds aufräumen, nur cachen, was sich lohnt), lösch vorinstallierte Tools, die der Job nicht nutzt (das Android SDK, GHC, CodeQL, .NET), und braucht der Job dann immer noch mehr, lass ihn auf einem Runner mit größerer Festplatte laufen.

### Was kann ich aus ubuntu-latest löschen, um Platz zu schaffen?

Tools, die der Job nicht nutzt. Nutzer in den Issues der runner-images von GitHub entfernen /usr/local/lib/android (12 GB in der Auflistung eines Nutzers), /usr/local/.ghcup, /opt/hostedtoolcache/CodeQL, /usr/share/dotnet und /usr/local/share/boost. $AGENT_TOOLSDIRECTORY zu entfernen gibt auch den gehosteten Tool-Cache frei, macht aber Setup-Steps kaputt, die ihre Tools dort erwarten. Gigabytes zu löschen kostet bei jedem Lauf Zeit.

### Haben die größeren Runner von GitHub mehr Festplatte?

Ja: 75 GB bei 2 vCPU, 150 GB bei 4, 300 GB bei 8, bis zu 2.040 GB bei 64 und 96 vCPU. Es gibt sie nur für Organisationen auf GitHub Team oder GitHub Enterprise Cloud, pro Minute berechnet.

### Wie viel Festplatte gibt Skipbox einem Job?

Die dedizierte Maschine deines Kontos hat 80 GB bei S, 160 GB bei M und 320 GB bei L. Die zwischen den Jobs behaltenen Caches teilen sich diese Festplatte: Nach einem Job, der sie zu mehr als 85 % gefüllt hinterlässt, wird sie auf 75 % zurückgestutzt, das am längsten Ungenutzte zuerst, also läuft sie nicht voll, wie es die Festplatte eines selbstgehosteten Runners tut. Einem Job, der selbst Dutzende Gigabyte schreibt, geben M und L den Platz.

### Was kostet es, das auszuprobieren?

Nichts. Die Testphase dauert 7 Tage oder 3.000 Job-Minuten, je nachdem, was zuerst erreicht ist, ohne Karte, auf der Maschine von S. Verschieb den Job, dem der Platz ausgeht, auf runs-on: skipbox und streich die Steps, die vorinstallierte Tools löschen.

Aktualisiert am 2026-11-19 · https://skipbox.dev/de/guides/github-actions-no-space-left-on-device
