# Limit rozmiaru cache w GitHub Actions: dlaczego cache jest usuwany, wolno się przywraca albo chybia

> Cache GitHub Actions mieści 10 GB na repozytorium, po przekroczeniu usuwa wpisy czytane najdawniej i kasuje każdy wpis nieużywany przez 7 dni. Nawet trafienie to pobieranie na nową VM. Ile kosztuje każda poprawka i dlaczego runner, który zachowuje dysk, sprawia, że większość cache jest zbędna, za stałe $39 miesięcznie.

GitHub Actions daje każdemu repozytorium 10 GB cache. Gdy repozytorium go przekroczy, GitHub nadal zapisuje nowy wpis i usuwa wpisy czytane najdawniej, aż znowu zmieści się w limicie, a każdy wpis, którego żadne zadanie nie czytało przez 7 dni, kasuje. Gałąź czyta tylko własne cache i cache gałęzi domyślnej, więc pierwsze uruchomienie nowej gałęzi często chybia. A trafienie to wciąż pobieranie: każde zadanie na runnerze hostowanym przez GitHub startuje na nowej VM, więc znowu pobiera i rozpakowuje archiwum. Możesz podnieść limit, po 0,07 USD za GB miesięcznie ponad 10 GB, i dopracować klucze, ale pobieranie zostaje.

Skipbox usuwa pobieranie. Twoje zadania działają na dedykowanej maszynie Twojego konta, która zostaje między zadaniami, więc cache npm, pnpm, Gradle, Go i Cargo oraz warstwy Dockera są nadal na jej dysku z poprzedniego zadania (80 GB w S, wobec 14 GB na runnerze GitHuba). To, co zapisuje actions/cache, zostaje obok maszyny, więc przywrócenie to odczyt lokalny. Zmień jedną linię, `runs-on: skipbox`, za stałe $39 miesięcznie, z minutami bez limitu.

- GitHub: 10 GB na repozytorium, wpisy nieużywane przez 7 dni usuwane, każde trafienie pobierane od nowa
- Skipbox: cache pakietów i warstwy Dockera zostają na dysku Twojej maszyny, z co najmniej 7× większym miejscem na cache niż w GitHubie
- 20 000 minut miesięcznie na 4 vCPU: $222 w GitHubie, $39 w Skipbox

**GitHub Actions w stałej cenie, minuty bez limitu** Skipbox uruchamia Twoje zadania GitHub Actions na Twojej własnej, dedykowanej maszynie: $39 miesięcznie, niezależnie od liczby minut. Warstwy Dockera i cache zależności zostają między zadaniami, więc kolejne zadanie startuje od razu.

Runner 4 vCPU, 20 000 minut miesięcznie: GitHub $222 → Skipbox $39. Oszczędzasz $183 co miesiąc.

Przejście to jedna linia: `runs-on: skipbox`.

[Rozpocznij 7-dniowy okres próbny](https://app.skipbox.dev/sign-in?ref=g-github-actions-cache-size-limit-pl)

## Zasady cache w GitHubie

Według [dokumentacji cache zależności](https://docs.github.com/en/actions/reference/workflows-and-actions/dependency-caching), [rozliczania Actions](https://docs.github.com/en/billing/concepts/product-billing/github-actions) i wpisu w changelogu GitHuba o [cache ponad 10 GB](https://github.blog/changelog/2025-11-20-github-actions-cache-size-can-now-exceed-10-gb-per-repository/):

| Zasada | Co robi GitHub |
|---|---|
| Rozmiar | Domyślnie 10 GB na repozytorium, wspólne dla wszystkich gałęzi i workflowów |
| Po przekroczeniu | Zapisuje nowy wpis, potem usuwa wpisy według ostatniego dostępu, od najstarszych, aż repozytorium zmieści się w limicie. Usuwanie działa co godzinę |
| Nieużywane wpisy | Usuwa każdy wpis nieczytany przez ponad 7 dni |
| Większy limit | Na koncie Pro, Team albo Enterprise administratorzy mogą podnieść rozmiar i liczbę dni. Ponad 10 GB 0,07 USD za GB miesięcznie, według szczytu każdej godziny. Wyczerpany budżet sprawia, że cache jest tylko do odczytu do następnego cyklu rozliczeniowego |
| Gałęzie | Uruchomienie przywraca cache ze swojej gałęzi i z gałęzi domyślnej; uruchomienie pull requesta także z jego gałęzi bazowej. Nigdy z gałęzi równoległej ani podrzędnej |
| Pull requesty | Cache pull requesta jest przypisany do jego merge ref: czytają go tylko ponowne uruchomienia tego pull requesta |
| Wpisy | Nie można ich zmieniać. Klucz, który już istnieje, nie jest zapisywany ponownie |
| Trafienia | `cache-hit` ma wartość `true` tylko przy dokładnym dopasowaniu `key`; dopasowanie z `restore-keys` daje `false` |
| Tempo | Do 200 wysłań i 1500 pobrań na minutę na repozytorium |

## Dlaczego cache jest usuwany

Jedne 10 GB mieszczą wszystko, co zapisuje repozytorium. Każda gałąź i każdy pull request zapisuje własne wpisy. Macierz trzech wersji Node na dwóch systemach operacyjnych zapisuje sześć. Cache buildów Dockera `type=gha` trafia do tych samych 10 GB. Gdy zapisy z jednego dnia przekroczą limit, każdy nowy zapis usuwa starszy wpis, często ten, którego potrzebuje następne zadanie. GitHub nazywa to cache thrashing.

Żeby zobaczyć, co go zapełnia, wyświetl wpisy według rozmiaru:

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

Strona Actions › Caches repozytorium pokazuje to samo, z gałęzią i ostatnim użyciem każdego wpisu.

## Dlaczego przywracanie jest wolne

Trafienie cache na runnerze hostowanym przez GitHub to pobieranie na nową VM, a potem rozpakowanie. Jego czas rośnie razem z archiwum, więc cache, który urósł do kilku GB, może trwać tyle, co instalacja, którą miał pominąć. Zawieszone pobieranie przerywa limit czasu segmentu w actions/cache, domyślnie 10 minut (`SEGMENT_DOWNLOAD_TIMEOUT_MINS`).

Większość konfiguracji przywraca też mniej, niż się wydaje. Parametr `cache:` w [setup-node](https://github.com/actions/setup-node) zapisuje cache pobrań menedżera pakietów, nie `node_modules`: po przywróceniu `npm ci` i tak instaluje każdy pakiet. Z cache pip w setup-python jest tak samo: pobrania wracają, a środowisko jest instalowane od nowa.

## Dlaczego cache chybia

- **Zmienił się klucz.** Klucz z `hashFiles('**/package-lock.json')` chybia przy każdej zmianie pliku blokady. `restore-keys` daje częściowe dopasowanie, a `cache-hit` ma wtedy wartość `false`.
- **Nowa gałąź.** Może czytać cache gałęzi domyślnej, a nie innej gałęzi z funkcją. Jeśli gałąź domyślna nigdy nie uruchomiła workflow, nie ma czego czytać.
- **Usunięty.** Zabrał go limit albo 7 dni.
- **Nigdy się nie zapisał.** Wpisów nie można zmieniać, więc istniejący klucz nigdy nie jest zapisywany ponownie, a zawartość cache zostaje tak stara jak jego pierwszy zapis. Pull request z forka może w ogóle nie mieć prawa zapisu.

**Przekazywanie plików do następnego zadania tego samego uruchomienia** to inne narzędzie. Cache jest dla następnego uruchomienia; wyniki buildu, których potrzebuje późniejsze zadanie tego samego workflow, idą przez `actions/upload-artifact` i `actions/download-artifact`. Artefakty mają własne miejsce, poza 10 GB, i one też są pobieraniem na nową VM.

## Ile kosztuje każda poprawka na runnerach GitHuba

- **Podnieś limit.** Mniej usuwania, po 0,07 USD za GB miesięcznie ponad 10 GB (przykład samego GitHuba: w pełni wykorzystane 200 GB to 13,30 USD miesięcznie), na koncie Pro, Team albo Enterprise. Przywracanie zostaje pobieraniem, a większy cache dłużej się pobiera.
- **Zapisuj mniej.** Zapisuj w cache `~/.npm` albo magazyn pnpm, nie `node_modules` ani wyniki buildu. Zapisuj tylko na gałęzi domyślnej, z `actions/cache/restore` w każdym zadaniu i `actions/cache/save` w jednym. Kosztuje to Twój czas, a mniejszy cache przywraca mniej.
- **Popraw klucze.** Opieraj klucz na pliku blokady, dodaj `restore-keys` i uruchamiaj workflow przy pushach do gałęzi domyślnej, żeby nowe gałęzie miały co czytać.
- **Runner self-hosted, który zachowuje dysk.** Bez pobierania, bez 10 GB. Maszynę prowadzisz Ty: aktualizacje systemu, czyszczenie między zadaniami bez kasowania cache i naprawianie, gdy się zepsuje.

## Gdy rozwiązaniem jest maszyna, która zachowuje dysk

Cache istnieje, bo maszyna zapomina. Runner hostowany przez GitHub to nowa VM dla każdego zadania, więc zadanie zapisuje swój stan w magazynie GitHuba i następnym razem go pobiera. Na maszynie, która zostaje, ten stan jest już na jej dysku: cache menedżera pakietów, tool cache, obrazy Dockera i cache buildów, a nawet wyniki buildu.

Różnicę widać w CI prawdziwych projektów, według [naszych uruchomień ich własnych zadań](https://skipbox.dev/pl/guides/rust-cache-slow-rust-ci):

- **astro (Node.js, Turborepo):** 528 s w GitHubie, 30 s na dedykowanej maszynie Skipbox, która zachowuje cache turbo, więc ciepłe uruchomienia odtwarzają 40 zadań buildu, zamiast je wykonywać.
- **helix (Rust):** krok toolchainu i cache trwał 9-10 s na dedykowanej maszynie, wobec 41-46 s w GitHubie.
- **tauri (Rust):** 246 s w GitHubie, 53 s na dedykowanej maszynie, z `target/` zachowanym między zadaniami.

## Skipbox trzyma cache na Twojej maszynie

Każdy plan ma dedykowaną maszynę Twojego konta, która zostaje między zadaniami:

- **Cache pakietów zostają na dysku:** `~/.npm`, magazyn pnpm, `~/.cache` każdego narzędzia oraz cache Go, Gradle, Cargo i Mavena, razem z narzędziami zainstalowanymi przez `setup-*`. Nic do przywracania.
- **Obrazy Dockera, warstwy i cache buildów też zostają.** `docker build` używa ponownie warstw z poprzedniego buildu ([cache warstw Dockera](https://skipbox.dev/pl/guides/docker-layer-cache-github-actions)).
- **actions/cache, setup-* i rust-cache nie wymagają zmian.** To, co zapisują, zostaje obok maszyny zamiast w magazynie GitHuba, z większym miejscem niż 10 GB GitHuba na repozytorium, a przywrócenie czyta to lokalnie.
- **Bez wygasania po 7 dniach na dysku.** Nic nie jest usuwane, dopóki dysk nie będzie po zadaniu prawie pełny; wtedy najpierw znika to, co było używane najdawniej.

Co najmniej 7× więcej miejsca na cache niż w GitHubie, już w S. Zadanie wybiera rozmiar etykietą:

| Etykieta | Maszyna | Dysk | Plan |
|---|---|---|---|
| `skipbox` | 4 vCPU · 16 GB | 80 GB | S, $39 miesięcznie |
| `skipbox-8x16` | 8 vCPU · 16 GB | 160 GB | M, $79 miesięcznie |
| `skipbox-16x32` | 16 vCPU · 32 GB | 320 GB | L, $149 miesięcznie |

`ubuntu-latest` repozytorium prywatnego ma 2 CPU, 8 GB i 14 GB SSD. W Skipbox minuty są bez limitu. Przy 20 000 minut miesięcznie na 4 vCPU GitHub nalicza $222; Skipbox S to $39, o $183 mniej.

## Przejście to jedna linia

```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. Zaloguj się do Skipbox przez GitHuba.
2. Zainstaluj aplikację Skipbox w GitHubie i wybierz repozytoria.
3. Zmień `runs-on` i zrób push.

Zostaw kroki cache bez zmian. Drugie uruchomienie znajdzie cache pierwszego na maszynie.

## Bezpieczeństwo

- Maszyna należy tylko do Twojego konta. Nie działają na niej zadania żadnej innej firmy.
- Po każdym zadaniu usuwane są dane uwierzytelniające runnera, procesy i kontenery. Opcja **Nowa VM dla każdego zadania** daje zamiast tego każdemu zadaniu nową maszynę.
- Kod od osób bez uprawnień do zapisu (na przykład pull requesty z forków) działa na nowej VM, która czyta Twój cache, ale nie może go zmienić.

Szczegóły są w artykule [jak zadania są od siebie odizolowane](https://docs.skipbox.dev/pl/isolation).

## Wypróbuj na zadaniu, którego cache chybia

Okres próbny jest bezpłatny przez 7 dni lub 3000 minut zadań, zależnie od tego, co nastąpi wcześniej, i nie wymaga karty. Przenieś to zadanie na `runs-on: skipbox`, uruchom je dwa razy i porównaj kroki przywracania i instalacji drugiego uruchomienia z GitHubem.

## FAQ

### Jaki jest limit rozmiaru cache w GitHub Actions?

Domyślnie 10 GB na repozytorium, łącznie dla wszystkich gałęzi i workflowów. Po jego przekroczeniu GitHub nadal zapisuje nowy wpis i usuwa wpisy według ostatniego dostępu, od najstarszych, aż repozytorium znowu zmieści się w limicie. Wpisy, których żadne zadanie nie czytało przez 7 dni, są usuwane bez względu na rozmiar. Na koncie Pro, Team albo Enterprise administratorzy mogą podnieść limit i liczbę dni; miejsce ponad 10 GB jest naliczane po 0,07 USD za GB miesięcznie, według szczytu każdej godziny, a po wyczerpaniu budżetu cache staje się tylko do odczytu do następnego cyklu rozliczeniowego.

### Dlaczego mój cache GitHub Actions jest tak często usuwany?

Bo wszystko w repozytorium dzieli jedne 10 GB: każda gałąź, każdy pull request, każde zadanie macierzy i każdy system operacyjny zapisuje własne wpisy, a cache Dockera type=gha trafia w to samo miejsce. Gdy zapisy z jednego dnia przekroczą limit, każdy zapis usuwa starszy wpis, a następne zadanie chybia tego, którego potrzebowało. GitHub nazywa to cache thrashing. Wyświetl wpisy według rozmiaru (gh cache list --sort size_in_bytes), żeby zobaczyć, co go zapełnia.

### Dlaczego przywracanie cache trwa tyle, co instalacja od zera?

Bo trafienie to wciąż pobieranie. Każde zadanie na runnerze hostowanym przez GitHub startuje na nowej VM, więc actions/cache za każdym razem pobiera archiwum i je rozpakowuje, a im większy cache, tym dłużej to trwa. Cache z setup-node przywraca cache pobrań menedżera pakietów, nie node_modules, więc po przywróceniu npm ci i tak instaluje każdy pakiet. Na runnerze, który zachowuje dysk, cache już tam są i nic nie jest pobierane.

### Dlaczego actions/cache chybia na nowej gałęzi?

Uruchomienie może przywracać cache ze swojej gałęzi i z gałęzi domyślnej, a uruchomienie pull requesta także z jego gałęzi bazowej. Nie może czytać cache gałęzi równoległej. Pierwsze uruchomienie gałęzi z funkcją trafia więc tylko wtedy, gdy gałąź domyślna zapisała ten klucz. Uruchamiaj workflow przy pushach do gałęzi domyślnej, żeby zapisywał, i dodaj restore-keys dla częściowego dopasowania; cache-hit jest true tylko przy dokładnym dopasowaniu key.

### Ile cache Actions trzyma Skipbox?

Więcej niż 10 GB GitHuba na repozytorium, obok Twojej maszyny zamiast w magazynie GitHuba. Na maszynie w chmurze to, co zadania zapisują przez actions/cache, setup-* i rust-cache, zostaje na własnym dysku maszyny, do połowy tego dysku (80 GB w S, 160 GB w M, 320 GB w L); na hoście Skipbox cache hosta trzyma 20 GB na repozytorium. Tak czy inaczej wpis jest trzymany przez 7 dni od ostatniego użycia, z regułami gałęzi GitHuba. Cache pakietów i warstwy Dockera nie przechodzą przez niego: zostają na samym dysku.

### Co czyści cache na maszynie Skipbox?

Między zadaniami nic: cache zostają na maszynie, a dopiero gdy zadanie zostawi dysk prawie pełny, najpierw znika to, co było używane najdawniej. Maszyna startuje od zera przy resecie: gdy naciśniesz Zresetuj maszynę, gdy jej obraz zostanie zaktualizowany (co najmniej raz w miesiącu), gdy po zadaniu nie przejdzie kontroli stanu i gdy zadanie dojdzie do limitu 6 godzin. Gdy kończy się plan, maszyna jest usuwana razem z dyskiem.

### Ile kosztuje wypróbowanie?

Nic. Okres próbny trwa 7 dni lub 3000 minut zadań, zależnie od tego, co nastąpi wcześniej, bez karty. Przenieś zadanie, którego cache chybia albo wolno się przywraca, na runs-on: skipbox, uruchom je dwa razy i porównaj kroki przywracania i instalacji drugiego uruchomienia z GitHubem.

Zaktualizowano 2026-11-19 · https://skipbox.dev/pl/guides/github-actions-cache-size-limit
