---
title: "Szablony: sandboxy gotowe do pracy od startu | Pethost Agent Sandboxes"
description: "Zapisz dysk sandboxa jako szablon, z pakietami i obrazami Dockera, i uruchamiaj z niego nowe sandboxy na dowolnym serwerze w ok. 0,2 s."
---

[Dokumentacja Agent Sandboxes](https://pethost.dev/pl/docs/sandboxes/) · Zadania

# Szablony: sandboxy gotowe do pracy od startu

Zaktualizowano 22 listopada 2026 · 5 min czytania

Szablon to to, z czego startuje sandbox. Nasz, `base`, ma narzędzia; twój to dysk sandboxa zapisany taki, jaki jest, z zainstalowanymi przez ciebie pakietami, twoim kodem i jego obrazami Dockera. Sandbox z niego startuje w ok. 0,22 s i nie trzeba już niczego instalować.

**W skrócie**

- **`CreateTemplate`** zapisuje dysk i ustawienia sandboxa jako nową wersję, `my-app@1`, `my-app@2`, a sandbox działa dalej.
- **SAVING, potem READY** w ok. 1,5 s dla małego, a ok. 10 s na GiB własnych danych.
- **`CreateSandbox`** z `"my-app"` startuje z jego najnowszej wersji READY, na dowolnym serwerze.
- **Same pliki:** szablon nie zachowuje pamięci, procesów ani rozmów agentów. Nie jest rozliczany; jego rozmiar ogranicza twój plan.

### Step 1: Przygotuj sandbox

Utwórz sandbox z `base` i ustaw go tak, jak powinien wyglądać każdy nowy: sklonuj kod, zainstaluj zależności, pobierz obrazy Dockera, których używa, rozgrzej cache ([polecenia i pliki](https://pethost.dev/pl/docs/sandboxes/commands-and-files/)). Liczą się też jego ustawienia: szablon bierze cykl życia, ruch wychodzący, publiczne porty i środowisko sandboxa takie, jakie są teraz, a sandboxy z niego startują z nimi, chyba że ich utworzenie mówi inaczej.

### Step 2: Zapisz go jako szablon

`CreateTemplate` w ciągu milisekund odpowiada nową wersją SAVING, gdy już trzyma dysk taki, jaki jest: sandbox działa dalej. Serwer zmniejsza potem wersję do tego, co zawiera, i ją wysyła. Zanim uruchomisz coś z tej wersji, poczekaj na READY.

Python

```
import time

from pethost.sandboxes import TemplateState

version = sandboxes.create_template("my-app", sandbox_id=sandbox_id, description="Node 22 and our dependencies")
while version.state == TemplateState.SAVING:
    time.sleep(1)
    version = sandboxes.get_template(f"my-app@{version.version}")
print(version.name, version.version, version.state.name, version.min_size.name, version.size_bytes)
# my-app 1 READY SMALL 25447048
```

TypeScript

```
let version = await sandboxes.createTemplate({
  name: "my-app",
  sandboxId,
  description: "Node 22 and our dependencies",
});
while (version.state === TemplateState.SAVING) {
  await new Promise((resolve) => setTimeout(resolve, 1000));
  version = await sandboxes.getTemplate({ template: `my-app@${version.version}` });
}
console.log(version.name, version.version, version.state, version.minSize, version.sizeBytes);
```

Go

```
version, err := client.CreateTemplate(ctx, &sandboxes.CreateTemplateRequest{
	Name:        "my-app",
	SandboxID:   id,
	Description: "Node 22 and our dependencies",
})
for err == nil && version.State == sandboxes.TemplateStateSaving {
	time.Sleep(time.Second)
	version, err = client.GetTemplate(ctx, &sandboxes.GetTemplateRequest{Template: fmt.Sprintf("my-app@%d", version.Version)})
}
if err != nil {
	log.Fatal(err)
}
fmt.Println(version.Name, version.Version, version.State, version.MinSize, version.SizeBytes)
```

Rust

```
let mut version = sandboxes
    .create_template(CreateTemplateRequest {
        name: "my-app".into(),
        sandbox_id: id.clone(),
        description: "Node 22 and our dependencies".into(),
        ..Default::default()
    })
    .await?;
while matches!(version.state, TemplateState::Saving) {
    tokio::time::sleep(std::time::Duration::from_secs(1)).await;
    let template = format!("my-app@{}", version.version);
    version = sandboxes.get_template(GetTemplateRequest { template, ..Default::default() }).await?;
}
println!("{} {} {:?} {:?} {}", version.name, version.version, version.state, version.min_size, version.size_bytes);
```

CLI

```
$ pethost sandbox template save api-dev my-app --description 'Node 22 and our dependencies'
✓ Saving my-app@2: it is ready once uploaded. See:  pethost sandbox template show my-app@2
my-app@2
$ pethost sandbox template ls my-app
my-app@2   ready   68 MB      55 s ago    Node 22 and our dependencies
my-app@1   ready   24 MB      1 min ago   Node 22 and our dependencies
```

MCP

```
CreateTemplate {"name": "my-app", "sandbox_id": "…", "description": "Node 22 and our dependencies"}
ListTemplates {"name": "my-app"}
```

### Step 3: Uruchamiaj z niego sandboxy

Wskaż szablon w `CreateSandbox`: `"my-app"` to jego najnowsza wersja READY, `"my-app@2"` dokładnie ta jedna. Pierwszy sandbox danej wersji na serwerze ją pobiera, ok. 10 s na GiB; serwer ją zachowuje, a kolejne startują w ok. 0,22 s.

Python

```
preview = sandboxes.create_sandbox("my-app")
print(preview.sandbox_id, preview.template)  # 8j37xshusqwdz8cs my-app@1
```

TypeScript

```
const preview = await sandboxes.createSandbox({ template: "my-app" });
console.log(preview.sandboxId, preview.template);
```

Go

```
preview, err := client.CreateSandbox(ctx, &sandboxes.CreateSandboxRequest{Template: "my-app"})
if err != nil {
	log.Fatal(err)
}
fmt.Println(preview.SandboxID, preview.Template)
```

Rust

```
let preview = sandboxes
    .create_sandbox(CreateSandboxRequest { template: "my-app".into(), ..Default::default() })
    .await?;
println!("{} {}", preview.sandbox_id, preview.template);
```

CLI

```
$ pethost sandbox new --template my-app
✓ Made sandbox ofvm8by6buvd4rkd: default, running, from my-app@2, in <1 s
  port 5173: https://5173-ofvm8by6buvd4rkd.sbx1.sandboxes.pethost.network
ofvm8by6buvd4rkd
Next:   pethost sandbox run ofvm8by6buvd4rkd -- <command>   ·   pethost sandbox shell ofvm8by6buvd4rkd
```

MCP

```
CreateSandbox {"template": "my-app"}
```

`template` w odpowiedzi podaje dokładną wersję, z której wystartował, np. `my-app@1`.

## Co zachowuje szablon

- **Zachowuje:** każdy plik z dysku sandboxa, pakiety, twój kod, a wśród nich obrazy i kontenery Dockera; oraz ustawienia sandboxa, z którymi startują jego sandboxy, chyba że ich utworzenie mówi inaczej.
- **Nie zachowuje:** pamięci i procesów, więc sandbox z szablonu startuje bez niczego, co działało; historii poleceń i rozmów agentów kodujących, bez których startują jego sandboxy.
- **Świeże w każdym sandboxie:** własne id, nazwa hosta, machine-id i losowość jądra.

Żeby skopiować sandbox z pamięcią i procesami, taki, jaki jest w tej sekundzie, zrób jego fork: [forki](https://pethost.dev/pl/docs/sandboxes/forks/). Szablon jest na wiele sandboxów przez wiele dni; fork na kilka kopii teraz.

## Wersje i rozmiary

Każdy zapis pod daną nazwą to jej następna wersja. `"my-app"` zawsze oznacza najnowszą wersję READY, a w trakcie zapisu nowej poprzednią, więc zapis nigdy nie psuje twoich utworzeń. Nazwa zachowuje 10 wersji; wersja FAILED nie zajmuje miejsca i znika po dniu. Przestrzeń robocza zapisuje jedną wersję naraz, a sandbox zachowuje wersję, z której wystartował, nawet po usunięciu szablonu.

Wersja READY ma `min_size`: najmniejszy rozmiar, którego dysk mieści to, co zapisała. Jej sandboxy mogą mieć ten rozmiar albo większy. Utworzenie z mniejszym rozmiarem jest odrzucane, a odmowa podaje rozmiar, który pasuje.

## Gdzie jest przechowywany i ile kosztuje

Wersja jest zmniejszana do tego, co zawiera, kompresowana, szyfrowana własnym kluczem i przechowywana w magazynie obiektów w UE, skąd każdy serwer może uruchamiać z niej sandboxy. Liczą się tylko jej własne bajty, a nie baza pod nią. Szablony nie są rozliczane: twój plan ogranicza, ile zajmują razem wersje przestrzeni roboczej, 5 GiB w planie za 20 $ i 30 GiB w planie za 100 $ (`Limits.template_gib`; `Workspace.template_bytes` to, ile zajmują teraz). `DeleteTemplate` usuwa wszystkie wersje danej nazwy i od razu zwalnia miejsce; sandboxy z niego zrobione dalej działają, wstrzymują się i wznawiają.

## Nasz szablon: base

`base` to Ubuntu 24.04 z narzędziami do budowania i gitem, Python 3, Node.js 22, Docker z Compose, Claude Code, Codex i OpenCode oraz pulpit z Google Chrome. Przebudowujemy go co miesiąc i od razu przy poprawce bezpieczeństwa Chrome, jądra albo pakietu. `Template.base` nazywa wersję, na której startują sandboxy szablonu, przez skrót tego, co zawiera: zapisana przez ciebie wersja zachowuje bazę, na której wystartował jej sandbox, więc twój szablon nie zmienia się bez twojej wiedzy.

Nie ma budowania z pliku Dockerfile: wykonaj kroki swojego Dockerfile w sandboxie albo zrób w nim `docker build` i zapisz ten sandbox.

## Gdy to nie działa

- **`RESOURCE_EXHAUSTED` z `LimitReached`, `template_gib`:** wersje przestrzeni roboczej zajmują miejsce z jej planu albo zapisuje się inna wersja. Usuń stary szablon albo poczekaj na zapis.
- **`LimitReached`, `template_versions`:** nazwa ma 10 wersji. Zapisz pod nową nazwą albo usuń szablon i zapisz ponownie.
- **Wersja jest FAILED:** `failure_message` mówi dlaczego, np. własne bajty wersji przekroczyły pozostałe miejsce. Zwolnij miejsce i zapisz ponownie.
- **`INVALID_ARGUMENT` z rozmiarem:** rozmiar jest mniejszy niż `min_size` wersji. Poproś o ten rozmiar albo większy.
- **Pierwszy sandbox z nowej wersji jest wolny:** jego serwer pobrał wersję, ok. 10 s na GiB. Kolejne startują tam w ok. 0,22 s.

## Pytania

### Jak zrobić własny szablon sandboxa?

Ustaw sandbox tak, jak mają wyglądać nowe, a potem wywołaj `CreateTemplate` z nazwą i jego id. Nowe sandboxy uruchamiaj z tą nazwą.

### Czy szablon zachowuje działające procesy?

Nie: tylko pliki i ustawienia. Żeby skopiować działający sandbox z pamięcią i procesami, zrób jego fork.

### Czy szablony są rozliczane?

Nie. Twój plan ogranicza, ile GiB zajmują szablony przestrzeni roboczej w magazynie obiektów.

### Czy mogę zbudować szablon z pliku Dockerfile?

Nie bezpośrednio: wykonaj kroki Dockerfile albo `docker build` w sandboxie, a potem zapisz sandbox jako szablon.

### Czy obrazy Dockera przetrwają w szablonie?

Tak. Obrazy i kontenery Dockera są na dysku sandboxa, który szablon zachowuje.

[PoprzedniaSterowanie komputerem: Chrome na pulpicie w sandboxie](https://pethost.dev/pl/docs/sandboxes/computer-use/) [NastępnaSekrety i ruch wychodzący: klucze, których sandbox nie trzyma](https://pethost.dev/pl/docs/sandboxes/secrets-and-egress/)

## Wypróbuj Pethost Agent Sandboxes

Okres próbny na 7 dni z 1 $ zużycia i 4 vCPU, z kartą. Potem plan od 20 $ miesięcznie, który zawiera tyle samo zużycia.

[Zacznij okres próbny](https://console.pethost.dev/)

Pethost · Stephan Gomer · NIP 1133096755

Pethost

- [Szablony](https://pethost.dev/pl/templates/)
- [O nas](https://pethost.dev/about/)
- [Dokumentacja](https://pethost.dev/docs/)
- [Blog](https://pethost.dev/pl/blog/)
- [API](https://pethost.dev/docs/api/)
- [CLI](https://pethost.dev/docs/cli/)
- [Plugin](https://github.com/pethost-dev/plugin)
- [Regulamin](https://pethost.dev/terms/)
- [Prywatność](https://pethost.dev/privacy/)
- [Zwroty](https://pethost.dev/refunds/)
- [support@pethost.dev](mailto:support@pethost.dev)

Bazy danych

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

Agent Sandboxes

- [Sandboxy](https://pethost.dev/pl/sandboxes/)
- [Cennik](https://pethost.dev/pl/sandboxes/#pricing)
- [Dokumentacja](https://pethost.dev/pl/docs/sandboxes/)
- [API](https://pethost.dev/docs/sandboxes/api/)

Porównania

- [Coolify vs Dokploy vs CapRover vs Dokku](https://pethost.dev/pl/blog/coolify-vs-dokploy-vs-caprover-vs-dokku/)
- [Coolify Cloud vs Dokploy Cloud](https://pethost.dev/pl/blog/coolify-cloud-vs-dokploy-cloud/)
- [Cennik Railway vs Render vs Fly.io](https://pethost.dev/pl/blog/railway-vs-render-vs-fly-io-pricing/)
- [Zarządzany hosting Docker Compose](https://pethost.dev/pl/blog/managed-docker-compose-hosting/)

Alternatywy

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