Skipbox

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

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.

Waarom elke build koud begint

  • Een nieuwe VM per job. De runnerreferentie 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 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 en cachebeheer met GitHub Actions (in het Engels):

Welke backend je ook kiest, orden het Dockerfile 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:

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

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.

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 19 november 2026

Snellere CI/CD met een cache die altijd warm is

Je warme runner voor een vaste prijs

Wij hosten ze. Jij wijzigt één regel. 1/12 van wat GitHub kost bij volledig gebruik. Vaste prijs, dus draai de hele dag door. 7× de cacheruimte van GitHub.

  • Geen kaart nodig
  • Inloggen met GitHub
  • Op elk moment opzegbaar