---
title: "Eigene Vorlagen aus einer laufenden Sandbox · Pethost"
description: "Speichere die Disk einer Pethost-Sandbox samt Paketen und Docker-Images als Vorlage und starte neue Sandboxes daraus in etwa 0,22 s. Kostenlos im Tarif."
---

[Agent Sandboxes](https://pethost.dev/de/sandboxes/) Eine Sandbox als Vorlage speichern

# Vorlagen: einmal installieren, jede Sandbox daraus starten

Installier einmal, was deine Arbeit braucht, in einer Sandbox, von Hand oder durch einen Agenten. Speichere die Disk der Sandbox als Vorlage, und jede neue Sandbox startet mit allem an seinem Platz: Pakete, Dateien, Docker-Images.

Eine Sandbox mit ihren Paketen und Docker-Images wird in 1,2 s als Vorlage my-app@3 gespeichert, und drei neue Sandboxes starten daraus auf zwei Servern.

## Unsere: base

Jede Sandbox startet aus einer Vorlage. Unsere ist `base`: Ubuntu 24.04 mit build-essential, git, curl, wget, ripgrep und jq; Python 3 mit pip und venv; Node.js 22; Claude Code, Codex und OpenCode mit ihren SDKs; Docker mit Compose und Buildx; und ein Desktop mit 1280×800 und Google Chrome. Du arbeitest als `user`, mit sudo und ohne Passwort. Ihr Root-Dateisystem ist schreibgeschützt und wird direkt von der Disk des Servers gelesen, also kostet, was eine Sandbox nicht ausführt, sie keinen RAM, und weder der Desktop noch Docker startet, bis etwas danach fragt.

Jede Version von `base` ist nach dem sha256 dessen benannt, was sie enthält: das Betriebssystem, seine Pakete und der Gast-Kernel. Wir bauen jeden Monat eine neue und sofort bei einem Sicherheitsfix für Chrome, den Kernel oder die Pakete. Neue Sandboxes starten mit der neuesten; eine Sandbox und eine aus ihr gespeicherte Vorlage behalten die Basis, mit der die Sandbox gestartet ist.

## Eigene Vorlagen, aus einer Sandbox gespeichert

Eine eigene Vorlage ist die Disk einer Sandbox, über unserer Basis gespeichert. Richte die Sandbox ein, von Hand oder durch einen Agenten, dann speichert `create_template` ihre Disk als nächste Version eines Namens: `my-app@1`, dann `my-app@2`. Sie speichert nur Dateien: keinen RAM, keine laufenden Prozesse und weder den Befehlsverlauf der Sandbox noch die Unterhaltungen ihrer Agenten, ohne die neue Sandboxes starten.

Der Aufruf antwortet in 28 bis 49 ms mit der Version im Zustand SAVING. Eine laufende Sandbox läuft weiter, für einige Millisekunden angehalten, während ihre Disk übernommen wird. Dann prüft der Server das Dateisystem und verkleinert es auf das, was es enthält, in einer eigenen Helfer-VM, und lädt nur die Chunks, die deine sind, in den Objektspeicher hoch, komprimiert und verschlüsselt mit einem Schlüssel nur für diese Version. Die Version einer kleinen Sandbox ist 0,9 bis 1,5 s nach dem Aufruf READY; allgemein dauert es etwa 5 s plus 10 s pro GiB deiner eigenen Daten. Eine Version im Zustand READY nennt ihre `min_size`, die kleinste Größe, deren Disk fasst, was sie gespeichert hat.

## Sandboxes daraus starten

Nenn die Vorlage, wenn du eine Sandbox erstellst: `my-app` nimmt ihre neueste Version im Zustand READY, `my-app@3` genau diese. Jeder Server startet Sandboxes aus jeder Version. Das Panel fragt zuerst die Server, die die Version schon haben, und dort dauert das Erstellen 218 bis 225 ms. Ein Server, dem sie fehlt, holt sie einmal, etwa 10 s pro GiB, das die Version enthält, und behält sie für das nächste Mal. Eine Sandbox aus einer Vorlage nimmt jede Größe ab der `min_size` der Version.

Die Images von Docker liegen auf der Disk der Sandbox, also nimmt eine Vorlage sie mit: Eine daraus erstellte Sandbox führt `docker run` mit einem Image aus, das sie nie gepullt hat. (Die Zeiten hier wurden über ein Panel 16 ms vom Server entfernt gemessen.)

Python

CLI

```
import time

from pethost.sandboxes import Sandboxes

sandboxes = Sandboxes()  # liest PETHOST_TOKEN
sandbox = sandboxes.create_sandbox()  # aus base
sandboxes.run_command(
    sandbox.sandbox_id,
    command="python3 -m venv ~/venv && ~/venv/bin/pip install pandas && docker pull postgres:18",
)

version = sandboxes.create_template("my-app", sandbox_id=sandbox.sandbox_id)
name = f"my-app@{version.version}"
while sandboxes.get_template(name).state.name == "SAVING":
    time.sleep(1)

copy = sandboxes.create_sandbox(name)  # pandas und das Image von postgres sind da
print(sandboxes.run_command(copy.sandbox_id, command="docker images postgres").stdout)
```

```
pethost sandbox template save api-dev my-app   # ihre Disk, als nächste Version von my-app
pethost sandbox template show my-app           # SAVING, dann READY
pethost sandbox new --template my-app          # eine neue Sandbox aus der neuesten Version
```

## Versionen, Platz und Preis

Ein Name hat bis zu 10 Versionen. Ein Workspace speichert eine Version nach der anderen, und seine Versionen passen zusammen in den Platz für Vorlagen seines Tarifs, gezählt als das, was sie komprimiert im Objektspeicher belegen:

| Tarif | Platz für Vorlagen |
| --- | --- |
| 20 $ im Monat | 5 GiB |
| 100 $ im Monat | 30 GiB |
| 500 $ im Monat | 175 GiB |
| 2.000 $ im Monat | 800 GiB |

Vorlagen kosten über diesen Platz hinaus nichts. Das Löschen einer Vorlage, aller Versionen ihres Namens, gibt ihren Platz sofort frei, und die daraus erstellten Sandboxes laufen, pausieren, stoppen und starten weiter: Der Objektspeicher behält eine Version, bis die letzte von ihnen gelöscht ist.

## Was Vorlagen noch nicht können

Einen Build aus einem Dockerfile gibt es noch nicht: Installier in einer Sandbox und speichere sie, wie oben. Eine Vorlage nimmt Dateien mit, nie laufende Prozesse. Um eine Sandbox mit RAM und Prozessen zu kopieren, mit laufendem Dev-Server oder einem Agenten mitten in einer Aufgabe, [forke sie](https://pethost.dev/de/sandboxes/fork/). Jede Sandbox, aus einer Vorlage oder nicht, ist eine eigene [Firecracker-MicroVM](https://pethost.dev/de/sandboxes/firecracker-microvm/) mit eigenem Kernel. Die [Anleitung zu Vorlagen](https://pethost.dev/de/docs/sandboxes/templates/) hat jeden Aufruf und jedes Feld.

## Im Vergleich

Am 21. November 2026 baute E2B Vorlagen mit seinem Vorlagen-Builder, und Daytona erstellte Snapshots aus einem Image oder einem Dockerfile, was Pethost noch nicht kann. boat.dev speichert Snapshots und berechnet 0,056 $ pro Snapshot und Tag über die im Tarif enthaltenen hinaus. Eine Vorlage bei Pethost kostet im Platz deines Tarifs nichts.

[Doku lesen](https://pethost.dev/de/docs/sandboxes/templates/)

## Fragen

**Kann ich eine Sandbox-Vorlage aus einem Dockerfile bauen?**

Noch nicht. Starte eine Sandbox aus `base`, führe die Schritte deines Dockerfile darin als Befehle aus, und speichere sie. Du kannst auch `docker build` in einer Sandbox ausführen: Das gebaute Image liegt auf der Disk der Sandbox, und die Vorlage nimmt es mit.

**Was kostet eine Vorlage?**

Nichts. Ihre Versionen zählen gegen den Platz für Vorlagen deines Tarifs, 5 GiB im Tarif für 20 $, gemessen, wie sie gespeichert sind, komprimiert.

**Behält eine Vorlage laufende Prozesse?**

Nein, sie behält Dateien. Ein Fork kopiert eine Sandbox mit ihrem RAM und ihren laufenden Prozessen.

**Wie schnell startet eine Sandbox aus einer Vorlage?**

In 218 bis 225 ms auf einem Server, der die Version hat. Der erste Start auf einem Server ohne sie holt sie zuerst, etwa 10 s pro GiB, das sie enthält.

## Verwandte Funktionen

- [Eine laufende Sandbox bei Schritt 41 einer Aufgabe wird in 0,25 s in drei Kopien geforkt; jede macht ab Schritt 41 für sich weiter. Fork samt RAM Kopier eine laufende Sandbox mit RAM, Prozessen und Disk in einem Aufruf in neue Sandboxes. Drei Kopien dauern etwa eine Viertelsekunde. So funktioniert es](https://pethost.dev/de/sandboxes/fork/)
- [Drei Sandboxes auf einem Server, jede eine MicroVM mit eigenem Kernel und eigener Root-Shell; eine vierte startet in 0,12 s. Eine MicroVM pro Sandbox Jede Sandbox ist eine Firecracker-MicroVM mit eigenem Linux-Kernel, Root-Zugriff und eigenem Netzwerk, in etwa 0,15 s aus einem Snapshot gestartet. So funktioniert es](https://pethost.dev/de/sandboxes/firecracker-microvm/)

## Gib deinem Agenten einen Computer in 0,15 s

[Kostenlose Testphase starten](https://console.pethost.dev/welcome?kind=sandboxes)

Pethost · Stephan Gomer · NIP 1133096755

Pethost

- [Vorlagen](https://pethost.dev/de/templates/)
- [Über uns](https://pethost.dev/about/)
- [Doku](https://pethost.dev/docs/)
- [Blog](https://pethost.dev/de/blog/)
- [API](https://pethost.dev/docs/api/)
- [CLI](https://pethost.dev/docs/cli/)
- [Plugin](https://github.com/pethost-dev/plugin)
- [AGB](https://pethost.dev/terms/)
- [Datenschutz](https://pethost.dev/privacy/)
- [Erstattung](https://pethost.dev/refunds/)
- [support@pethost.dev](mailto:support@pethost.dev)

Datenbanken

- [Postgres](https://pethost.dev/de/postgres/)
- [Valkey](https://pethost.dev/de/valkey/)

Agent Sandboxes

- [Sandboxes](https://pethost.dev/de/sandboxes/)
- [Preise](https://pethost.dev/de/sandboxes/#pricing)
- [Doku](https://pethost.dev/de/docs/sandboxes/)
- [API](https://pethost.dev/docs/sandboxes/api/)

Vergleiche

- [Coolify vs Dokploy vs CapRover vs Dokku](https://pethost.dev/de/blog/coolify-vs-dokploy-vs-caprover-vs-dokku/)
- [Coolify Cloud vs Dokploy Cloud](https://pethost.dev/de/blog/coolify-cloud-vs-dokploy-cloud/)
- [Railway vs Render vs Fly.io Preise](https://pethost.dev/de/blog/railway-vs-render-vs-fly-io-pricing/)
- [Managed Hosting für Docker Compose](https://pethost.dev/de/blog/managed-docker-compose-hosting/)

Alternativen

- [Railway-Alternativen](https://pethost.dev/de/blog/railway-alternatives/)
- [Heroku-Alternativen](https://pethost.dev/de/blog/heroku-alternatives/)
- [Dokploy-Alternativen](https://pethost.dev/de/blog/dokploy-alternatives/)
- [Coolify-Alternativen](https://pethost.dev/de/blog/coolify-alternatives/)
- [Render-Alternativen](https://pethost.dev/de/blog/render-alternatives/)
- [Sliplane-Alternativen](https://pethost.dev/de/blog/sliplane-alternatives/)
