# Cache warstw Dockera w GitHub Actions: dlaczego każdy build startuje na zimno i jak zachować warstwy

> Każde zadanie GitHub Actions startuje na nowej VM bez cache buildów Dockera i bez pobranych obrazów, a domyślny builder z setup-buildx-action startuje pusty. cache-to i cache-from z buildx (gha, registry, local) przywracają warstwy jako pobrania, w ramach 10 GB GitHuba. Runner, który trzyma cache buildów Dockera na swoim dysku, nie potrzebuje niczego z tego, za stałe $39 miesięcznie.

Cache warstw Dockera ginie przy każdym uruchomieniu GitHub Actions, bo każde zadanie na runnerze hostowanym przez GitHub startuje na nowej VM: bez cache buildów, bez pobranych obrazów. Domyślny builder z docker/setup-buildx-action (`docker-container`) też startuje pusty w każdym zadaniu i jest usuwany na jego końcu. Zwykle rozwiązuje się to eksportem cache przez buildx. `cache-to: type=gha,mode=max` i `cache-from: type=gha` trzymają warstwy w cache Actions GitHuba, 10 GB na repozytorium, wspólne z każdym innym cache; `type=registry` trzyma je w Twoim rejestrze; `type=local` w katalogu, który zapisujesz przez actions/cache. Każdy z nich zamienia przebudowę na wysyłanie i pobieranie przy każdym uruchomieniu.

Skipbox trzyma warstwy tam, gdzie działa build. Twoje zadania działają na dedykowanej maszynie Twojego konta, która zachowuje obrazy Dockera, warstwy i cache buildów między zadaniami, na dysku 80 GB w S, wobec 14 GB na runnerze GitHuba. `docker build` i `docker compose build` używają ponownie warstw z poprzedniego buildu, a obrazy pobrane przez compose są już na dysku. setup-buildx-action działa bez zmian, a jego builder też znajduje te warstwy. Zmień jedną linię, `runs-on: skipbox`, za stałe $39 miesięcznie, z minutami bez limitu.

- GitHub: nowa VM dla każdego zadania, więc przy każdym uruchomieniu brak warstw, brak obrazów i pusty builder buildx
- Skipbox: cache buildów Dockera i obrazy zostają na dysku Twojej maszyny, więc niezmienione warstwy nie są ani budowane od nowa, ani pobierane
- 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-docker-layer-cache-github-actions-pl)

## Dlaczego każdy build startuje na zimno

- **Nowa VM dla każdego zadania.** Według [dokumentacji runnerów](https://docs.github.com/en/actions/reference/runners/github-hosted-runners) GitHuba każdy runner hostowany przez GitHub to nowa maszyna wirtualna (VM) hostowana przez GitHub. Nie ma na niej niczego, co zbudowało albo pobrało poprzednie zadanie.
- **Pusty builder.** [docker/setup-buildx-action](https://github.com/docker/setup-buildx-action) domyślnie tworzy i uruchamia builder ze sterownikiem `docker-container`, a jego `cleanup` (domyślnie włączony) usuwa builder na końcu zadania.
- **14 GB dysku.** `ubuntu-latest` repozytorium prywatnego ma 2 CPU, 8 GB i 14 GB SSD. Duży obraz, jego cache buildów i archiwum cache do rozpakowania mogą wyczerpać miejsce („no space left on device”).

## Backendy cache buildx i ile kosztuje każdy z nich

Według stron Dockera [cache backends](https://docs.docker.com/build/cache/backends/) i [cache management with GitHub Actions](https://docs.docker.com/build/ci/github-actions/cache/):

| Backend | Gdzie trafiają warstwy | Co płaci każde uruchomienie | Ograniczenia |
|---|---|---|---|
| `type=gha` | Cache Actions GitHuba | Wysyła nowe warstwy, pobiera te, których potrzebuje | 10 GB na repozytorium razem z każdym innym cache, usuwane od najstarszych; domyślny scope `buildkit` jest nadpisywany przez każdy build; API cache GitHuba ogranicza tempo |
| `type=registry` | Osobny obraz cache w Twoim rejestrze | Pobiera cache z rejestru, wysyła nowy | Logowanie do rejestru z prawem zapisu; miejsce i ruch w rejestrze |
| `type=inline` | W samym obrazie | Pobiera obraz, żeby odczytać jego cache | Tylko `mode=min`: warstwy etapów pośrednich nie są zachowywane |
| `type=local` + actions/cache | Katalog zapisany przez actions/cache | Pobiera i rozpakowuje cały katalog, a potem go wysyła | Rośnie z każdym uruchomieniem, chyba że [`reset=true`](https://docs.docker.com/build/cache/backends/local/) (Buildx 0.35.0 i nowsze); liczy się do 10 GB |

Jakikolwiek backend wybierzesz, [ułóż Dockerfile](https://docs.docker.com/build/cache/optimize/) tak, żeby warstwy, które zmieniają się najrzadziej, były pierwsze: skopiuj plik blokady i zainstaluj zależności, zanim skopiujesz kod źródłowy. Inaczej każdy commit unieważnia warstwę instalacji i żaden cache jej nie przywróci.

`mode=min`, domyślny, zachowuje tylko warstwy obrazu końcowego. `mode=max` zachowuje warstwy każdego etapu, więc build wieloetapowy trafia częściej i więcej wysyła.

Typowa konfiguracja `type=gha`, z własnym scope dla każdego obrazu:

```yaml
- uses: docker/setup-buildx-action@v4
- uses: docker/build-push-action@v7
  with:
    context: .
    tags: app:ci
    load: true
    cache-from: type=gha,scope=app
    cache-to: type=gha,scope=app,mode=max
```

**Cache mounts nie przetrwają.** `RUN --mount=type=cache` (cache menedżera pakietów wewnątrz buildu) nie jest domyślnie zachowywany w cache GitHub Actions; dokumentacja Dockera odsyła do [buildkit-cache-dance](https://github.com/reproducible-containers/buildkit-cache-dance), żeby przenosić go do i z actions/cache, co oznacza kolejne pobieranie i wysyłanie przy każdym uruchomieniu.

## docker compose pobiera każdy obraz w każdym zadaniu

Testy integracyjne, które uruchamiają Postgresa, Redisa i kilka usług przez `docker compose up`, pobierają każdy obraz w każdym zadaniu, bo VM jest nowa. Na runnerach hostowanych przez GitHub dostępne opcje tylko przenoszą pobieranie:

- Zapisz obrazy przez `docker save` do pliku tar, zapisz go w cache przez actions/cache i wczytaj przez `docker load` w następnym zadaniu. Liczy się to do 10 GB, a samo wczytanie też zajmuje czas.
- Buduj obrazy usług przez buildx z jednym z powyższych backendów cache, co nadal zostawia obrazy bazowe do pobrania.

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

Każdy z powyższych backendów istnieje, bo builder zapomina. Demon Dockera, który zostaje między zadaniami, ma już na własnym dysku warstwy z poprzedniego buildu, jego cache mounts i każdy obraz, który pobrał. Nie ma czego eksportować, nie ma czego importować i nie ma 10 GB do dzielenia.

## Skipbox trzyma cache Dockera na Twojej maszynie

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

- **`docker build` i `docker compose build`** używają ponownie warstw z poprzedniego buildu, bez zmian w workflow.
- **Obrazy zostają na dysku.** `docker compose up` znajduje obrazy pobrane ostatnim razem; `docker compose pull` pobiera tylko warstwy, które się zmieniły.
- **Cache mounts zostają** razem z cache buildów Dockera, więc `RUN --mount=type=cache` zachowuje cache menedżera pakietów bez dodatkowego kroku.
- **docker/setup-buildx-action działa bez zmian.** Jego builder startuje od warstw, które poprzedni build Twojego repozytorium zostawił na maszynie, a `cache-from` i `cache-to` możesz usunąć. W naszym własnym uruchomieniu CI publicznego projektu na maszynie z 4 vCPU (19 listopada 2026, po jednym uruchomieniu) krok budujący obraz trwał 177 s za pierwszym razem i 4 s przy powtórce, a 31 kroków miało status CACHED.
- **Dysk:** nic nie jest usuwane, dopóki dysk nie będzie po zadaniu prawie pełny. Wtedy najpierw znikają wiszące obrazy, potem cache buildów używany najdawniej.

```yaml
jobs:
  build:
    runs-on: skipbox # was ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: docker/setup-buildx-action@v4
      - uses: docker/build-push-action@v7
        with:
          context: .
          tags: app:ci
          load: true
```

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 |

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

1. Zaloguj się do Skipbox przez GitHuba.
2. Zainstaluj aplikację Skipbox w GitHubie i wybierz repozytoria.
3. Zmień `runs-on` i zrób push.

Pierwsze zadanie buduje każdą warstwę. Drugie znajduje je 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, a także `~/.docker/config.json`, więc logowanie do rejestru nie przechodzi na następne zadanie. 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, jednorazowej maszynie, nigdy na Twojej.

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

## Wypróbuj na swoim buildzie Dockera

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ś build Dockera na `runs-on: skipbox`, uruchom go dwa razy i porównaj krok buildu drugiego uruchomienia z GitHubem.

## FAQ

### Dlaczego cache warstw Dockera ginie przy każdym uruchomieniu GitHub Actions?

Bo każde zadanie na runnerze hostowanym przez GitHub startuje na nowej VM, bez cache buildów i bez obrazów z poprzedniego uruchomienia. docker/setup-buildx-action dokłada do tego swoje: domyślnie tworzy builder docker-container, który startuje pusty i jest usuwany na końcu zadania. Każda warstwa jest więc budowana od nowa, chyba że eksportujesz cache przez cache-to i importujesz go przez cache-from albo uruchamiasz build na maszynie, która zachowuje cache buildów Dockera.

### Jak zapisać w cache warstwy Dockera w GitHub Actions?

Na runnerach hostowanych przez GitHub eksporterami cache z buildx: cache-from: type=gha i cache-to: type=gha,mode=max w docker/build-push-action trzymają warstwy w cache Actions GitHuba (10 GB na repozytorium, wspólne z każdym innym cache). type=registry trzyma je jako osobny obraz w Twoim rejestrze, a type=local w katalogu, który zapisujesz przez actions/cache. Przy type=gha daj każdemu obrazowi własny scope, bo domyślny scope jest nadpisywany przez każdy build. Na maszynie, która zachowuje dysk, docker build używa ponownie warstw bez żadnego eksportera.

### Dlaczego buildx z cache-to type=gha nadal jest wolny?

Bo warstwy nadal podróżują. Z mode=max każde uruchomienie wysyła każdą nową warstwę każdego etapu, a kolejne uruchomienie pobiera warstwy, których potrzebuje. Cache dzieli 10 GB GitHuba na repozytorium ze wszystkim innym, więc jest usuwany, a API cache GitHuba ogranicza tempo buildu, który wysyła za dużo żądań. Builder, który już ma warstwy na dysku, pomija oba kierunki.

### Jak sprawić, żeby docker compose nie pobierał tych samych obrazów w każdym zadaniu?

Na runnerze hostowanym przez GitHub się nie da, można tylko przenieść pobieranie: zapisz obrazy przez docker save do pliku tar, zapisz go w cache przez actions/cache i wczytaj przez docker load w następnym zadaniu. Liczy się to do tych samych 10 GB i przy każdym uruchomieniu oznacza pobranie i wczytanie. Na maszynie, która zachowuje dysk, obrazy pobrane przez compose ostatnim razem już tam są, a docker compose pull pobiera tylko warstwy, które się zmieniły.

### Czy muszę zmienić workflow, żeby zachować cache Dockera w Skipbox?

Tylko runs-on: maszyna Twojego konta zachowuje obrazy Dockera, warstwy i cache buildów między zadaniami. docker build i docker compose build używają ich ponownie, a docker/setup-buildx-action działa bez zmian: jego builder startuje od warstw, które poprzedni build Twojego repozytorium zostawił na maszynie. cache-from i cache-to możesz usunąć.

### 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ś build Dockera na runs-on: skipbox, uruchom go dwa razy i porównaj krok buildu drugiego uruchomienia z GitHubem.

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