---
title: "Fork sandboxa, razem z pamięcią i procesami | Pethost Agent Sandboxes"
description: "Skopiuj działający sandbox, z pamięcią, procesami i dyskiem, nawet do 100 sandboxów jednym wywołaniem, żeby naraz próbować kilku rzeczy od tego samego miejsca."
---

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

# Fork sandboxa, razem z pamięcią i procesami

Zaktualizowano 22 listopada 2026 · 5 min czytania

Fork kopiuje sandbox taki, jaki jest w tej chwili, z pamięcią, działającymi procesami i dyskiem, do nowych sandboxów, które idą dalej od tego miejsca. Agent próbuje naraz trzech poprawek z tego samego stanu, ewaluacja uruchamia sto ziaren z jednego rozgrzanego środowiska, a kopie, które przegrają, są usuwane.

**W skrócie**

- **`ForkSandbox`** robi do 100 kopii jednym wywołaniem, w stanie RUNNING na serwerze źródła; trzy zajmują ok. 0,25 s.
- **Źródło działa dalej:** działające wstrzymuje się na kilka milisekund; wstrzymane zostaje wstrzymane; kopie zatrzymanego startują z jego dysku.
- **Każda kopia** ma własne id, nazwę hosta, machine-id i losowość jądra, rozmiar źródła i żadnej nazwy.
- **Wszystkie albo żadna:** każda kopia to start i liczy swoje vCPU; gdy nie zmieszczą się wszystkie, nie powstaje żadna.

### Step 1: Zrób fork sandboxa

Daj kopiom własną etykietę, żeby później znaleźć je razem. Bez niej dostają etykiety źródła.

Python

```
from pethost.sandboxes import Label

run = Label(key="run", value="seeds-7")
copies = sandboxes.fork_sandbox(sandbox_id, count=3, labels=[run]).sandboxes
print([copy.sandbox_id for copy in copies])
# ['kecrb56zb2sqfmy0', '9pd5esg1e2vguf1j', 'zawco1pzbjzgxjyy']
```

TypeScript

```
const run = { key: "run", value: "seeds-7" };
const { sandboxes: copies } = await sandboxes.forkSandbox({ sandboxId, count: 3, labels: [run] });
console.log(copies.map((copy) => copy.sandboxId));
```

Go

```
run := sandboxes.Label{Key: "run", Value: "seeds-7"}
forked, err := client.ForkSandbox(ctx, &sandboxes.ForkSandboxRequest{SandboxID: id, Count: 3, Labels: []sandboxes.Label{run}})
if err != nil {
	log.Fatal(err)
}
for _, copy := range forked.Sandboxes {
	fmt.Println(copy.SandboxID)
}
```

Rust

```
let run = Label { key: "run".into(), value: "seeds-7".into() };
let copies = sandboxes
    .fork_sandbox(ForkSandboxRequest {
        sandbox_id: id.clone(),
        count: 3,
        labels: vec![run.clone()],
        ..Default::default()
    })
    .await?
    .sandboxes;
for copy in &copies {
    println!("{}", copy.sandbox_id);
}
```

CLI

```
$ pethost sandbox fork api-dev --count 3 --label run=seeds-7
✓ Forked api-dev into 3 sandboxes in 1 s
us8wjivt4ndyu3mn
7sfjrgzwk72v3ie4
955mpq7p89sfaezv
```

MCP

```
ForkSandbox {"sandbox_id": "…", "count": 3, "labels": [{"key": "run", "value": "seeds-7"}]}
```

### Step 2: Daj każdej kopii własną pracę

Każda kopia odpowiada na własne wywołania. Uruchom w każdej inne zadanie, nie czekając na nie, i oznacz je `keep_awake`, żeby żadna kopia nie wstrzymała się w trakcie swojego zadania.

Python

```
for seed, copy in enumerate(copies):
    sandboxes.run_command(
        copy.sandbox_id,
        command=f"python3 experiment.py --seed {seed} > result.txt",
        wait_seconds=0,
        keep_awake=True,
    )
```

TypeScript

```
await Promise.all(
  copies.map((copy, seed) =>
    sandboxes.runCommand({
      sandboxId: copy.sandboxId,
      command: `python3 experiment.py --seed ${seed} > result.txt`,
      waitSeconds: 0,
      keepAwake: true,
    }),
  ),
);
```

Go

```
for seed, copy := range forked.Sandboxes {
	_, err := client.RunCommand(ctx, &sandboxes.RunCommandRequest{
		SandboxID:   copy.SandboxID,
		Command:     fmt.Sprintf("python3 experiment.py --seed %d > result.txt", seed),
		WaitSeconds: new(uint32(0)),
		KeepAwake:   true,
	})
	if err != nil {
		log.Fatal(err)
	}
}
```

Rust

```
for (seed, copy) in copies.iter().enumerate() {
    sandboxes
        .run_command(RunCommandRequest {
            sandbox_id: copy.sandbox_id.clone(),
            command: format!("python3 experiment.py --seed {seed} > result.txt"),
            wait_seconds: Some(0),
            keep_awake: true,
            ..Default::default()
        })
        .await?;
}
```

### Step 3: Zostaw tę, która zadziałała, resztę usuń

`ListSandboxes` z etykietą przebiegu znajduje kopie; usuń te, których nie zostawiasz. Zostawiona kopia to sandbox jak każdy inny: nadaj jej nazwę przez `UpdateSandbox`.

Python

```
best = copies[0].sandbox_id  # the copy whose result you keep
for copy in sandboxes.list_sandboxes(labels=[run]).sandboxes:
    if copy.sandbox_id != best:
        sandboxes.delete_sandbox(copy.sandbox_id)
```

TypeScript

```
const best = copies[0]!.sandboxId; // the copy whose result you keep
const { sandboxes: found } = await sandboxes.listSandboxes({ labels: [run] });
for (const copy of found) {
  if (copy.sandboxId !== best) await sandboxes.deleteSandbox({ sandboxId: copy.sandboxId });
}
```

Go

```
best := forked.Sandboxes[0].SandboxID // the copy whose result you keep
found, err := client.ListSandboxes(ctx, &sandboxes.ListSandboxesRequest{Labels: []sandboxes.Label{run}})
if err != nil {
	log.Fatal(err)
}
for _, copy := range found.Sandboxes {
	if copy.SandboxID != best {
		if _, err := client.DeleteSandbox(ctx, &sandboxes.DeleteSandboxRequest{SandboxID: copy.SandboxID}); err != nil {
			log.Fatal(err)
		}
	}
}
```

Rust

```
let best = copies[0].sandbox_id.clone(); // the copy whose result you keep
let found = sandboxes
    .list_sandboxes(ListSandboxesRequest { labels: vec![run], ..Default::default() })
    .await?;
for copy in found.sandboxes.iter().filter(|copy| copy.sandbox_id != best) {
    let gone = DeleteSandboxRequest { sandbox_id: copy.sandbox_id.clone(), ..Default::default() };
    sandboxes.delete_sandbox(gone).await?;
}
```

CLI

```
$ pethost sandbox ls --label run=seeds-7
ID                 NAME   STATE     SIZE      TEMPLATE   CREATED    LABELS
us8wjivt4ndyu3mn          running   default   base@17    20 s ago   run=seeds-7
955mpq7p89sfaezv          running   default   base@17    20 s ago   run=seeds-7
7sfjrgzwk72v3ie4          running   default   base@17    20 s ago   run=seeds-7
$ pethost sandbox rm us8wjivt4ndyu3mn 7sfjrgzwk72v3ie4 --yes
us8wjivt4ndyu3mn   deleted
7sfjrgzwk72v3ie4   deleted
```

## Co ma kopia

Kopia to źródło takie, jakie było w chwili forka: te same pliki, ta sama pamięć, te same procesy na tej samej instrukcji. Serwer deweloperski dalej serwuje, sesja Pythona zachowuje swoje zmienne, a rozmowa agenta kodującego jest gotowa do kontynuacji, w każdej kopii. Kopie działają na serwerze źródła, w rozmiarze źródła i z jego dyskiem. Ich pozostałe ustawienia są takie jak źródła, chyba że fork wysyła własną grupę (`settings`), np. inny ruch wychodzący albo środowisko; inny rozmiar jest odrzucany.

Każda kopia dostaje własne id, które jest też jej nazwą hosta, własny machine-id i świeżą losowość jądra, więc `/dev/urandom` różni się od pierwszego odczytu. Nie ma nazwy: nazwy są unikalne, a `UpdateSandbox` nadaje ją zostawionej kopii.

## Daj nowe ziarno temu, co generuje liczby losowe

Jądro dostaje nowe ziarno w każdej kopii; własny generator procesu nie. Generator losowy zainicjowany przed forkiem, `random` w Pythonie, `math/rand` w Go, `Math.random` w V8, generator OpenSSL, daje w każdej kopii te same liczby, dopóki nie dostanie nowego ziarna, a klucze wygenerowane przed forkiem są takie same w każdej kopii. Inicjuj eksperymenty po forku, jak robi to ziarno powyżej, i klucze też generuj po nim.

## Źródło i koszt forka

- **Źródło RUNNING** wstrzymuje się na kilka milisekund, gdy pobierane są jego pamięć i dysk, i działa dalej.
- **Źródło PAUSED** zostaje wstrzymane, a jego kopie startują z jego zapisanej pamięci.
- **Źródło STOPPED** nie ma pamięci: jego kopie startują z jego dysku, jak przy uruchomieniu systemu.

Fork to wszystkie albo żadna. Każda kopia liczy swoje vCPU do twojego planu od swojego startu i każda jest startem w limicie startów planu na minutę, godzinę i dzień. Starty są darmowe: kopia kosztuje to, co działa, co do sekundy, jak każdy sandbox. Gdy serwer źródła nie ma miejsca na wszystkie kopie, wywołanie jest odrzucane z `UNAVAILABLE` i `NoCapacity`, którego `fork_count` mówi, ile się zmieści. Z sandboxa z wolumenem do odczytu i zapisu nie da się zrobić forka, bo wolumen zapisuje naraz jeden sandbox.

## Gdy to nie działa

- **`UNAVAILABLE` z `NoCapacity`:** serwer źródła nie ma miejsca na wszystkie kopie. Poproś o `fork_count` kopii lub mniej albo spróbuj później.
- **`RESOURCE_EXHAUSTED` z `LimitReached`, `vcpus`:** kopie przekroczyłyby vCPU twojego planu. Usuń niepotrzebne sandboxy albo zrób mniej kopii.
- **`LimitReached` z limitem `starts_per_*`:** kopie przekroczyłyby starty okna; `retry_time` mówi, kiedy się zmieszczą. Fork z większą liczbą kopii niż sam limit nie ma `retry_time`: podziel go.
- **`FAILED_PRECONDITION`:** sandbox montuje wolumen do odczytu i zapisu. Rób fork sandboxa, który montuje go tylko do odczytu albo nie montuje wcale.
- **Każda kopia wypisuje te same liczby losowe:** generator dostał ziarno przed forkiem. Zainicjuj go ponownie w każdej kopii.

## Pytania

### Jak sklonować działający sandbox?

`ForkSandbox` z `count`: każda kopia ma pamięć, procesy i dysk źródła i działa dalej od miejsca, w którym było źródło.

### Ile kopii może zrobić jeden fork?

Do 100, wszystkie albo żadna, w ramach vCPU i startów twojego planu.

### Czy fork zatrzymuje oryginalny sandbox?

Nie. Działające źródło wstrzymuje się na kilka milisekund i działa dalej.

### Czy fork jest rozliczany?

Starty są darmowe. Każda kopia jest rozliczana co do sekundy za swój stan, jak każdy sandbox.

### Czym różni się fork od szablonu?

Fork kopiuje sandbox teraz, z pamięcią i procesami, na jego serwerze. Szablon zachowuje pliki sandboxa dla nowych sandboxów na dowolnym serwerze, bez pamięci i procesów.

[PoprzedniaSekrety i ruch wychodzący: klucze, których sandbox nie trzyma](https://pethost.dev/pl/docs/sandboxes/secrets-and-egress/) [NastępnaWolumeny: dysk, który przeżywa sandboxy](https://pethost.dev/pl/docs/sandboxes/volumes/)

## 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/)
