Skipbox

Limiet van de GitHub Actions-cache: waarom je cache wordt verdrongen, traag terugkomt of mist

GitHub Actions geeft elke repository 10 GB cache. Komt de repository daarboven, dan slaat GitHub het nieuwe item toch op en verwijdert het de items die het langst geleden zijn gelezen tot hij weer onder de limiet zit, en het verwijdert elk item dat 7 dagen door geen job is gelezen. Een branch leest alleen zijn eigen caches en die van de standaardbranch, dus de eerste run van een nieuwe branch mist vaak. En een hit is nog steeds een download: elke job op een door GitHub gehoste runner start op een nieuwe VM, dus hij downloadt het archief opnieuw en pakt het uit. Je kunt de limiet verhogen, voor $0,07 per GB per maand boven 10 GB, en je keys afstellen, maar de download blijft.

Skipbox haalt de download weg. Je jobs draaien op de dedicated machine van je account, die tussen jobs bewaard blijft, dus de caches van npm, pnpm, Gradle, Go en Cargo en de layers van Docker staan nog op de schijf van de vorige job (80 GB op S, tegenover 14 GB op de runner van GitHub). Wat actions/cache opslaat, blijft naast de machine, dus terugzetten is lokaal lezen. Wijzig één regel, runs-on: skipbox, voor een vaste $39 per maand met onbeperkte minuten.

De cacheregels van GitHub

Uit de referentie over dependency caching van GitHub, Actions-facturering en de changelog over caches boven 10 GB (in het Engels):

Waarom de cache wordt verdrongen

Eén keer 10 GB houdt alles vast wat de repository opslaat. Elke branch en elke pull request slaat zijn eigen items op. Een matrix van drie Node-versies op twee besturingssystemen slaat er zes op. De type=gha-buildcache van Docker komt in dezelfde 10 GB terecht. Tellen de opslagen van een dag op tot meer dan de limiet, dan verwijdert elke nieuwe opslag een ouder item, vaak het item dat de volgende job nodig heeft. GitHub noemt dat cache thrashing.

Toon de items op grootte om te zien wat hem vult:

gh cache list --sort size_in_bytes --limit 20

De pagina Actions › Caches van de repository toont hetzelfde, met de branch en het laatste gebruik van elk item.

Waarom het terugzetten traag is

Een cache hit op een door GitHub gehoste runner is een download naar een nieuwe VM, en daarna uitpakken. De tijd groeit met het archief, dus een cache die is gegroeid tot een paar GB kan net zo lang duren als de installatie die hij moest overslaan. Een vastgelopen download wordt afgebroken door de segmenttime-out van actions/cache, standaard 10 minuten (SEGMENT_DOWNLOAD_TIMEOUT_MINS).

De meeste opzetten zetten ook minder terug dan mensen denken. De invoer cache: van setup-node slaat de downloadcache van de packagemanager op, niet node_modules: na het terugzetten installeert npm ci nog steeds elk package. De pip-cache van setup-python is hetzelfde: de downloads komen terug, de omgeving wordt opnieuw geïnstalleerd.

Waarom de cache mist

  • De key is veranderd. Een key met hashFiles('**/package-lock.json') mist bij elke wijziging van de lockfile. restore-keys geeft een gedeeltelijke match, en cache-hit staat dan op false.
  • Een nieuwe branch. Hij kan de caches van de standaardbranch lezen, niet die van een andere featurebranch. Heeft de standaardbranch de workflow nooit gedraaid, dan valt er niets te lezen.
  • Verdrongen. De limiet of de 7 dagen hebben hem weggehaald.
  • Hij is nooit opgeslagen. Items kunnen niet worden gewijzigd, dus een key die bestaat, wordt nooit opnieuw opgeslagen, en de gecachte inhoud blijft zo oud als zijn eerste opslag. Een pull request vanuit een fork mag soms helemaal niet opslaan.

Bestanden doorgeven aan de volgende job van dezelfde run is een ander gereedschap. De cache is voor de volgende run; builduitvoer die een latere job van dezelfde workflow nodig heeft, gaat via actions/upload-artifact en actions/download-artifact. Artifacts hebben hun eigen opslag, los van de 10 GB, en ook dat is een download naar een nieuwe VM.

Wat elke fix kost op de runners van GitHub

  • Verhoog de limiet. Minder verdringing, voor $0,07 per GB per maand boven 10 GB (het eigen voorbeeld van GitHub: 200 GB helemaal gebruikt is $13,30 per maand), op een Pro-, Team- of Enterprise-account. Terugzetten blijft downloaden, en grotere caches doen er langer over.
  • Sla minder op. Cache ~/.npm of de pnpm-store, niet node_modules of builduitvoer. Sla alleen op de standaardbranch op, met actions/cache/restore in elke job en actions/cache/save in één. Het kost je tijd, en een kleinere cache zet minder terug.
  • Repareer de keys. Baseer de key op de lockfile, voeg restore-keys toe, en draai de workflow bij pushes naar de standaardbranch, zodat nieuwe branches iets hebben om te lezen.
  • Een self-hosted runner die zijn schijf bewaart. Geen download, geen 10 GB. Jij draait de machine: OS-updates, opruimen tussen jobs zonder de caches te wissen, en hem repareren als hij stukgaat.

Wanneer de oplossing een machine is die zijn schijf bewaart

De cache bestaat omdat de machine vergeet. Een door GitHub gehoste runner is voor elke job een nieuwe VM, dus de job slaat zijn toestand op in de opslag van GitHub en haalt hem de volgende keer terug. Op een machine die blijft, staat die toestand al op de schijf: de cache van de packagemanager, de toolcache, de images en buildcache van Docker, zelfs de builduitvoer.

Het verschil is te zien in de CI van echte projecten, uit onze runs van hun eigen jobs:

  • astro (Node.js, Turborepo): 528 s op GitHub, 30 s op een dedicated machine van Skipbox, die de cache van turbo bewaart, dus zijn warme runs spelen 40 buildtaken af in plaats van ze te draaien.
  • helix (Rust): de step voor toolchain en cache duurde 9-10 s op de dedicated machine, tegenover 41-46 s op GitHub.
  • tauri (Rust): 246 s op GitHub, 53 s op de dedicated machine, met target/ tussen jobs bewaard.

Skipbox houdt de cache op je machine

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

  • Packagecaches blijven op de schijf: ~/.npm, de pnpm-store, de ~/.cache van elke tool, en de caches van Go, Gradle, Cargo en Maven, met de tools die setup-* installeerde. Niets om terug te zetten.
  • Ook de images, layers en buildcache van Docker blijven staan. docker build hergebruikt de layers van de vorige build (Docker-layercache).
  • **actions/cache, setup-* en rust-cache hoeven niet te veranderen.** Wat ze opslaan, blijft naast de machine in plaats van in de opslag van GitHub, met meer ruimte dan de 10 GB per repository van GitHub, en terugzetten leest het lokaal.
  • Geen verloop na 7 dagen op de schijf. Er wordt niets verwijderd tot de schijf na een job bijna vol is; dan gaat eerst weg wat het langst geleden is gebruikt.

Minstens 7× de cacheruimte van GitHub op S. Een job kiest zijn grootte met zijn label:

ubuntu-latest van een privé-repository heeft 2 CPU's, 8 GB en 14 GB SSD. Op Skipbox zijn de minuten onbeperkt. Bij 20.000 minuten per maand op 4 vCPU rekent GitHub $222; Skipbox S is $39, $183 minder.

Overstappen kost één regel

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. Log in bij Skipbox met GitHub.
  2. Installeer de GitHub-app van Skipbox en kies de repository's.
  3. Wijzig runs-on en push.

Laat je cachesteps zoals ze zijn. De tweede run vindt de caches van de eerste run 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. 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 VM die je caches leest maar niet kan wijzigen.

De details staan in zo worden jobs geïsoleerd.

Probeer het op de job waarvan de cache mist

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

Veelgestelde vragen

Wat is de maximale grootte van de GitHub Actions-cache?

Standaard 10 GB per repository, voor alle branches en workflows samen. Daarboven slaat GitHub het nieuwe item toch op en verwijdert het items in volgorde van laatste gebruik, oudste eerst, tot de repository weer onder de limiet zit. Items die 7 dagen door geen job zijn gelezen, worden verwijderd, ongeacht de grootte. Op een Pro-, Team- of Enterprise-account kunnen admins de limiet en het aantal dagen verhogen; opslag boven 10 GB kost $0,07 per GB per maand, gemeten naar de piek van elk uur, en zodra een budget is bereikt, wordt de cache alleen-lezen tot de volgende factureringsperiode.

Waarom wordt mijn GitHub Actions-cache zo vaak verdrongen?

Omdat alles in de repository één keer 10 GB deelt: elke branch, elke pull request, elke matrixjob en elk OS slaat zijn eigen items op, en de type=gha-cache van Docker komt op dezelfde plek terecht. Tellen de opslagen van een dag op tot meer dan de limiet, dan verwijdert elke opslag een ouder item, en mist de volgende job het item dat hij nodig had. GitHub noemt dat cache thrashing. Toon de items op grootte (gh cache list --sort size_in_bytes) om te zien wat hem vult.

Waarom duurt het terugzetten van de cache net zo lang als alles opnieuw installeren?

Omdat een hit nog steeds een download is. Elke job op een door GitHub gehoste runner start op een nieuwe VM, dus actions/cache downloadt het archief en pakt het elke keer uit, en hoe groter de cache, hoe langer dat duurt. De cache van setup-node brengt de downloadcache van de packagemanager terug, niet node_modules, dus npm ci installeert na het terugzetten nog steeds elk package. Op een runner die zijn schijf bewaart, staan de caches er al en wordt er niets gedownload.

Waarom mist actions/cache op een nieuwe branch?

Een run kan caches terugzetten van zijn eigen branch en van de standaardbranch, en de run van een pull request ook van zijn basisbranch. Hij kan de caches van een naastliggende branch niet lezen. De eerste run van een featurebranch heeft dus alleen een hit als de standaardbranch die key heeft opgeslagen. Draai de workflow bij pushes naar de standaardbranch zodat hij opslaat, en voeg restore-keys toe voor een gedeeltelijke match; cache-hit is alleen true bij een exacte match van key.

Hoeveel Actions-cache bewaart Skipbox?

Meer dan de 10 GB per repository van GitHub, naast je machine in plaats van in de opslag van GitHub. Op een cloudmachine blijft wat jobs opslaan met actions/cache, setup-* en rust-cache op de eigen schijf van de machine, tot de helft van die schijf (80 GB op S, 160 GB op M, 320 GB op L); op een Skipbox-host houdt de cache van de host 20 GB per repository vast. In beide gevallen blijft een item 7 dagen na het laatste gebruik bewaard, met de branchregels van GitHub. Packagecaches en de layers van Docker gaan er niet doorheen: die blijven gewoon op de schijf.

Wat wist de caches op een Skipbox-machine?

Niets tussen jobs: de caches blijven op de machine, en pas als een job de schijf bijna vol achterlaat, gaat eerst weg wat het langst geleden is gebruikt. De machine begint schoon na een reset: als je op Machine resetten drukt, als zijn image wordt bijgewerkt (minstens één keer per maand), als hij na een job niet door zijn health check komt, en als een job de limiet van 6 uur bereikt. Als het abonnement afloopt, wordt de machine met zijn schijf verwijderd.

Hoeveel kost het om te proberen?

Niets. De proefperiode is 7 dagen of 3.000 jobminuten, wat het eerst komt, zonder kaart. Zet de job waarvan de cache mist of traag terugkomt op runs-on: skipbox, draai hem twee keer, en vergelijk de restore- en installatiesteps 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