# „No space left on device” în GitHub Actions: află ce umple discul, eliberează-l sau ia unul mai mare

> GitHub garantează doar 14 GB de spațiu liber pe runnerul lui standard Linux, iar imaginile Docker, restaurările de cache și arborii de build îl umplu. Cum vezi ce umple discul, ce ștergi din imaginea runnerului și de unde iei un disc mai mare: runnerele mari GitHub pe Team și Enterprise sau mașina dedicată Skipbox, cu 80 GB pe S, 160 GB pe M și 320 GB pe L, la preț fix.

„No space left on device” în GitHub Actions înseamnă că jobul a scris mai mult decât avea liber runnerul, iar pe runnerul standard Linux al GitHub asta înseamnă cam 14 GB: un mentenant runner-images a scris că GitHub garantează doar 14 GB de spațiu liber atât pentru repository-urile private, cât și pentru cele publice, pentru că instrumentele preinstalate din imagine iau restul (listarea unui utilizator pe `ubuntu-latest`: 12 GB de Android SDK, 8,5 GB de cache de instrumente găzduite, 5,5 GB de GHC). Imaginile Docker, un cache restaurat și dezarhivat pe disc și arborii de build umplu repede 14 GB. Rezolvă în această ordine: vezi ce umple discul (`df -h`, `df -i`, `du`, `docker system df`), scrie mai puțin, șterge instrumentele preinstalate pe care jobul nu le folosește, iar dacă tot nu încape, rulează jobul pe un disc mai mare. Runnerele mari GitHub au de la 75 GB în sus, doar pe GitHub Team și Enterprise Cloud.

Skipbox îți rulează joburile pe mașina dedicată a contului tău, cu 80 GB de disc pe S, 160 GB pe M și 320 GB pe L, la preț fix, cu minute nelimitate. Cache-urile pe care le păstrează între joburi stau pe acel disc, iar Skipbox le reduce pe cele mai vechi când discul se umple, așa că nu trebuie șters nimic la începutul unui job.

- 80 GB de disc pe S, 160 GB pe M, 320 GB pe L, față de cam 14 GB liberi pe runnerul standard GitHub
- Imaginile și layerele Docker și cache-urile de pachete rămân pe acel disc între joburi
- Peste 85% după un job, discul e redus înapoi la 75%, începând cu ce a fost folosit cel mai demult

**GitHub Actions la preț fix, cu minute nelimitate** Skipbox rulează joburile tale GitHub Actions pe propria ta mașină dedicată: $39 pe lună, oricâte minute ai rula. Layerele Docker și cache-urile de dependențe rămân între joburi, așa că jobul următor pornește imediat.

Un runner de 4 vCPU, 20.000 de minute pe lună: GitHub $222 → Skipbox $39. Economisești $183 în fiecare lună.

E nevoie de o singură linie: `runs-on: skipbox`.

[Încearcă gratuit 7 zile](https://app.skipbox.dev/sign-in?ref=g-github-actions-no-space-left-on-device-ro)

## Cât disc are un runner GitHub

[Pagina despre runnerele găzduite de GitHub](https://docs.github.com/en/actions/reference/runners/github-hosted-runners) listează 14 GB de SSD pentru runnerul standard Linux, în repository-urile private și publice. În [discuția runner-images #9329](https://github.com/actions/runner-images/discussions/9329), după ce o schimbare de imagine a redus spațiul liber pe runnerele Ubuntu de la peste 31 GB la peste 17 GB, un mentenant a răspuns că GitHub garantează într-adevăr doar 14 GB de spațiu liber atât pentru repository-urile private, cât și pentru cele publice (în engleză). Socotește cu 14 GB.

Restul discului e imaginea. În [issue-ul #10386](https://github.com/actions/runner-images/issues/10386) („Free space left: 72 MB”), comanda `du` rulată de un utilizator pe `ubuntu-latest` a arătat:

| Director | Mărime |
|---|---|
| `/usr/local/lib/android` | 12 GB |
| `/opt/hostedtoolcache` | 8,5 GB (doar CodeQL, 5 GB) |
| `/usr/local/.ghcup` | 5,5 GB |

## 1. Vezi ce umple discul

Adaugă un pas după cel care eșuează, cu `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` arată fiecare sistem de fișiere și cât e de plin. Notează-l pe cel în care scrie jobul tău: workspace-ul, datele Docker din `/var/lib/docker` sau directorul temporar.
- `df -i` arată inodurile. Un disc poate rămâne fără inoduri (unul pe fișier) având încă bytes liberi, iar eroarea e aceeași.
- `du` arată cele mai mari directoare.
- [`docker system df`](https://docs.docker.com/reference/cli/docker/system/df/) arată cât ocupă imaginile, containerele, volumele și cache-ul de build Docker.

## 2. Scrie mai puțin

- **Curăță Docker între builduri.** [`docker system prune`](https://docs.docker.com/reference/cli/docker/system/prune/) elimină containerele oprite, rețelele nefolosite, imaginile neetichetate și cache-ul de build nefolosit; `-a` elimină toate imaginile nefolosite, iar `--volumes` și volumele anonime.
- **Pune în cache ce merită.** Un cache restaurat e dezarhivat pe discul runnerului, așa că o arhivă mare de cache ocupă mai mult loc decât descărcarea ei. Împarte-o pe joburi sau renunță la ce se aduce repede din nou.
- **Curăță arborii de build** de care un pas ulterior nu are nevoie, înaintea pasului care are nevoie de spațiu.

## 3. Șterge instrumentele preinstalate pe care jobul nu le folosește

Din [issue-ul #2875](https://github.com/actions/runner-images/issues/2875) și din #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 /
```

Două costuri. Ștergerea a gigabytes întregi durează la fiecare rulare, pentru că VM-ul jobului următor le are din nou. Iar ștergerea lui `$AGENT_TOOLSDIRECTORY` (tot cache-ul de instrumente găzduite) eliberează mai mult, dar, cum a descoperit autorul lui #2875, strică instrumentele pe care pașii se așteaptă să le găsească acolo. Action-ul [free-disk-space](https://github.com/marketplace/actions/free-disk-space-ubuntu) împachetează aceste ștergeri; autorul lui a adăugat opțiunea pentru cache-ul de instrumente după discuție, spunând că eliberează încă 6 GB.

## 4. Rulează jobul pe un disc mai mare

| Runner | Disc | Cine îl poate folosi |
|---|---|---|
| Runnerul standard Linux GitHub | 14 GB SSD, cam 14 GB liberi | Toată lumea |
| Runnerul mare GitHub, 2 până la 96 vCPU | 75 GB la 2 vCPU, 150 GB la 4, 300 GB la 8, până la 2.040 GB ([larger runners](https://docs.github.com/en/actions/reference/runners/larger-runners)) | Organizațiile pe GitHub Team și Enterprise Cloud, la minut ([despre runnerele mari](https://docs.github.com/en/actions/concepts/runners/larger-runners)) |
| Runner self-hosted | Cât îi dai; un runner păstrat între joburi se umple cu imagini și workspace-uri vechi dacă nu îl curăță ceva | Oricine, iar tu îl rulezi |
| Mașina dedicată Skipbox | 80 GB pe S, 160 GB pe M, 320 GB pe L, redus când e plin | Organizații și conturi personale, preț fix |

## Ce face Skipbox cu discul

Fiecare plan vine cu mașina dedicată a contului tău, păstrată între joburi, cu discul mărimii ei:

- **Discul are 80 GB pe S, 160 GB pe M, 320 GB pe L.**
- **Ce rămâne pe el e starea ta:** imaginile, layerele și cache-ul de build Docker, `~/.npm`, store-ul pnpm, `~/.cache`, cache-urile Go, Gradle, Maven și Cargo și instrumentele instalate de `setup-*`. Ce salvează `actions/cache` rămâne lângă mașină, până la jumătate din disc.
- **Nu se umple.** Nu se șterge nimic până când discul e plin peste 85% după un job. Atunci e redus înapoi la 75%, începând cu ce a fost folosit cel mai demult: imaginile neetichetate, apoi cache-ul de build Docker, apoi cache-uri întregi de pachete și builduri păstrate. Mașina e resetată doar dacă discul e tot peste 85%.
- **Mai mult disc e un plan mai sus.** Un job care scrie el însuși zeci de gigabytes, cum ar fi imagini mari sau un arbore de build mare, primește 160 GB pe M și 320 GB pe L.

| Etichetă | Mașină | Disc | Plan |
|---|---|---|---|
| `skipbox` | 4 vCPU · 16 GB | 80 GB | S, $39 pe lună |
| `skipbox-8x16` | 8 vCPU · 16 GB | 160 GB | M, $79 pe lună |
| `skipbox-16x32` | 16 vCPU · 32 GB | 320 GB | L, $149 pe lună |

Minutele sunt nelimitate. La 20.000 de minute pe lună pe 4 vCPU, GitHub facturează $222; Skipbox S costă $39.

## Mutarea înseamnă o singură linie

```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` rulează pe un plan M; `runs-on: skipbox` rulează pe S și în perioada de probă.

1. Conectează-te la Skipbox cu GitHub.
2. Instalează aplicația GitHub Skipbox și alege repository-urile.
3. Schimbă `runs-on` și fă push.

## Securitate

- Mașina este doar a contului tău. Niciun job al altei companii nu rulează pe ea.
- După fiecare job, credențialele runnerului, procesele și containerele sunt șterse, la fel și fișierele de credențiale din directorul home. „Curățare la fiecare job” îi dă în schimb fiecărui job o mașină nouă.
- Codul de la persoane fără acces de scriere (cum ar fi pull request-urile din forkuri) rulează pe un VM nou, care îți citește cache-urile, dar nu le poate modifica.

Detaliile sunt în [cum sunt izolate joburile](https://docs.skipbox.dev/ro/isolation).

## Încearcă pe jobul care rămâne fără disc

Perioada de probă este gratuită timp de 7 zile sau 3.000 de minute de job, oricare se termină mai întâi, și nu cere card. Rulează `runs-on: skipbox` pe mașina planului S, cu 80 GB. Mută jobul acolo, renunță la pasul care șterge instrumentele preinstalate și rulează-l.

## Întrebări frecvente

### Cât spațiu pe disc are un runner GitHub Actions?

Documentația GitHub listează 14 GB de SSD pentru runnerul standard Linux, atât în repository-urile private, cât și în cele publice, iar un mentenant runner-images a scris că GitHub garantează doar 14 GB de spațiu liber pentru amândouă. Discul în sine e mai mare, dar instrumentele preinstalate din imaginea runnerului umplu restul, așa că socotește cu 14 GB.

### Cum rezolv No space left on device în GitHub Actions?

Mai întâi vezi ce l-a umplut: df -h pentru fiecare sistem de fișiere, df -i pentru inoduri, sudo du -xh --max-depth=1 / pentru cele mai mari directoare și docker system df pentru imaginile și cache-ul de build Docker. Apoi scrie mai puțin (curăță Docker între builduri, pune în cache doar ce merită), șterge instrumentele preinstalate pe care jobul nu le folosește (Android SDK, GHC, CodeQL, .NET), iar dacă jobul tot are nevoie de mai mult, rulează-l pe un runner cu disc mai mare.

### Ce pot șterge din ubuntu-latest ca să eliberez spațiu pe disc?

Instrumentele pe care jobul nu le folosește. Utilizatorii din issue-urile GitHub runner-images șterg /usr/local/lib/android (12 GB în listarea unui utilizator), /usr/local/.ghcup, /opt/hostedtoolcache/CodeQL, /usr/share/dotnet și /usr/local/share/boost. Ștergerea lui $AGENT_TOOLSDIRECTORY eliberează și cache-ul de instrumente găzduite, dar strică pașii de setup care se așteaptă să-și găsească instrumentele acolo. Ștergerea a gigabytes întregi durează la fiecare rulare.

### Runnerele mari GitHub au mai mult spațiu pe disc?

Da: 75 GB la 2 vCPU, 150 GB la 4, 300 GB la 8, până la 2.040 GB la 64 și 96 vCPU. Sunt doar pentru organizațiile pe GitHub Team sau GitHub Enterprise Cloud și se facturează la minut.

### Cât spațiu pe disc îi dă Skipbox unui job?

Mașina dedicată a contului tău are 80 GB pe S, 160 GB pe M și 320 GB pe L. Cache-urile păstrate între joburi împart acel disc: după un job care îl lasă plin peste 85%, e redus înapoi la 75%, începând cu ce a fost folosit cel mai demult, așa că nu se umple cum se umple discul unui runner self-hosted. Pentru un job care scrie el însuși zeci de gigabytes, M și L îi dau spațiul.

### Cât costă să încerc?

Nimic. Perioada de probă durează 7 zile sau 3.000 de minute de job, oricare se termină mai întâi, fără card, pe mașina planului S. Mută jobul care rămâne fără disc pe runs-on: skipbox și renunță la pașii care șterg instrumentele preinstalate.

Actualizat pe 2026-11-16 · https://skipbox.dev/ro/guides/github-actions-no-space-left-on-device
