---
title: "Копіюйте пісочницю разом із пам’яттю й процесами | Pethost Agent Sandboxes"
description: "Скопіюйте пісочницю, що працює, з її пам’яттю, процесами й диском — до 100 копій одним викликом, щоб пробувати кілька речей з тієї самої точки водночас."
---

[Документація Agent Sandboxes](https://pethost.dev/uk/docs/sandboxes/) · Завдання

# Копіюйте пісочницю разом із пам’яттю й процесами

Оновлено 22 листопада 2026 р. · 5 хв читання

Копіювання (fork) переносить пісочницю такою, як вона є цієї миті, з пам’яттю, запущеними процесами й диском, у нові пісочниці, що продовжують звідти. Агент пробує три виправлення водночас з одного стану, оцінювання запускає сотню сідів з одного прогрітого середовища, а копії, що програли, видаляються.

**Коротко**

- **`ForkSandbox`** робить до 100 копій одним викликом, RUNNING на сервері вихідної пісочниці; три займають приблизно 0,25 с.
- **Вихідна працює далі:** та, що працює, стає на паузу на кілька мілісекунд; та, що на паузі, лишається на паузі; копії зупиненої стартують із її диска.
- **Кожна копія** має власні id, ім’я хоста, machine-id і випадковість ядра, розмір вихідної пісочниці й не має назви.
- **Усі або жодної:** кожна копія — це запуск і рахує свої vCPU; коли вміщуються не всі, не створюється жодна.

### Step 1: Скопіюйте пісочницю

Дайте копіям власну мітку, щоб пізніше знайти їх разом. Без неї вони беруть мітки вихідної пісочниці.

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: Дайте кожній копії власну роботу

Кожна копія відповідає на власні виклики. Запустіть у кожній іншу задачу, не чекаючи на неї, і позначте її `keep_awake`, щоб жодна копія не стала на паузу посеред своєї задачі.

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: Лишіть ту, що спрацювала, а решту видаліть

`ListSandboxes` з міткою прогону знаходить копії; видаліть ті, які не лишаєте. Копія, яку ви лишили, — така сама пісочниця, як будь-яка інша: дайте їй назву через `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
```

## Що має копія

Копія — це вихідна пісочниця такою, якою вона була в момент копіювання: ті самі файли, та сама пам’ять, ті самі процеси на тій самій інструкції. Сервер розробки далі обслуговує запити, сесія Python зберігає свої змінні, розмова агента для коду чекає на продовження — у кожній копії. Копії працюють на сервері вихідної пісочниці, з її розміром і її диском. Інші налаштування в них — як у вихідної, якщо копіювання не надсилає власної групи (`settings`), як-от інший вихідний трафік чи середовище; інший розмір відхиляється.

Кожна копія отримує власний id, що є також її іменем хоста, власний machine-id і свіжу випадковість ядра, тож `/dev/urandom` відрізняється з першого ж читання. Назви вона не має: назви унікальні, і `UpdateSandbox` дає назву копії, яку ви лишаєте.

## Перезасівайте генератори випадкових чисел

Ядро в кожній копії перезасівається; власний генератор процесу — ні. Генератор випадкових чисел, засіяний до копіювання, — `random` у Python, `math/rand` у Go, `Math.random` у V8, генератор OpenSSL — дає ті самі числа в кожній копії, доки його не засіяти знову, а ключі, створені до копіювання, однакові в кожній копії. Засівайте експерименти після копіювання, як це робить сід вище, і ключі теж створюйте після нього.

## Вихідна пісочниця і скільки коштує копіювання

- **Вихідна пісочниця RUNNING** стає на паузу на кілька мілісекунд, поки знімаються її пам’ять і диск, і працює далі.
- **Вихідна пісочниця PAUSED** лишається на паузі, а її копії стартують зі збереженої пам’яті.
- **Вихідна пісочниця STOPPED** не має пам’яті: її копії стартують із її диска, як під час завантаження.

Копіювання відбувається повністю або ніяк. Кожна копія з моменту запуску рахує свої vCPU в ліміт тарифу, і кожна — це запуск у межах запусків тарифу на хвилину, годину й день. Запуски безкоштовні: копія коштує того, що відпрацює, посекундно, як будь-яка пісочниця. Коли на сервері вихідної пісочниці немає місця для кожної копії, виклик відхиляється з `UNAVAILABLE` і `NoCapacity`, чий `fork_count` каже, скільки вміщується. Пісочницю з томом для читання й запису скопіювати не можна, бо в том пише одна пісочниця за раз.

## Коли не працює

- **`UNAVAILABLE` з `NoCapacity`:** на сервері вихідної пісочниці немає місця для всіх копій. Попросіть `fork_count` копій чи менше або спробуйте пізніше.
- **`RESOURCE_EXHAUSTED` з `LimitReached`, `vcpus`:** копії перевищили б vCPU вашого тарифу. Видаліть пісочниці, які більше не потрібні, або робіть менше копій.
- **`LimitReached` з лімітом `starts_per_*`:** копії перевищили б запуски вікна; `retry_time` каже, коли вони вмістяться. Копіювання в більше копій, ніж сам ліміт, не має `retry_time`: розбийте його.
- **`FAILED_PRECONDITION`:** пісочниця монтує том для читання й запису. Копіюйте ту, що монтує його лише для читання, або без тому.
- **Кожна копія виводить ті самі випадкові числа:** генератор засіяно до копіювання. Засійте його знову в кожній копії.

## Запитання

### Як склонувати пісочницю, що працює?

`ForkSandbox` з `count`: кожна копія має пам’ять, процеси й диск вихідної пісочниці й продовжує з того місця, де та була.

### Скільки копій може зробити одне копіювання?

До 100, усі або жодної, у межах vCPU і запусків вашого тарифу.

### Чи зупиняє копіювання вихідну пісочницю?

Ні. Вихідна, що працює, стає на паузу на кілька мілісекунд і працює далі.

### Чи оплачується копіювання?

Запуски безкоштовні. Кожна копія оплачується посекундно за свій стан, як будь-яка пісочниця.

### Чим копіювання відрізняється від шаблону?

Копіювання переносить пісочницю зараз, із пам’яттю й процесами, на її сервері. Шаблон зберігає файли пісочниці для нових пісочниць на будь-якому сервері, без пам’яті й процесів.

[НазадСекрети й вихідний трафік: ключі, яких пісочниця не тримає](https://pethost.dev/uk/docs/sandboxes/secrets-and-egress/) [ДаліТоми: диск, що переживає пісочниці](https://pethost.dev/uk/docs/sandboxes/volumes/)

## Спробуйте Pethost Agent Sandboxes

Пробний період на 7 днів із використанням на 1 $ і 4 vCPU, потрібна картка. Далі — тариф від 20 $ на місяць, який включає стільки ж використання.

[Почати пробний період](https://console.pethost.dev/)

Pethost · Stephan Gomer · NIP 1133096755

Pethost

- [Шаблони](https://pethost.dev/uk/templates/)
- [Про нас](https://pethost.dev/about/)
- [Документація](https://pethost.dev/docs/)
- [Блог](https://pethost.dev/uk/blog/)
- [API](https://pethost.dev/docs/api/)
- [CLI](https://pethost.dev/docs/cli/)
- [Плагін](https://github.com/pethost-dev/plugin)
- [Умови](https://pethost.dev/terms/)
- [Конфіденційність](https://pethost.dev/privacy/)
- [Повернення коштів](https://pethost.dev/refunds/)
- [support@pethost.dev](mailto:support@pethost.dev)

Бази даних

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

Agent Sandboxes

- [Пісочниці](https://pethost.dev/uk/sandboxes/)
- [Тарифи](https://pethost.dev/uk/sandboxes/#pricing)
- [Документація](https://pethost.dev/uk/docs/sandboxes/)
- [API](https://pethost.dev/docs/sandboxes/api/)

Порівняння

- [Coolify vs Dokploy vs CapRover vs Dokku](https://pethost.dev/uk/blog/coolify-vs-dokploy-vs-caprover-vs-dokku/)
- [Coolify Cloud vs Dokploy Cloud](https://pethost.dev/uk/blog/coolify-cloud-vs-dokploy-cloud/)
- [Ціни Railway vs Render vs Fly.io](https://pethost.dev/uk/blog/railway-vs-render-vs-fly-io-pricing/)
- [Керований хостинг Docker Compose](https://pethost.dev/uk/blog/managed-docker-compose-hosting/)

Альтернативи

- [Альтернативи Railway](https://pethost.dev/uk/blog/railway-alternatives/)
- [Альтернативи Heroku](https://pethost.dev/uk/blog/heroku-alternatives/)
- [Альтернативи Dokploy](https://pethost.dev/uk/blog/dokploy-alternatives/)
- [Альтернативи Coolify](https://pethost.dev/uk/blog/coolify-alternatives/)
- [Альтернативи Render](https://pethost.dev/uk/blog/render-alternatives/)
- [Альтернативи Sliplane](https://pethost.dev/uk/blog/sliplane-alternatives/)
