# GitHub Actions beschleunigen: eine 25-Minuten-Pipeline kürzen, Hebel für Hebel

> Eine langsame GitHub-Actions-Pipeline besteht aus Jobs, die aufeinander warten, Arbeit, die nicht laufen musste, Setup, das auf einer leeren VM wiederholt wird, und CPU-lastigen Steps auf 2 Kernen. Behebe sie in dieser Reihenfolge. Die letzten beiden sind die Maschine: Skipbox behält deine Caches zwischen den Jobs auf deiner dedizierten Maschine, mit bis zu 16 vCPU, pauschal für $39 im Monat mit unbegrenzten Minuten.

Eine 25-Minuten-Pipeline in GitHub Actions besteht meist aus vier gestapelten Verzögerungen: Jobs, die aufeinander warten, Arbeit, die nicht laufen musste, Setup, das eine leere VM bei jedem Job wiederholt, und CPU-lastige Steps, die auf 2 Kerne gequetscht werden (das `ubuntu-latest` eines privaten Repositorys hat 2 CPUs und 8 GB). Geh sie in dieser Reihenfolge an. Miss zuerst den kritischen Pfad, die Wartezeit getrennt. Dann überspring, was nicht laufen musste, führ unabhängige Jobs gleichzeitig aus, hör auf, den Zustand neu aufzubauen, gib den schweren Steps mehr Kerne und teile in Shards auf, was dann noch lang ist. Die ersten drei sind Workflow-Fixes, die nichts kosten. Der Rest ist die Maschine: ein Runner, der seine Caches zwischen den Jobs behält und mehr Kerne hat.

Skipbox ist dieser Runner. Deine Jobs laufen auf der dedizierten Maschine deines Kontos, die Docker-Layer, Paket-Caches, Tools und Build-Ausgabe zwischen den Jobs behält, mit 4 bis 16 vCPU, pauschal für $39 im Monat mit unbegrenzten Minuten. Bei der CI von astro waren das 528 s auf GitHub und 30 s auf Skipbox. Der Wechsel ist eine Zeile: `runs-on: skipbox`.

- Die Hebel der Reihe nach: messen, überspringen, parallel ausführen, nicht mehr neu aufbauen, Kerne hinzufügen, in Shards aufteilen
- Deine dedizierte Maschine behält Caches und Build-Ausgabe zwischen den Jobs: Die CI von astro ging von 528 s auf 30 s
- 20.000 Minuten im Monat auf 4 vCPU: $222 bei GitHub, $39 bei Skipbox

**GitHub Actions zum Festpreis, unbegrenzte Minuten** Skipbox führt deine GitHub-Actions-Jobs auf deiner eigenen dedizierten Maschine aus: $39 im Monat, egal wie viele Minuten du nutzt. Docker-Layer und Caches für Abhängigkeiten bleiben zwischen den Jobs erhalten, sodass der nächste Job sofort startet.

Ein Runner mit 4 vCPU, 20.000 Minuten im Monat: GitHub $222 → Skipbox $39. Du sparst jeden Monat $183.

Der Wechsel braucht eine Zeile: `runs-on: skipbox`.

[7-tägige Testphase kostenlos starten](https://app.skipbox.dev/sign-in?ref=g-speed-up-github-actions-de)

## 1. Den kritischen Pfad messen

Die Zeit, die dein Team wartet, ist die Kette von Jobs, die zuletzt fertig wird, nicht die Summe aller Jobs. Öffne den Lauf eines typischen Pull Requests: Der Graph zeigt, welche Jobs auf welche warten, und das Log jedes Jobs zeigt seine Step-Zeiten. Notier für die langsamste Kette:

| Phase | Was du prüfst |
|---|---|
| Queued | Hat der Job auf einen Runner gewartet? Ein schnellerer Befehl kann keine Warteschlange verkürzen |
| Set up job, Checkout | Ein gezogenes Container-Image, ein vollständiger Klon, wo ein flacher genügen würde |
| Toolchain und Installation | Hat der Cache getroffen, und hat der Treffer mehr gespart, als die Wiederherstellung gedauert hat? |
| Build | Wird dieselbe Ausgabe in einem anderen Job gebaut? |
| Tests | Ist die CPU des Runners die ganze Zeit ausgelastet, oder macht ein Worker alles? |
| Uploads | Artefakte und Cache-Speicherungen, nachdem die eigentliche Arbeit erledigt ist |

Vergleich einen warmen Lauf mit einem kalten. Ein Cache, der die Hälfte der Zeit danebengeht, sieht im Durchschnitt gut aus.

## 2. Überspringen, was nicht laufen musste

- **Ersetzte Läufe abbrechen.** Jeder Push nach dem ersten macht den laufenden Lauf sinnlos. Eine [Concurrency-Gruppe](https://docs.github.com/en/actions/how-tos/write-workflows/choose-when-workflows-run/control-workflow-concurrency) mit `cancel-in-progress` stoppt ihn. Beschränk sie auf Pull Requests, damit ein Push auf den Standard-Branch nie ein Deployment abbricht:

```yaml
concurrency:
  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
```

- **Nur ausführen, was die Änderung berührt.** `paths:`-Filter überspringen einen Workflow bei Änderungen nur an der Doku; in einem Monorepo führen `turbo run test --affected` oder die affected-Befehle von Nx nur die Pakete aus, die sich geändert haben. Ein Filter auf Trigger-Ebene heißt, dass ein Pflicht-Check nie meldet, also filtere im Job, wenn der Check Pflicht ist.

## 3. Unabhängige Jobs gleichzeitig ausführen

GitHub führt Jobs parallel aus, solange `needs:` sie nicht verkettet. Lint, Typprüfungen, Unit-Tests und der Build brauchen einander selten: Starte sie zusammen und lass nur das Packaging oder das Deployment auf alle warten. Bauen zwei Jobs dasselbe, bau es einmal und reich es mit `actions/upload-artifact` weiter, und miss dabei Upload und Download.

## 4. Nicht mehr denselben Zustand neu aufbauen

Hierhin geht das meiste einer langen Pipeline. Jeder Job auf einem von GitHub gehosteten Runner startet auf einer neuen VM, also lädt er seine Toolchain herunter, installiert Abhängigkeiten, baut Docker-Layer neu und kompiliert von vorn, jedes Mal.

- **Caches, die wirklich treffen.** `cache: npm` von `actions/setup-node` (und seine Formen für pnpm und yarn) speichert die Downloads des Paketmanagers mit einem Key aus dem Lockfile; es speichert nicht `node_modules`, also läuft die Installation trotzdem. GitHub behält 10 GB pro Repository, verwirft Einträge, die 7 Tage ungenutzt sind, und ein Treffer ist immer noch ein Download auf die neue VM ([Cache-Größenlimit](https://skipbox.dev/de/guides/github-actions-cache-size-limit)).
- **Tool-Caches.** `eslint --cache`, `tsc --incremental`, das Cache-Verzeichnis von Jest und `.turbo/cache` von turbo speichern die Arbeit selbst, nicht die Downloads. Auf einer frischen VM sind sie leer, wenn du sie nicht auch wiederherstellst.
- **Docker-Layer.** `docker build` startet auf einer frischen VM ohne Layer; sie mit `cache-to` von buildx zu exportieren und bei jedem Lauf zu importieren ist der Workaround ([Docker-Layer-Cache](https://skipbox.dev/de/guides/docker-layer-cache-github-actions)).

Eine Maschine, die ihre Festplatte behält, erledigt das alles von selbst: Die Caches, die Tool-Caches, die Layer und die Build-Ausgabe sind vom letzten Job noch da.

## 5. Den schweren Steps mehr Kerne geben

Compiler, Bundler und Test-Runner starten einen Worker pro Kern, also führen sie auf 2 CPUs zwei gleichzeitig aus. Prüf, was der Test-Runner tatsächlich nutzt: [Jest](https://jestjs.io/docs/cli#--maxworkersnumstring) nimmt standardmäßig die Kerne minus eins (ein Worker auf 2 CPUs), pytest läuft seriell bis `-n auto`, und [Playwright](https://playwright.dev/docs/ci#workers) nimmt standardmäßig die Hälfte der Kerne, wobei seine Doku in der CI einen Worker empfiehlt. Mehr Kerne helfen erst, wenn der Runner angewiesen wird, sie zu nutzen, und nur bei Steps, die die CPU auslasten; ein Download oder ein Datenbankstart wird nicht schneller.

Bei GitHub heißen mehr Kerne [größere Runner](https://docs.github.com/en/actions/concepts/runners/larger-runners): 4 bis 96 Kerne, nur für Organisationen auf GitHub Team oder Enterprise Cloud, pro Minute zu einem höheren Satz pro Kern berechnet.

## 6. In Shards aufteilen, was noch lang ist

Eine Matrix aus Shards teilt eine lange Suite auf Jobs auf. Sie verkürzt die Wartezeit, nicht die Minuten: Jeder Shard checkt wieder aus, installiert und baut, also bezahlen vier Shards das Setup viermal. Verteil die Shards nach gemessener Zeit, nicht nach Dateizahl, und hör auf, weitere hinzuzufügen, wenn das Setup den Großteil jedes Shards ausmacht.

## Was es kostet, langsam zu bleiben

Eine 15-Minuten-Pipeline, die 40-mal am Tag läuft, sind 10 Stunden Warten, verteilt auf dein Team, jeden Tag, bevor jemand die Kontextwechsel zählt. Bei Abrechnung pro Minute werden Setup-Minuten wie Test-Minuten berechnet:

| Minuten im Monat (4 vCPU) | GitHub | Skipbox S | Du sparst jeden Monat |
|---|---|---|---|
| 10.000 | $102 | $39 | **$63** |
| 20.000 | $222 | $39 | **$183** |
| 30.000 | $342 | $39 | **$303** |

Mehr Kerne kosten bei GitHub mehr pro Minute, also wächst der Abstand mit der Maschine:

| 20.000 Minuten im Monat | GitHub | Skipbox | Du sparst jeden Monat |
|---|---|---|---|
| 8 vCPU | $422 | $79 (M) | **$343** |
| 16 vCPU | $822 | $149 (L) | **$673** |

Die GitHub-Werte gelten nach Abzug der in GitHub Team enthaltenen Nutzung. Probier deine eigenen Minuten im [Rechner auf der Startseite](https://skipbox.dev/?ref=g-speed-up-github-actions-de#cost) aus.

## Wenn der Fix die Maschine ist

Die eigenen CI-Jobs echter Projekte, Steps unverändert, auf dem Runner von GitHub für öffentliche Repositorys (4 vCPU, 16 GB) und auf einer dedizierten Skipbox-Maschine mit denselben vCPU, aus [unseren Läufen ihrer Workflows](https://skipbox.dev/de/guides/rust-cache-slow-rust-ci):

| Projekt | GitHub | Skipbox, dedizierte Maschine | Was die Maschine behielt |
|---|---|---|---|
| astro (Node.js, Turborepo) | 528 s | **30 s** | Den Cache von turbo: 40 Build-Tasks wieder abgespielt |
| tauri (Rust) | 246 s | **53 s** | Das `target/` von Cargo: kein Crate erneut kompiliert |
| ripgrep (Rust) | 200 s | **40 s** | Das `target/` und das Docker-Image von cross |
| vite (Node.js) | 141 s | 100 s | Paket-Caches; der Rest ist die Laufzeit seiner Tests |

Das `ubuntu-latest` eines privaten Repositorys hat die Hälfte der Kerne dieser GitHub-Läufe.

## Was Skipbox für deine Pipeline tut

**Es behält die Maschine.** Zu jedem Tarif gehört die dedizierte Maschine deines Kontos, die zwischen den Jobs bestehen bleibt. Docker-Images, Layer und Build-Cache, Paket-Caches, der Tool-Cache und dein Checkout mit dem `target/` von Cargo und dem Cache von turbo bleiben auf ihrer Festplatte: mindestens 7× so viel Cache-Speicher wie bei GitHub, ohne Keys, ohne Ablauf nach 7 Tagen und ohne Branch-Regel.

**Es fügt Kerne zum Festpreis hinzu.** Ein Job wählt seine Größe per Label:

| Label | Maschine | Tarif |
|---|---|---|
| `skipbox` | 4 vCPU · 16 GB | S, $39 im Monat |
| `skipbox-8x16` | 8 vCPU · 16 GB | M, $79 im Monat |
| `skipbox-16x32` | 16 vCPU · 32 GB | L, $149 im Monat |

Die Minuten sind unbegrenzt, also erhöhen Shards, erneute Läufe und eine größere Matrix die Rechnung nicht. Skipbox-Jobs verbrauchen keine GitHub-Minuten, also stoppt ein GitHub-Budget sie nie.

**Es kümmert sich um sich selbst.** Skipbox stellt die Maschine bereit, hält das Image aktuell, räumt nach jedem Job auf und baut eine Maschine neu auf, die ihre Zustandsprüfung nicht besteht.

## Der Wechsel ist eine Zeile

```yaml
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. Melde dich bei Skipbox mit GitHub an.
2. Installiere die GitHub-App von Skipbox und wähle die Repositorys.
3. Ändere `runs-on` und pushe.

Deine Steps und Actions laufen, wie sie sind, auf Ubuntu 24.04 mit Docker, Node.js und Python.

## Sicherheit

- Die Maschine gehört nur deinem Konto. Keine Jobs eines anderen Unternehmens laufen darauf.
- Nach jedem Job werden die Zugangsdaten, Prozesse und Container des Runners gelöscht, ebenso die Git-Zugangsdaten und die nicht versionierten Dateien im behaltenen Checkout. „Frische VM für jeden Job“ gibt stattdessen jedem Job eine frische Maschine.
- Code von Personen ohne Schreibzugriff (etwa Pull Requests aus Forks) läuft auf einer frischen VM, die deine Caches liest, aber nicht ändern kann.

Die Einzelheiten stehen unter [Wie Jobs isoliert werden](https://docs.skipbox.dev/de/isolation).

## Probier es mit deinem langsamsten Job

Die Testphase ist kostenlos für 7 Tage oder 3.000 Job-Minuten, je nachdem, was zuerst erreicht ist, und braucht keine Karte. Verschieb den Job auf deinem kritischen Pfad auf `runs-on: skipbox`, führe ihn zweimal aus und lies die Step-Zeiten des zweiten Laufs neben denen von GitHub.

## FAQ

### Unsere GitHub-Actions-Pipeline braucht 25 Minuten. Was ist der schnellste Weg, sie schneller zu machen?

Arbeite sie der Reihe nach ab. Lies den Graphen und die Step-Zeiten des Laufs, um die Kette von Jobs zu finden, die die Zeit bestimmt, die Wartezeit getrennt. Brich ersetzte Läufe ab und überspring Jobs, deren Dateien sich nicht geändert haben. Streich needs:, die nur Gewohnheit ausdrücken, damit unabhängige Jobs gleichzeitig laufen. Hör auf, den Zustand bei jedem Job neu aufzubauen: Caches, die wirklich treffen, oder ein Runner, der seine Festplatte behält. Gib CPU-lastigen Steps mehr Kerne und lass den Test-Runner sie nutzen. Teile in Shards auf, was dann noch lang ist. Auf dem ubuntu-latest eines privaten Repositorys (2 CPUs, 8 GB) sind die letzten drei oft der Großteil der 25 Minuten, und sie gehören zur Maschine: Skipbox gibt dem Job eine dedizierte Maschine, die Caches zwischen den Jobs behält, mit 4 bis 16 vCPU.

### Lohnt es sich, auf schnellere Runner zu wechseln, statt den Workflow zu optimieren?

Mach zuerst die kostenlosen Workflow-Fixes: Ersetzte Läufe abbrechen, Pfadfilter und unnötige needs: streichen kosten nichts, und kein Runner erledigt sie für dich. Danach sieh nach, wohin die verbleibende Zeit geht. Setup, das sich bei jedem Job wiederholt (Toolchains, Installation von Abhängigkeiten, Docker-Builds), und Steps, die jeden Kern auslasten, sind das Problem der Maschine, und ein Runner, der seine Caches behält und mehr Kerne hat, beseitigt sie mit einer einzeiligen runs-on-Änderung. Warten auf das Netzwerk und serielle Steps werden mit einer größeren Maschine nicht schneller.

### Warum ist GitHub Actions langsamer als mein Laptop?

Dein Laptop behält seine Pakete, Tools, Docker-Layer und Build-Ausgabe auf der Festplatte und hat meist 8 oder mehr Kerne. Ein Job auf dem ubuntu-latest eines privaten Repositorys bekommt 2 CPUs und 8 GB, auf einer neuen VM, die nichts davon hat. Skipbox funktioniert wie dein Laptop: Die Maschine bleibt zwischen den Jobs bestehen, mit 4 vCPU oder mehr.

### Macht das Aufteilen von Tests in Shards GitHub Actions schneller?

Es verkürzt die Wartezeit, nicht die Minuten. Jeder Shard ist ein neuer Job, der wieder auscheckt, installiert und baut, also bezahlen vier Shards das Setup viermal, und bei Abrechnung pro Minute zählt jedes einzelne. Teile in Shards auf, nachdem das Setup günstig ist und die Kerne des Runners genutzt werden. Auf Skipbox bleibt das Setup auf der Festplatte, und die Minuten sind unbegrenzt, also kosten Shards nichts extra.

### Wie bekomme ich mehr als 4 Kerne für einen GitHub-Actions-Job?

Bei GitHub gibt es größere Runner mit 4 bis 96 Kernen, nur für Organisationen auf GitHub Team oder Enterprise Cloud, pro Minute berechnet. Auf Skipbox ändere runs-on auf skipbox-8x16 für 8 vCPU oder skipbox-16x32 für 16 vCPU, zum monatlichen Festpreis, für Organisationen und persönliche Konten gleichermaßen.

### Was kostet es, das auszuprobieren?

Nichts. Die Testphase dauert 7 Tage oder 3.000 Job-Minuten, je nachdem, was zuerst erreicht ist, ohne Karte. Ändere das runs-on deines langsamsten Jobs auf skipbox, führe ihn zweimal aus und vergleich seine Step-Zeiten.

Aktualisiert am 2026-11-19 · https://skipbox.dev/de/guides/speed-up-github-actions
