# Кеш на Docker слоеве в GitHub Actions: защо всяка компилация започва студена и как да запазите слоевете

> Всяка задача в GitHub Actions започва на нова VM без кеш на компилацията на Docker и без изтеглени образи, а builder-ът по подразбиране на setup-buildx-action започва празен. cache-to и cache-from на buildx (gha, registry, local) връщат слоевете като изтегляния, в рамките на 10-те GB на GitHub. Рънър, който пази кеша на компилацията на Docker на диска си, не се нуждае от нищо от това, за фиксирани $39 на месец.

Кешът на Docker слоевете се губи при всяко изпълнение в GitHub Actions, защото всяка задача на рънър, хостван от GitHub, започва на нова VM: без кеш на компилацията, без изтеглени образи. Builder-ът по подразбиране на docker/setup-buildx-action (`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 между задачите, на диск от 80 GB в S срещу 14 GB на рънъра на GitHub. `docker build` и `docker compose build` използват отново слоевете от предишната компилация, а изтеглените от compose образи вече са на диска. setup-buildx-action работи както си е и неговият builder също намира тези слоеве. Сменете един ред, `runs-on: skipbox`, за фиксирани $39 на месец с неограничени минути.

- GitHub: нова VM за всяка задача, така че без слоеве, без образи и с празен builder на buildx при всяко изпълнение
- Skipbox: кешът на компилацията и образите на Docker остават на диска на машината ви, така че непроменените слоеве не се изграждат наново и не се изтеглят
- 20 000 минути на месец на 4 vCPU: $222 в GitHub, $39 в Skipbox

**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-bg)

## Защо всяка компилация започва студена

- **Нова VM за всяка задача.** [Справочникът на GitHub за рънърите](https://docs.github.com/en/actions/reference/runners/github-hosted-runners): всеки рънър, хостван от GitHub, е нова виртуална машина (VM), хоствана от GitHub. На нея няма нищо от компилираното или изтегленото от предишната задача.
- **Празен builder.** [docker/setup-buildx-action](https://github.com/docker/setup-buildx-action) по подразбиране създава и стартира builder с драйвера `docker-container`, а неговият `cleanup` (включен по подразбиране) премахва builder-а в края на задачата.
- **14 GB диск.** `ubuntu-latest` в частно хранилище има 2 CPU, 8 GB и 14 GB SSD. Голям образ, кешът на компилацията му и архив на кеша за разархивиране може да изчерпят мястото („no space left on device“).

## Бекендовете за кеш на buildx и какво струва всеки

От документацията на Docker за [бекендовете за кеш](https://docs.docker.com/build/cache/backends/) и [управлението на кеша с GitHub Actions](https://docs.docker.com/build/ci/github-actions/cache/):

| Бекенд | Къде отиват слоевете | Какво плаща всяко изпълнение | Ограничения |
|---|---|---|---|
| `type=gha` | Кешът на GitHub Actions | Качва новите слоеве, изтегля тези, които му трябват | 10 GB на хранилище заедно с всеки друг кеш, като най-старите се изтриват първи; scope-ът по подразбиране `buildkit` се презаписва от всяка компилация; API на кеша на GitHub ограничава заявките |
| `type=registry` | Отделен образ с кеша в регистъра ви | Изтегля кеша от регистъра, качва новия | Влизане в регистъра с права за push; съхранението и трафикът на регистъра |
| `type=inline` | В самия образ | Изтегля образа, за да прочете кеша му | Само `mode=min`: слоевете на междинните етапи не се пазят |
| `type=local` + actions/cache | Директория, записана с actions/cache | Изтегля и разархивира цялата директория, после я качва | Расте с всяко изпълнение, освен при [`reset=true`](https://docs.docker.com/build/cache/backends/local/) (Buildx 0.35.0 и по-нов); брои се към 10-те GB |

Който и бекенд да изберете, [подредете Dockerfile-а](https://docs.docker.com/build/cache/optimize/) така, че слоевете, които се променят най-рядко, да са първи: копирайте lockfile-а и инсталирайте зависимостите, преди да копирате изходния код. Иначе всеки commit обезсилва слоя с инсталирането и никой кеш не го връща.

`mode=min`, по подразбиране, пази само слоевете на крайния образ. `mode=max` пази слоевете на всеки етап, така че многоетапна компилация попада по-често, но и качва повече.

Типична настройка с `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
```

**Монтиранията за кеш не оцеляват.** `RUN --mount=type=cache` (кешът на пакетен мениджър в компилацията) по подразбиране не се пази в кеша на GitHub Actions; документацията на Docker насочва към [buildkit-cache-dance](https://github.com/reproducible-containers/buildkit-cache-dance), за да го премествате в и от actions/cache – още едно изтегляне и качване при всяко изпълнение.

## docker compose изтегля всеки образ при всяка задача

Интеграционните тестове, които стартират Postgres, Redis и няколко услуги с `docker compose up`, изтеглят всеки образ при всяка задача, защото VM е нова. На рънъри, хоствани от GitHub, вариантите само преместват изтеглянето:

- Запишете образите в tar файл с `docker save`, кеширайте го с actions/cache и го заредете с `docker load` в следващата задача. Това се брои към 10-те GB, а зареждането отнема собствено време.
- Изграждайте образите на услугите с buildx и бекенд за кеш от горните, което пак оставя базовите образи за изтегляне.

## Когато решението е машина, която пази кеша на Docker

Всеки бекенд по-горе съществува, защото builder-ът забравя. Docker демон, който остава между задачите, вече има слоевете от предишната компилация, монтиранията ѝ за кеш и всеки изтеглен образ на собствения си диск. Няма какво да експортирате, няма какво да импортирате и няма 10 GB за делене.

## Skipbox пази кеша на Docker на машината ви

Всеки план идва с отделна машина за профила ви, пазена между задачите:

- **`docker build` и `docker compose build`** използват отново слоевете от предишната компилация, без промяна в работния поток.
- **Образите остават на диска.** `docker compose up` намира образите, изтеглени миналия път; `docker compose pull` изтегля само променените слоеве.
- **Монтиранията за кеш остават** с кеша на компилацията на Docker, така че `RUN --mount=type=cache` пази кеша на пакетния мениджър без допълнителна стъпка.
- **docker/setup-buildx-action работи както си е.** Неговият builder започва от слоевете, които предишната компилация на вашето хранилище е оставила на машината, и можете да махнете `cache-from` и `cache-to`. При нашето собствено изпълнение на CI на публичен проект на машина с 4 vCPU (19 ноември 2026 г., по едно изпълнение) стъпката, която компилира образа, отне 177 с при първото изпълнение и 4 с при повторното, с 31 стъпки CACHED.
- **Диск:** нищо не се изтрива, докато дискът не е почти пълен след задача. Тогава първо отиват висящите образи, после най-отдавна използваният кеш на компилацията.

```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 на месец |

Минутите са неограничени. При 20 000 минути на месец на 4 vCPU GitHub таксува $222; Skipbox S е $39, с $183 по-малко.

## Преминаването е един ред

1. Влезте в Skipbox с GitHub.
2. Инсталирайте приложението Skipbox в GitHub и изберете хранилищата.
3. Сменете `runs-on` и направете push.

Първата задача изгражда всеки слой. Втората ги намира на машината.

## Сигурност

- Машината е само на вашия профил. Задачи на друга компания никога не се изпълняват на нея.
- След всяка задача идентификационните данни, процесите и контейнерите на рънъра се изтриват, както и `~/.docker/config.json`, така че влизане в регистър не се пренася към следващата задача. „Чиста VM за всяка задача“ дава вместо това на всяка задача нова машина.
- Код от хора без права за запис (например pull request-и от форкове) се изпълнява на нова машина за еднократна употреба, никога на вашата.

Подробностите са в [как са изолирани задачите](https://docs.skipbox.dev/bg/isolation).

## Изпробвайте го с компилацията си на Docker

Пробният период е безплатен за 7 дни или 3000 минути на задачи, което настъпи първо, и не изисква карта. Преместете компилацията на Docker на `runs-on: skipbox`, пуснете я два пъти и сложете стъпката за компилация от второто изпълнение до тази в GitHub.

## Често задавани въпроси

### Защо кешът на Docker слоевете се губи при всяко изпълнение в GitHub Actions?

Защото всяка задача на рънър, хостван от GitHub, започва на нова VM, без кеш на компилацията и без образи от предишното изпълнение. docker/setup-buildx-action добавя към това: по подразбиране създава builder с docker-container, който започва празен и се премахва в края на задачата. Така всеки слой се изгражда наново, освен ако не експортирате кеша с cache-to и не го импортирате с cache-from или не изпълнявате на машина, която пази кеша на компилацията на Docker.

### Как да кеширам Docker слоеве в GitHub Actions?

На рънъри, хоствани от GitHub – с експортерите на кеш на buildx: cache-from: type=gha и cache-to: type=gha,mode=max в docker/build-push-action съхраняват слоевете в кеша на GitHub Actions (10 GB на хранилище, споделени с всеки друг кеш). type=registry ги съхранява като отделен образ в регистъра ви, а type=local – в директория, която записвате с actions/cache. Дайте на всеки образ собствен scope при type=gha, защото scope-ът по подразбиране се презаписва от всяка компилация. На машина, която пази диска си, docker build използва отново слоевете без експортер.

### Защо buildx с cache-to type=gha още е бавен?

Защото слоевете пак пътуват. С mode=max всяко изпълнение качва всеки нов слой на всеки етап, а следващо изпълнение изтегля слоевете, които му трябват. Кешът дели 10-те GB на хранилище в GitHub с всичко останало, така че се изтрива, а API на кеша на GitHub ограничава компилация, която прави твърде много заявки. Builder, който вече има слоевете на диска си, прескача и двете посоки.

### Как да спра docker compose да тегли едни и същи образи при всяка задача?

На рънър, хостван от GitHub, не можете, само можете да преместите изтеглянето: запишете образите в tar файл с docker save, кеширайте го с actions/cache и го заредете с docker load в следващата задача. Това се брои към същите 10 GB и е изтегляне и зареждане при всяко изпълнение. На машина, която пази диска си, образите, изтеглени от compose миналия път, вече са там, а docker compose pull изтегля само променените слоеве.

### Трябва ли да променя работния си поток, за да пазя кеша на Docker в Skipbox?

Само runs-on: машината на профила ви пази образите, слоевете и кеша на компилацията на Docker между задачите. docker build и docker compose build ги използват отново, а docker/setup-buildx-action работи както си е: неговият builder започва от слоевете, които предишната компилация на вашето хранилище е оставила на машината. Можете да махнете cache-from и cache-to.

### Колко струва да го изпробвам?

Нищо. Пробният период е 7 дни или 3000 минути на задачи, което настъпи първо, без карта. Преместете компилацията на Docker на runs-on: skipbox, пуснете я два пъти и сравнете стъпката за компилация от второто изпълнение с тази в GitHub.

Обновено на 2026-11-19 · https://skipbox.dev/bg/guides/docker-layer-cache-github-actions
