# Docker-layercache in GitHub Actions: waarom elke build koud begint, en hoe je de layers bewaart

> Elke GitHub Actions-job start op een nieuwe VM zonder Docker-buildcache en zonder gepullde images, en de standaardbuilder van setup-buildx-action begint leeg. cache-to en cache-from van buildx (gha, registry, local) halen layers terug als downloads, binnen de 10 GB van GitHub. Een runner die de buildcache van Docker op zijn schijf bewaart, heeft niets daarvan nodig, voor een vaste $39 per maand.

De layercache van Docker gaat bij elke GitHub Actions-run verloren, omdat elke job op een door GitHub gehoste runner op een nieuwe VM start: geen buildcache, geen gepullde images. Ook de standaardbuilder van docker/setup-buildx-action (`docker-container`) begint in elke job leeg en wordt aan het eind verwijderd. De gebruikelijke oplossing is de cache exporteren met buildx. `cache-to: type=gha,mode=max` en `cache-from: type=gha` houden de layers in de Actions-cache van GitHub, 10 GB per repository en gedeeld met elke andere cache; `type=registry` houdt ze in je registry; `type=local` in een map die je opslaat met actions/cache. Elk daarvan maakt van een rebuild bij elke run een upload en een download.

Skipbox houdt de layers waar de build draait. Je jobs draaien op de dedicated machine van je account, die de images, layers en buildcache van Docker tussen jobs bewaart, op een schijf van 80 GB op S tegenover 14 GB op de runner van GitHub. `docker build` en `docker compose build` hergebruiken de layers van de vorige build, en images die compose pullde, staan al op de schijf. setup-buildx-action werkt zoals het is, en de builder vindt die layers ook. Wijzig één regel, `runs-on: skipbox`, voor een vaste $39 per maand met onbeperkte minuten.

- GitHub: een nieuwe VM per job, dus geen layers, geen images en bij elke run een lege buildx-builder
- Skipbox: de buildcache en images van Docker blijven op de schijf van je machine, dus ongewijzigde layers worden niet opnieuw gebouwd of gedownload
- 20.000 minuten per maand op 4 vCPU: $222 op GitHub, $39 op Skipbox

**GitHub Actions voor een vaste prijs, onbeperkte minuten** Skipbox draait je GitHub Actions-jobs op je eigen dedicated machine: $39 per maand, hoeveel minuten je ook draait. Docker-layers en dependencycaches blijven tussen jobs bewaard, dus de volgende job start meteen.

Een runner met 4 vCPU, 20.000 minuten per maand: GitHub $222 → Skipbox $39. Je bespaart elke maand $183.

Overstappen kost één regel: `runs-on: skipbox`.

[Gratis 7-daagse proefperiode starten](https://app.skipbox.dev/sign-in?ref=g-docker-layer-cache-github-actions-nl)

## Waarom elke build koud begint

- **Een nieuwe VM per job.** De [runnerreferentie](https://docs.github.com/en/actions/reference/runners/github-hosted-runners) van GitHub: elke door GitHub gehoste runner is een nieuwe virtuele machine (VM) die GitHub host. Niets wat de vorige job bouwde of pullde, staat erop.
- **Een lege builder.** [docker/setup-buildx-action](https://github.com/docker/setup-buildx-action) maakt en start standaard een builder met de driver `docker-container`, en zijn `cleanup` (standaard aan) verwijdert de builder aan het eind van de job.
- **14 GB schijf.** `ubuntu-latest` van een privé-repository heeft 2 CPU's, 8 GB en 14 GB SSD. Een grote image, de buildcache ervan en een cachearchief om uit te pakken kunnen de ruimte opmaken ("no space left on device").

## De cachebackends van buildx, en wat elk kost

Uit de documentatie van Docker over [cachebackends](https://docs.docker.com/build/cache/backends/) en [cachebeheer met GitHub Actions](https://docs.docker.com/build/ci/github-actions/cache/) (in het Engels):

| Backend | Waar de layers heen gaan | Wat elke run betaalt | Limieten |
|---|---|---|---|
| `type=gha` | De Actions-cache van GitHub | Uploadt nieuwe layers, downloadt de layers die hij nodig heeft | 10 GB per repository samen met elke andere cache, oudste eerst verwijderd; de standaardscope `buildkit` wordt door elke build overschreven; de cache-API van GitHub begrenst het aantal verzoeken |
| `type=registry` | Een aparte cache-image in je registry | Pullt de cache uit de registry, pusht de nieuwe | Een login bij de registry met pushrechten; de opslag en het verkeer van de registry |
| `type=inline` | In de image zelf | Pullt de image om de cache te lezen | Alleen `mode=min`: layers van tussenliggende stages worden niet bewaard |
| `type=local` + actions/cache | Een map die met actions/cache wordt opgeslagen | Downloadt en pakt de hele map uit, en uploadt hem daarna | Groeit bij elke run, tenzij [`reset=true`](https://docs.docker.com/build/cache/backends/local/) (Buildx 0.35.0 en later); telt mee voor de 10 GB |

Welke backend je ook kiest, [orden het Dockerfile](https://docs.docker.com/build/cache/optimize/) zo dat de layers die het minst veranderen eerst komen: kopieer de lockfile en installeer de dependencies voordat je de broncode kopieert. Anders maakt elke commit de installatielayer ongeldig, en brengt geen enkele cache hem terug.

`mode=min`, de standaard, bewaart alleen de layers van de uiteindelijke image. `mode=max` bewaart de layers van elke stage, dus een multi-stage build heeft meer hits, en uploadt meer.

Een gangbare opzet met `type=gha`, met een eigen scope per image:

```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 overleven het niet.** `RUN --mount=type=cache` (de cache van een packagemanager binnen de build) wordt standaard niet in de GitHub Actions-cache bewaard; de documentatie van Docker verwijst naar [buildkit-cache-dance](https://github.com/reproducible-containers/buildkit-cache-dance) om hem in en uit actions/cache te verplaatsen, weer een download en upload extra per run.

## docker compose pullt elke image, bij elke job

Integratietests die Postgres, Redis en een paar services starten met `docker compose up`, pullen bij elke job elke image, omdat de VM nieuw is. Op door GitHub gehoste runners verplaatsen de opties alleen de download:

- `docker save` de images naar een tar-bestand, cache het met actions/cache, en `docker load` het in de volgende job. Het telt mee voor de 10 GB, en het laden kost zelf ook tijd.
- Bouw de service-images met buildx en een van de cachebackends hierboven, waarbij de base-images nog steeds gepulld moeten worden.

## Wanneer de oplossing een machine is die de cache van Docker bewaart

Elke backend hierboven bestaat omdat de builder vergeet. Een Docker-daemon die tussen jobs blijft, heeft de layers van de vorige build, zijn cache mounts en elke image die hij pullde al op zijn eigen schijf. Er valt niets te exporteren, niets te importeren, en geen 10 GB te delen.

## Skipbox bewaart de cache van Docker op je machine

Elk abonnement komt met de dedicated machine van je account, die tussen jobs bewaard blijft:

- **`docker build` en `docker compose build`** hergebruiken de layers van de vorige build, zonder wijziging aan de workflow.
- **Images blijven op de schijf.** `docker compose up` vindt de images die hij de vorige keer pullde; `docker compose pull` haalt alleen layers op die veranderd zijn.
- **Cache mounts blijven** bij de buildcache van Docker, dus `RUN --mount=type=cache` houdt de cache van de packagemanager zonder extra step.
- **docker/setup-buildx-action werkt zoals het is.** De builder begint op de layers die de vorige build van je repository op de machine achterliet, en je kunt `cache-from` en `cache-to` weglaten. In onze eigen run van de CI van een openbaar project op een machine met 4 vCPU (19 november 2026, elk één run) duurde de step die de image bouwt 177 s bij de eerste run en 4 s bij de herhaling, met 31 steps CACHED.
- **Schijf:** er wordt niets verwijderd tot de schijf na een job bijna vol is. Dan gaan eerst de dangling images weg, daarna de buildcache die het langst geleden is gebruikt.

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

Een job kiest zijn grootte met zijn label:

| Label | Machine | Schijf | Abonnement |
|---|---|---|---|
| `skipbox` | 4 vCPU · 16 GB | 80 GB | S, $39 per maand |
| `skipbox-8x16` | 8 vCPU · 16 GB | 160 GB | M, $79 per maand |
| `skipbox-16x32` | 16 vCPU · 32 GB | 320 GB | L, $149 per maand |

De minuten zijn onbeperkt. Bij 20.000 minuten per maand op 4 vCPU rekent GitHub $222; Skipbox S is $39, $183 minder.

## Overstappen kost één regel

1. Log in bij Skipbox met GitHub.
2. Installeer de GitHub-app van Skipbox en kies de repository's.
3. Wijzig `runs-on` en push.

De eerste job bouwt elke layer. De tweede vindt ze op de machine.

## Beveiliging

- De machine is alleen van je account. Er draaien geen jobs van een ander bedrijf op.
- Na elke job worden de credentials, processen en containers van de runner gewist, en ook `~/.docker/config.json`, dus een login bij de registry gaat niet mee naar de volgende job. Met Schone VM per job krijgt elke job in plaats daarvan een nieuwe machine.
- Code van mensen zonder schrijfrechten (zoals pull requests vanuit forks) draait op een nieuwe wegwerpmachine, nooit op die van jou.

De details staan in [zo worden jobs geïsoleerd](https://docs.skipbox.dev/nl/isolation).

## Probeer het op je Docker-build

De proefperiode is gratis voor 7 dagen of 3.000 jobminuten, wat het eerst komt, en er is geen kaart voor nodig. Zet je Docker-build op `runs-on: skipbox`, draai hem twee keer, en leg de buildstep van de tweede run naast die van GitHub.

## Veelgestelde vragen

### Waarom gaat de Docker-layercache bij elke GitHub Actions-run verloren?

Omdat elke job op een door GitHub gehoste runner op een nieuwe VM start, zonder buildcache en zonder images van de vorige run. docker/setup-buildx-action maakt het erger: standaard maakt hij een docker-container-builder die leeg begint en aan het eind van de job wordt verwijderd. Elke layer wordt dus opnieuw gebouwd, tenzij je de cache exporteert met cache-to en importeert met cache-from, of draait op een machine die de buildcache van Docker bewaart.

### Hoe cache ik Docker-layers in GitHub Actions?

Op door GitHub gehoste runners met de cache-exporters van buildx: cache-from: type=gha en cache-to: type=gha,mode=max in docker/build-push-action slaan de layers op in de Actions-cache van GitHub (10 GB per repository, gedeeld met elke andere cache). type=registry slaat ze op als een aparte image in je registry, en type=local in een map die je opslaat met actions/cache. Geef elke image zijn eigen scope met type=gha, want de standaardscope wordt door elke build overschreven. Op een machine die zijn schijf bewaart, hergebruikt docker build de layers zonder exporter.

### Waarom is buildx met cache-to type=gha nog steeds traag?

Omdat de layers nog steeds reizen. Met mode=max uploadt elke run elke nieuwe layer van elke stage, en een latere run downloadt de layers die hij nodig heeft. De cache deelt de 10 GB per repository van GitHub met al het andere, dus hij wordt verdrongen, en de cache-API van GitHub begrenst een build die te veel verzoeken doet. Een builder die de layers al op zijn schijf heeft, slaat beide richtingen over.

### Hoe voorkom ik dat docker compose in elke job dezelfde images pullt?

Op een door GitHub gehoste runner kan dat niet, je kunt alleen de download verplaatsen: docker save de images naar een tar-bestand, cache het met actions/cache en docker load het in de volgende job. Dat telt mee voor dezelfde 10 GB en is bij elke run een download en een load. Op een machine die zijn schijf bewaart, staan de images die compose de vorige keer pullde er al, en haalt docker compose pull alleen layers op die veranderd zijn.

### Moet ik mijn workflow wijzigen om de cache van Docker op Skipbox te bewaren?

Alleen runs-on: de machine van je account bewaart de images, layers en buildcache van Docker tussen jobs. docker build en docker compose build hergebruiken ze, en docker/setup-buildx-action werkt zoals het is: de builder begint op de layers die de vorige build van je repository op de machine achterliet. Je kunt cache-from en cache-to weglaten.

### Hoeveel kost het om te proberen?

Niets. De proefperiode is 7 dagen of 3.000 jobminuten, wat het eerst komt, zonder kaart. Zet je Docker-build op runs-on: skipbox, draai hem twee keer, en vergelijk de buildstep van de tweede run met die van GitHub.

Bijgewerkt op 2026-11-19 · https://skipbox.dev/nl/guides/docker-layer-cache-github-actions
