# Sind selbstgehostete Runner für private Repositorys sicher? Die Härtungsregeln von GitHub, für dich umgesetzt

> Ein selbstgehosteter GitHub-Actions-Runner behält, was frühere Jobs hinterlassen haben, und kann durch einen einzigen bösartigen Job dauerhaft kompromittiert werden. Die Empfehlung von GitHub: ein Runner für einen Job, eine saubere Maschine, getrennte Maschinen für Code, dem du nicht vertraust. Skipbox setzt alle drei auf der dedizierten Maschine deines Kontos um, pauschal für $39 im Monat, mit einer frischen VM für jeden Job, wenn du „Frische VM für jeden Job“ einschaltest.

Ein selbstgehosteter Runner ist für ein privates Repository erst dann sicher, wenn du ergänzt, was dir die gehosteten Runner von GitHub geben und einem einfachen selbstgehosteten Runner fehlt: eine saubere Maschine, ein Runner, der einen Job annimmt, und getrennte Maschinen für Code, dem du nicht vertraust. Die [Sicherheitsreferenz](https://docs.github.com/en/actions/reference/security/secure-use#hardening-for-self-hosted-runners) von GitHub sagt, dass selbstgehostete Runner „do not have guarantees around running in ephemeral clean virtual machines, and can be persistently compromised by untrusted code in a workflow“: Sie laufen also nicht garantiert in kurzlebigen, sauberen VMs und können durch nicht vertrauenswürdigen Code in einem Workflow dauerhaft kompromittiert werden.

Skipbox ist ein selbstgehosteter Runner, bei dem diese Arbeit erledigt ist. Deine Jobs laufen auf einer Maschine, die nur deinem Konto gehört, ihre Zugangsdaten werden nach jedem Job gelöscht, jeder Runner wird für einen Job registriert, und Code von Personen ohne Schreibzugriff läuft in einer frischen VM. Schalte **Frische VM für jeden Job** ein, und jeder Job bekommt eine frische VM. Pauschal $39 im Monat, unbegrenzte Minuten; ändere eine `runs-on`-Zeile.

- GitHub: Ein selbstgehosteter Runner kann durch einen einzigen Job dauerhaft kompromittiert werden, und der Pull Request eines Forks kann seine Secrets erreichen
- Skipbox: die dedizierte Maschine deines Kontos, Zugangsdaten nach jedem Job gelöscht, eine frische VM für Code von Personen ohne Schreibzugriff
- „Frische VM für jeden Job“: jeder Job in einer neuen VM, die mitsamt ihrer Festplatte gelöscht wird, wenn der Job endet

**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-self-hosted-runner-security-private-repositories-de)

## Wovor GitHub warnt

Alles aus der Sicherheitsreferenz von GitHub und seiner Doku zu selbstgehosteten Runnern:

- **Die Maschine erinnert sich.** Ein selbstgehosteter Runner braucht nicht für jeden Job eine saubere Instanz. Was ein Job hinterlässt (Dateien, Prozesse, Container, Tokens), ist für den nächsten da.
- **Private Repositorys sind nicht ausgenommen.** „Anyone who can fork the repository and open a pull request (generally those with read access to the repository) are able to compromise the self-hosted runner environment, including gaining access to secrets and the `GITHUB_TOKEN`.“ Jeder, der das Repository forken und einen Pull Request öffnen kann (meist alle mit Lesezugriff), kann also die Umgebung des Runners kompromittieren, einschließlich Zugriff auf Secrets und das `GITHUB_TOKEN`.
- **Öffentliche Repositorys.** Selbstgehostete Runner „should almost never be used for public repositories“, sollten dort also fast nie genutzt werden, weil jeder Nutzer einen Pull Request öffnen kann.
- **Ein Runner, viele Repositorys.** Ein Runner auf Organisationsebene nimmt Jobs von jedem Repository an, das ihn nutzen darf, also breitet sich eine Kompromittierung aus. Runner-Gruppen begrenzen, welche Repositorys welche Runner erreichen.
- **Was auf der Maschine liegt.** SSH-Keys, API-Tokens und Netzwerkzugriff auf interne Dienste oder den Metadaten-Dienst einer Cloud liegen alle in Reichweite eines Jobs.
- **Die Maschine nach einem Job zu löschen reicht allein nicht.** „There is no way to guarantee that a self-hosted runner only runs one job.“ Es gibt also keine Garantie, dass ein selbstgehosteter Runner nur einen Job ausführt. Die Lösung von GitHub ist ein Just-in-time-Runner, der höchstens einen Job ausführt, gestartet in einer sauberen Umgebung durch deine eigene Automatisierung.
- **Freigabe-Einstellungen schützen deine Hardware nicht.** Sobald der Workflow eines Forks laufen darf, „potentially malicious user-controlled workflow code will execute automatically“, wird also möglicherweise bösartiger, vom Nutzer kontrollierter Workflow-Code automatisch auf einem selbstgehosteten Runner ausgeführt.

## Was ein sicheres Setup braucht

Die Empfehlung von GitHub, als Arbeit:

| Die Empfehlung von GitHub | Auf einem Runner, den du hostest | Auf Skipbox |
|---|---|---|
| Ein Runner, der einen Job annimmt | Vor jedem Job die REST-API nach einer Just-in-time-Konfiguration fragen und den Runner damit starten | Jeder Runner wird just in time für einen Job registriert, mit den Labels dieses Jobs, und danach entfernt |
| Eine saubere Umgebung dafür | Pro Job eine neue VM booten und löschen oder ein Löschverfahren schreiben, dem du vertraust | Zugangsdaten, Prozesse, Container und Dateien mit Zugangsdaten nach jedem Job gelöscht; eine neue VM pro Job mit „Frische VM für jeden Job“ |
| Code von Außenstehenden getrennt halten | Ein zweiter Pool von Maschinen für Forks und ein Routing, das sie nie vermischt | Code von Personen ohne Schreibzugriff läuft immer in einer frischen VM |
| Wenig auf der Maschine | Keys, Tokens und interne Netzwerkrouten vom Host fernhalten | Eine VM außerhalb deines Netzwerks, ohne eingehende Verbindungen |
| Begrenzter Zugriff | Runner-Gruppen pro Repository oder Team | Deine Maschine führt nur die Jobs deines Kontos aus; bei einem persönlichen Konto wird jeder Runner im eigenen Repository des Jobs registriert |
| Patchen | Betriebssystem, Docker und Runner, nach deinem Zeitplan | Das Image wird für dich aktualisiert, mindestens einmal im Monat |

Von Hand gebaut ist das ein Autoscaler, eine Image-Pipeline und ein zweiter Runner-Pool. Auf Skipbox ist es der Standard.

## Was Skipbox genau isoliert

### Deine eigene Maschine

Jeder Tarif, und die Testphase, gibt deinem Konto seine dedizierte VM. Sie führt nur die Jobs deines Kontos aus, einen nach dem anderen, und bleibt zwischen den Jobs erhalten: Docker-Images und Build-Cache, Paket-Caches und installierte Tools bleiben, und deshalb ist der nächste Job schnell.

Nach jedem Job

- löscht Skipbox die Zugangsdaten des Runners
- stoppt es jeden Prozess des Runner-Nutzers und entfernt jeden Container
- löscht es Dateien mit Zugangsdaten: `~/.docker/config.json`, `~/.npmrc`, `~/.git-credentials`, `~/.config/gh`, `~/.aws/credentials`, `~/.kube/config`, `~/.ssh/id_*`
- entfernt es die Git-Zugangsdaten im Checkout und in der Git-Konfiguration der Home-Verzeichnisse, die Hooks des Checkouts und seine nicht versionierten Dateien
- prüft es die Maschine (Festplatte, Pakete, Docker, den Runner, DNS, übrig gebliebene Prozesse und Container) und baut sie aus dem Image neu auf, wenn die Prüfung fehlschlägt

Ab dem 13. November 2026 bleiben dein Checkout und seine Build-Ausgabe (`target/` von Cargo) für deine nächsten Jobs auf deiner dedizierten Maschine. Die Maschine wird außerdem neu aufgebaut, wenn du **Maschine zurücksetzen** drückst und wenn das Image aktualisiert wird, mindestens einmal im Monat.

Die Jobs deines Kontos teilen sich diese Festplatte, und genau das hält ihre Caches und Build-Ergebnisse für den nächsten Job bereit. Um Repositorys oder Branches voneinander getrennt zu halten, schalte „Frische VM für jeden Job“ ein.

### Eine frische VM

Diese Jobs laufen in einer neuen VM, die keinen anderen Job ausgeführt hat und mitsamt ihrer Festplatte gelöscht wird, wenn der Job endet:

- jeder Job, wenn **Frische VM für jeden Job** eingeschaltet ist
- Code von Personen ohne Schreibzugriff, etwa Pull Requests aus Forks
- Jobs, die ankommen, während alle deine dedizierten Maschinen beschäftigt sind

Ein Lauf zählt als einer deines Teams, wenn sein Code der eigene des Repositorys ist und die Person, die ihn gestartet hat, Schreib-, Maintain- oder Admin-Zugriff hat. Alles andere wird als Code von außen behandelt: der Pull Request eines Forks, ein `pull_request_target` oder `workflow_run`, gestartet aus dem Code eines Forks, ein `issue_comment` von jemandem ohne Schreibzugriff. Die Regel ist für private und öffentliche Repositorys dieselbe. Ein Job von außen liest deine Caches und kann sie nicht ändern, und einer, der trotzdem deine dedizierte Maschine erreicht, schlägt fehl, bevor seine Steps laufen; die Maschine wird dann zurückgesetzt.

### Rund um die VM

- **Ein Job pro Runner.** Jeder Runner wird just in time für einen einzigen Job registriert. Ein Runner, der nach seinem Job registriert geblieben ist, wird entfernt.
- **Keine eingehenden Verbindungen.** Nichts im Internet kann sich mit der VM eines Jobs verbinden.
- **Kein Zugriff auf deinen Code.** Die Skipbox-App kann deine Repositorys nicht lesen; jeder Job checkt deinen Code selbst aus, in seiner VM.
- **Kein anderer Kunde.** Kein Job einer anderen Organisation läuft auf deiner Maschine.

Die VM eines Jobs hält die Secrets des Workflows und das Token von GitHub für diesen Job, und Skipbox löscht sie, wenn der Job endet. [Wie Jobs voneinander getrennt werden](https://docs.skipbox.dev/de/isolation) hat jede Einzelheit.

## Was es neben den Runnern von GitHub kostet

Selbstgehostete Minuten sind bei GitHub kostenlos, und die Runner von Skipbox sind selbstgehostete Runner.

| 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** |
| Dauerbetrieb | $500,40 | $39 | **$461,40** |

Die GitHub-Werte sind die Rechnung bei GitHub Team nach Abzug der enthaltenen Rechenzeit. Berechne deine eigenen Minuten im [Rechner auf der Startseite](https://skipbox.dev/?ref=g-self-hosted-runner-security-private-repositories-de#cost); ohne Anmeldung.

## Der Wechsel ist eine Zeile

```yaml
jobs:
  build:
    runs-on: skipbox # was ubuntu-latest, or self-hosted
    steps:
      - uses: actions/checkout@v4
      - run: npm ci && npm test
```

1. Melde dich bei Skipbox mit GitHub an.
2. Installiere die GitHub-App von Skipbox und wähle deine Repositorys.
3. Ändere `runs-on` und pushe.

Für eine frische VM bei jedem Job schalte **Frische VM für jeden Job** unter „Tarife und Abrechnung“ ein.

## Probier es mit einem privaten Repository

Die Testphase braucht keine Karte und läuft 7 Tage oder 3.000 Job-Minuten. Verschieb einen Job auf `runs-on: skipbox` und leg den Runner still, den du gerade härten wolltest.

## FAQ

### Sind selbstgehostete Runner für private Repositorys sicher?

Nur mit der Arbeit, die dir die gehosteten Runner von GitHub abnehmen. Die Doku von GitHub sagt, dass ein selbstgehosteter Runner keine Garantie für eine saubere, kurzlebige Maschine hat und durch nicht vertrauenswürdigen Code dauerhaft kompromittiert werden kann, und dass in einem privaten Repository jeder, der es forken und einen Pull Request öffnen kann, den Runner, seine Secrets und sein GITHUB_TOKEN erreichen kann. Skipbox schließt diese Lücken für dich: eine Maschine, die nur die Jobs deines Kontos ausführt, Zugangsdaten, die nach jedem Job gelöscht werden, ein Runner, der für einen Job registriert wird, und eine frische VM für Code von Personen ohne Schreibzugriff.

### Wie richte ich einen selbstgehosteten GitHub-Actions-Runner sicher ein, mit einer frischen VM pro Job?

Registriere jeden Runner just in time für einen einzigen Job, starte ihn in einer VM, die keinen anderen Job ausgeführt hat, lösch die VM, wenn der Job endet, halte die Pull Requests von Außenstehenden von Maschinen fern, die dein Team nutzt, und leite die Logs des Runners weiter, bevor die VM verschwindet. Das ist ein Autoscaler, den du bauen und betreiben musst. Auf Skipbox ist es ein Schalter: Schalte „Frische VM für jeden Job“ ein, und jeder Job läuft in einer neuen VM, die danach mitsamt ihrer Festplatte gelöscht wird. Ändere runs-on auf skipbox, um anzufangen.

### Führt Skipbox jeden Job auf einer frischen VM aus?

Mit eingeschaltetem „Frische VM für jeden Job“ ja: Jeder Job läuft in einer neuen VM, die keinen anderen Job ausgeführt hat, und wird mitsamt ihrer Festplatte gelöscht, wenn der Job endet. Ohne die Option laufen die Jobs deines Teams auf der dedizierten Maschine deines Kontos, die zwischen den Jobs erhalten bleibt, damit Docker-Layer und Paket-Caches bleiben; nach jedem Job löscht Skipbox die Zugangsdaten des Runners, stoppt seine Prozesse, entfernt jeden Container und löscht Dateien mit Zugangsdaten. Code von Personen ohne Schreibzugriff und Jobs, die ankommen, während deine Maschinen beschäftigt sind, bekommen immer eine frische VM.

### Was behält ein selbstgehosteter Runner zwischen den Jobs?

Alles, wenn du es nicht löschst: Dateien, Prozesse, Container, Docker-Zugangsdaten, SSH-Keys und Tokens, die der letzte Job geschrieben hat. Die Doku von GitHub sagt, dass ein selbstgehosteter Runner nicht für jeden Job eine saubere Instanz braucht. Auf einer dedizierten Skipbox-Maschine bleiben die Caches und dein Checkout, und die Zugangsdaten, Prozesse und Container verschwinden nach jedem Job; eine Maschine, die ihre Prüfung nach einem Job nicht besteht, wird aus einem sauberen Image neu aufgebaut.

### Kann ein Pull Request aus einem Fork auf meinem selbstgehosteten Runner laufen?

Auf einem Runner, den du hostest, ja, sobald die Fork-Richtlinie des Repositorys seine Workflows laufen lässt: Die Doku von GitHub warnt, dass dann vom Nutzer kontrollierter Workflow-Code auf deiner Infrastruktur ausgeführt wird. Auf Skipbox läuft der Pull Request eines Forks nie auf deiner dedizierten Maschine. Er läuft in einer frischen VM, die deine Caches lesen, aber nicht ändern kann, und ein Job aus einem Fork, der trotzdem deine dedizierte Maschine erreicht, schlägt fehl, bevor seine Steps laufen.

### Sind selbstgehostete Runner für öffentliche Repositorys sicher?

GitHub sagt, dass selbstgehostete Runner für öffentliche Repositorys fast nie genutzt werden sollten, weil jeder Nutzer einen Pull Request öffnen und die Maschine kompromittieren kann. Skipbox führt die Jobs öffentlicher Repositorys aus, indem es diese Pull Requests von deiner Maschine fernhält: Code von Personen ohne Schreibzugriff läuft in einer frischen VM, die danach gelöscht wird, und deine dedizierte Maschine führt nur den Code deines Teams aus.

Aktualisiert am 2026-11-19 · https://skipbox.dev/de/guides/self-hosted-runner-security-private-repositories
