# GitHub Actions में Docker layer cache: हर बिल्ड ठंडे से क्यों शुरू होता है, और लेयर कैसे बचाएं

> हर GitHub Actions जॉब बिना Docker बिल्ड कैश और बिना pull की गई इमेज वाली नई VM पर शुरू होती है, और setup-buildx-action का डिफ़ॉल्ट builder खाली शुरू होता है। buildx के cache-to और cache-from (gha, registry, local) लेयर को डाउनलोड के रूप में वापस लाते हैं, GitHub के 10 GB के अंदर। जो रनर Docker का बिल्ड कैश अपनी डिस्क पर रखता है, उसे इनमें से कुछ नहीं चाहिए, हर महीने तय $39 में।

Docker का layer cache हर GitHub Actions रन में खो जाता है, क्योंकि GitHub-होस्टेड रनर पर हर जॉब नई VM पर शुरू होती है: कोई बिल्ड कैश नहीं, कोई pull की गई इमेज नहीं। docker/setup-buildx-action का डिफ़ॉल्ट builder (`docker-container`) भी हर जॉब में खाली शुरू होता है और उसके अंत में हटा दिया जाता है। आम हल है buildx से कैश एक्सपोर्ट करना। `cache-to: type=gha,mode=max` और `cache-from: type=gha` लेयर को GitHub के Actions कैश में रखते हैं, हर रिपॉज़िटरी के लिए 10 GB, हर दूसरे कैश के साथ बंटा हुआ; `type=registry` उन्हें आपकी रजिस्ट्री में रखता है; `type=local` एक डायरेक्टरी में जिसे आप actions/cache से सेव करते हैं। हर एक हर रन में रीबिल्ड को एक अपलोड और एक डाउनलोड में बदल देता है।

Skipbox लेयर वहीं रखता है जहां बिल्ड चलता है। आपकी जॉब आपके अकाउंट की डेडिकेटेड मशीन पर चलती हैं, जो जॉब के बीच Docker की इमेज, लेयर और बिल्ड कैश रखती है, S पर 80 GB की डिस्क पर, जबकि GitHub के रनर पर 14 GB। `docker build` और `docker compose build` पिछले बिल्ड की लेयर दोबारा इस्तेमाल करते हैं, और compose की pull की गई इमेज पहले से डिस्क पर होती हैं। setup-buildx-action जैसा है वैसा ही काम करता है, और उसका builder भी ये लेयर पा लेता है। एक लाइन बदलें, `runs-on: skipbox`, हर महीने तय $39 में, अनलिमिटेड मिनट के साथ।

- GitHub: हर जॉब के लिए नई VM, इसलिए हर रन में न लेयर, न इमेज, और खाली buildx builder
- Skipbox: Docker का बिल्ड कैश और इमेज आपकी मशीन की डिस्क पर रहते हैं, इसलिए बिना बदली लेयर न फिर से बनती हैं न डाउनलोड होती हैं
- 4 vCPU पर हर महीने 20,000 मिनट: GitHub पर $222, Skipbox पर $39

**तय कीमत पर GitHub Actions, अनलिमिटेड मिनट** Skipbox आपकी GitHub Actions जॉब आपकी अपनी डेडिकेटेड मशीन पर चलाता है: हर महीने $39, आप कितने भी मिनट चलाएं। Docker लेयर और डिपेंडेंसी कैश जॉब के बीच बने रहते हैं, इसलिए अगली जॉब तुरंत शुरू होती है।

4 vCPU रनर, हर महीने 20,000 मिनट: GitHub $222 → Skipbox $39. आप हर महीने $183 बचाते हैं.

आने के लिए एक लाइन काफ़ी है: `runs-on: skipbox`।

[7 दिन का मुफ़्त ट्रायल शुरू करें](https://app.skipbox.dev/sign-in?ref=g-docker-layer-cache-github-actions-hi)

## हर बिल्ड ठंडे से क्यों शुरू होता है

- **हर जॉब के लिए नई VM।** GitHub के [रनर रेफ़रेंस](https://docs.github.com/en/actions/reference/runners/github-hosted-runners) के अनुसार हर GitHub-होस्टेड रनर GitHub पर होस्ट की गई एक नई वर्चुअल मशीन (VM) है। पिछली जॉब ने जो बनाया या pull किया, उसमें से कुछ उस पर नहीं होता।
- **खाली builder।** [docker/setup-buildx-action](https://github.com/docker/setup-buildx-action) डिफ़ॉल्ट रूप से `docker-container` driver वाला builder बनाकर शुरू करता है, और उसका `cleanup` (डिफ़ॉल्ट रूप से चालू) जॉब के अंत में builder हटा देता है।
- **14 GB डिस्क।** प्राइवेट रिपॉज़िटरी के `ubuntu-latest` में 2 CPU, 8 GB और 14 GB SSD है। एक बड़ी इमेज, उसका बिल्ड कैश और अनपैक करने के लिए एक कैश आर्काइव जगह खत्म कर सकते हैं ("no space left on device")।

## buildx के cache backends, और हर एक की कीमत

Docker के [cache backends](https://docs.docker.com/build/cache/backends/) और [GitHub Actions के साथ cache management](https://docs.docker.com/build/ci/github-actions/cache/) से:

| Backend | लेयर कहां जाती हैं | हर रन क्या चुकाता है | सीमाएं |
|---|---|---|---|
| `type=gha` | GitHub का Actions कैश | नई लेयर अपलोड करता है, ज़रूरी लेयर डाउनलोड करता है | हर रिपॉज़िटरी के लिए 10 GB हर दूसरे कैश के साथ, सबसे पुराना पहले हटता है; डिफ़ॉल्ट scope `buildkit` हर बिल्ड में बदल जाता है; GitHub का cache API रेट लिमिट लगाता है |
| `type=registry` | आपकी रजिस्ट्री में एक अलग कैश इमेज | रजिस्ट्री से कैश pull करता है, नया push करता है | push अधिकार वाला रजिस्ट्री लॉगिन; रजिस्ट्री का स्टोरेज और ट्रैफ़िक |
| `type=inline` | इमेज के अंदर ही | उसका कैश पढ़ने के लिए इमेज pull करता है | सिर्फ़ `mode=min`: बीच के स्टेज की लेयर नहीं रखी जातीं |
| `type=local` + actions/cache | actions/cache से सेव की गई एक डायरेक्टरी | पूरी डायरेक्टरी डाउनलोड और अनपैक करता है, फिर उसे अपलोड करता है | [`reset=true`](https://docs.docker.com/build/cache/backends/local/) (Buildx 0.35.0 और बाद में) के बिना हर रन के साथ बढ़ता है; 10 GB में गिना जाता है |

आप कोई भी backend चुनें, [Dockerfile का क्रम ऐसा रखें](https://docs.docker.com/build/cache/optimize/) कि सबसे कम बदलने वाली लेयर पहले आएं: सोर्स कॉपी करने से पहले lockfile कॉपी करें और डिपेंडेंसी इंस्टॉल करें। नहीं तो हर कमिट इंस्टॉल वाली लेयर अमान्य कर देता है, और कोई कैश उसे वापस नहीं लाता।

`mode=min`, जो डिफ़ॉल्ट है, सिर्फ़ आखिरी इमेज की लेयर रखता है। `mode=max` हर स्टेज की लेयर रखता है, इसलिए multi-stage बिल्ड ज़्यादा हिट पाता है, और ज़्यादा अपलोड भी करता है।

एक आम `type=gha` सेटअप, हर इमेज के अपने scope के साथ:

```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 नहीं बचते।** `RUN --mount=type=cache` (बिल्ड के अंदर पैकेज मैनेजर का कैश) डिफ़ॉल्ट रूप से GitHub Actions कैश में नहीं रखा जाता; Docker के डॉक्स इसे actions/cache में अंदर-बाहर ले जाने के लिए [buildkit-cache-dance](https://github.com/reproducible-containers/buildkit-cache-dance) की ओर इशारा करते हैं, यानी हर रन में एक और डाउनलोड और अपलोड।

## docker compose हर जॉब में हर इमेज pull करता है

जो integration टेस्ट `docker compose up` से Postgres, Redis और कुछ सर्विस शुरू करते हैं, वे हर जॉब में हर इमेज pull करते हैं, क्योंकि VM नई है। GitHub-होस्टेड रनर पर विकल्प सिर्फ़ डाउनलोड की जगह बदलते हैं:

- `docker save` से इमेज एक tar फ़ाइल में डालें, actions/cache से उसे कैश करें, और अगली जॉब में `docker load` करें। यह 10 GB में गिना जाता है, और लोड का अपना समय लगता है।
- सर्विस इमेज buildx और ऊपर के किसी cache backend से बनाएं, जिसके बाद भी base इमेज pull करनी बाकी रहती हैं।

## जब हल ऐसी मशीन है जो Docker का कैश रखे

ऊपर का हर backend इसलिए है क्योंकि builder भूल जाता है। जो Docker daemon जॉब के बीच बना रहता है, उसके पास पिछले बिल्ड की लेयर, उसके cache mounts और उसकी pull की हर इमेज पहले से अपनी डिस्क पर होती है। न कुछ एक्सपोर्ट करना है, न इंपोर्ट, और बांटने के लिए कोई 10 GB नहीं।

## Skipbox, Docker का कैश आपकी मशीन पर रखता है

हर प्लान के साथ आपके अकाउंट की डेडिकेटेड मशीन आती है, जो जॉब के बीच बनी रहती है:

- **`docker build` और `docker compose build`** पिछले बिल्ड की लेयर दोबारा इस्तेमाल करते हैं, वर्कफ़्लो में कोई बदलाव किए बिना।
- **इमेज डिस्क पर रहती हैं।** `docker compose up` पिछली बार pull की गई इमेज पाता है; `docker compose pull` सिर्फ़ बदली हुई लेयर लाता है।
- **Cache mounts बने रहते हैं** Docker के बिल्ड कैश के साथ, इसलिए `RUN --mount=type=cache` बिना किसी अतिरिक्त स्टेप के पैकेज मैनेजर का कैश रखता है।
- **docker/setup-buildx-action जैसा है वैसा ही काम करता है।** उसका builder उन लेयर से शुरू होता है जो आपकी रिपॉज़िटरी के पिछले बिल्ड ने मशीन पर छोड़ी थीं, और आप `cache-from` और `cache-to` हटा सकते हैं। हमने खुद एक पब्लिक प्रोजेक्ट का CI 4 vCPU की मशीन पर चलाया (19 नवंबर 2026, हर बार एक रन): इमेज बिल्ड करने वाले स्टेप में पहले रन में 177 सेकंड और दोबारा चलाने पर 4 सेकंड लगे, और 31 स्टेप CACHED रहे।
- **डिस्क:** जब तक किसी जॉब के बाद डिस्क लगभग भर न जाए, कुछ डिलीट नहीं होता। तब पहले dangling इमेज जाती हैं, फिर सबसे पुराना इस्तेमाल हुआ बिल्ड कैश।

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

जॉब अपना साइज़ लेबल से चुनती है:

| लेबल | मशीन | डिस्क | प्लान |
|---|---|---|---|
| `skipbox` | 4 vCPU · 16 GB | 80 GB | S, हर महीने $39 |
| `skipbox-8x16` | 8 vCPU · 16 GB | 160 GB | M, हर महीने $79 |
| `skipbox-16x32` | 16 vCPU · 32 GB | 320 GB | L, हर महीने $149 |

मिनट अनलिमिटेड हैं। 4 vCPU पर हर महीने 20,000 मिनट के लिए GitHub $222 का बिल बनाता है; Skipbox S $39 का है, यानी $183 कम।

## आना बस एक लाइन का काम है

1. GitHub से Skipbox में साइन इन करें।
2. Skipbox GitHub App इंस्टॉल करें और रिपॉज़िटरी चुनें।
3. `runs-on` बदलें और push करें।

पहली जॉब हर लेयर बनाती है। दूसरी उन्हें मशीन पर पाती है।

## सुरक्षा

- मशीन सिर्फ़ आपके अकाउंट की है। किसी दूसरी कंपनी की जॉब उस पर नहीं चलतीं।
- हर जॉब के बाद रनर के क्रेडेंशियल, प्रोसेस और कंटेनर मिटा दिए जाते हैं, और `~/.docker/config.json` भी, इसलिए रजिस्ट्री लॉगिन अगली जॉब तक नहीं जाता। “हर जॉब नई VM पर” इसके बजाय हर जॉब को नई मशीन देता है।
- बिना write एक्सेस वाले लोगों का कोड (जैसे फ़ोर्क से आई पुल रिक्वेस्ट) एक नई, इस्तेमाल के बाद हटाई जाने वाली मशीन पर चलता है, आपकी मशीन पर कभी नहीं।

पूरी जानकारी [जॉब को अलग कैसे रखा जाता है](https://docs.skipbox.dev/hi/isolation) में है।

## अपने Docker बिल्ड पर आज़माएं

ट्रायल 7 दिन या 3,000 जॉब-मिनट तक मुफ़्त है, जो भी पहले पूरा हो, और कार्ड नहीं लगता। अपना Docker बिल्ड `runs-on: skipbox` पर ले जाएं, उसे दो बार चलाएं, और दूसरे रन का बिल्ड स्टेप GitHub के साथ रखकर देखें।

## अक्सर पूछे जाने वाले सवाल

### हर GitHub Actions रन में Docker layer cache क्यों खो जाता है?

क्योंकि GitHub-होस्टेड रनर पर हर जॉब नई VM पर शुरू होती है, पिछले रन के बिना किसी बिल्ड कैश और इमेज के। docker/setup-buildx-action इसमें और जोड़ता है: डिफ़ॉल्ट रूप से वह एक docker-container builder बनाता है जो खाली शुरू होता है और जॉब के अंत में हटा दिया जाता है। इसलिए हर लेयर फिर से बनती है, जब तक आप cache-to से कैश एक्सपोर्ट और cache-from से इंपोर्ट न करें, या ऐसी मशीन पर न चलाएं जो Docker का बिल्ड कैश रखे।

### GitHub Actions में Docker लेयर कैश कैसे करें?

GitHub-होस्टेड रनर पर buildx के cache exporters से: docker/build-push-action में cache-from: type=gha और cache-to: type=gha,mode=max लेयर को GitHub के Actions कैश में रखते हैं (हर रिपॉज़िटरी के लिए 10 GB, हर दूसरे कैश के साथ बंटा हुआ)। type=registry उन्हें आपकी रजिस्ट्री में एक अलग इमेज के रूप में रखता है, और type=local एक डायरेक्टरी में जिसे आप actions/cache से सेव करते हैं। type=gha के साथ हर इमेज को उसका अपना scope दें, क्योंकि डिफ़ॉल्ट scope हर बिल्ड में बदल जाता है। जो मशीन अपनी डिस्क रखती है, उस पर docker build बिना किसी exporter के लेयर दोबारा इस्तेमाल करता है।

### cache-to type=gha के साथ भी buildx धीमा क्यों है?

क्योंकि लेयर फिर भी आती-जाती हैं। mode=max के साथ हर रन हर स्टेज की हर नई लेयर अपलोड करता है, और बाद का रन ज़रूरी लेयर डाउनलोड करता है। कैश GitHub के हर रिपॉज़िटरी के 10 GB को बाकी सब के साथ बांटता है, इसलिए वह हटाया जाता है, और बहुत ज़्यादा रिक्वेस्ट करने वाले बिल्ड पर GitHub का cache API रेट लिमिट लगाता है। जिस builder की डिस्क पर लेयर पहले से हैं, वह दोनों दिशाएं छोड़ देता है।

### docker compose को हर जॉब में वही इमेज pull करने से कैसे रोकें?

GitHub-होस्टेड रनर पर रोक नहीं सकते, सिर्फ़ डाउनलोड की जगह बदल सकते हैं: docker save से इमेज एक tar फ़ाइल में डालें, actions/cache से उसे कैश करें, और अगली जॉब में docker load करें। यह उसी 10 GB में गिना जाता है और हर रन में एक डाउनलोड और एक लोड है। जो मशीन अपनी डिस्क रखती है, उस पर compose की पिछली बार pull की गई इमेज पहले से होती हैं, और docker compose pull सिर्फ़ बदली हुई लेयर लाता है।

### क्या Skipbox पर Docker का कैश रखने के लिए मुझे अपना वर्कफ़्लो बदलना होगा?

सिर्फ़ runs-on: आपके अकाउंट की मशीन जॉब के बीच Docker की इमेज, लेयर और बिल्ड कैश रखती है। docker build और docker compose build इन्हें दोबारा इस्तेमाल करते हैं, और docker/setup-buildx-action जैसा है वैसा ही काम करता है: उसका builder उन लेयर से शुरू होता है जो आपकी रिपॉज़िटरी के पिछले बिल्ड ने मशीन पर छोड़ी थीं। आप cache-from और cache-to हटा सकते हैं।

### आज़माने में कितना खर्च आता है?

कुछ नहीं। ट्रायल 7 दिन या 3,000 जॉब-मिनट का है, जो भी पहले पूरा हो, और कार्ड नहीं लगता। अपना Docker बिल्ड runs-on: skipbox पर ले जाएं, उसे दो बार चलाएं, और दूसरे रन का बिल्ड स्टेप GitHub से मिलाएं।

2026-11-19 को अपडेट किया गया · https://skipbox.dev/hi/guides/docker-layer-cache-github-actions
