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

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

# Форк песочницы вместе с памятью и процессами

Обновлено 22 ноября 2026 г. · 5 мин чтения

Форк копирует песочницу такой, какая она в этот момент, — ее память, работающие процессы и диск — в новые песочницы, которые продолжают оттуда. Агент пробует три исправления сразу из одного состояния, эвал прогоняет сотню сидов из одного прогретого окружения, а проигравшие копии удаляются.

**Коротко**

- **`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
```

## Что есть у копии

Копия — это источник таким, каким он был в момент форка: те же файлы, та же память, те же процессы на той же инструкции. Dev-сервер продолжает отвечать, сессия Python сохраняет свои переменные, разговор агента для кода можно продолжить — в каждой копии. Копии работают на сервере источника, с его размером и его диском. Остальные настройки у них как у источника, если форк не отправляет свою группу (`settings`), например другой исходящий трафик или окружение; другой размер получает отказ.

Каждая копия получает свой ID, который заодно ее имя хоста, свой machine-id и свежую случайность ядра, так что `/dev/urandom` отличается с первого же чтения. Имени у нее нет: имена уникальны, и `UpdateSandbox` дает имя оставленной копии.

## Переинициализируйте то, что генерирует случайные числа

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

## Источник и сколько стоит форк

- **Работающий источник** замирает на несколько миллисекунд, пока снимаются его память и диск, и продолжает работу.
- **Источник на паузе** остается на паузе, а его копии запускаются из его сохраненной памяти.
- **У остановленного источника** памяти нет: его копии запускаются с его диска, загружаясь с нуля.

Форк — все или ничего. Каждая копия с момента запуска учитывает свои 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/ru/docs/sandboxes/secrets-and-egress/) [СледующаяТома: диск, который переживает песочницы](https://pethost.dev/ru/docs/sandboxes/volumes/)

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

Пробный период на 7 дней: 1 $ использования и 4 vCPU, нужна карта. Затем тариф от 20 $ в месяц, в который входит столько же использования.

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

Pethost · Stephan Gomer · NIP 1133096755

Pethost

- [Шаблоны](https://pethost.dev/ru/templates/)
- [О нас](https://pethost.dev/about/)
- [Документация](https://pethost.dev/docs/)
- [Блог](https://pethost.dev/ru/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/ru/postgres/)
- [Valkey](https://pethost.dev/ru/valkey/)

Agent Sandboxes

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

Сравнения

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

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

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