Українська
Меню документації

Документація Agent Sandboxes · Завдання

Томи: диск, що переживає пісочниці

Оновлено · 5 хв читання

Том — це диск поза будь-якою пісочницею, змонтований в одну з них за шляхом: набір даних, який читають багато пісочниць, кеш, що переживає кожну задачу, файли, які має лишити по собі пісочниця, що її видаляють. Він лежить на диску одного сервера, і це треба знати, перш ніж щось на нього класти.

Коротко
  • CreateVolume створює том від 1 до 1 000 GiB; CreateSandbox монтує до 4 томів під час створення, кожен за своїм шляхом.
  • Для читання й запису — в одній пісочниці за раз, лише для читання — у будь-якій кількості.
  • На одному сервері, без копій: пісочниця, що його монтує, працює там, і якщо цей сервер утрачено, утрачено й том.
  • Оплачується за весь розмір, 0,20 $ за GiB на місяць, використаний чи ні.

Step 1: Створіть том

Том створюється порожнім, на сервері, де є місце, а його корінь належить user.

Python
volume = sandboxes.create_volume("data", size_gib=10)
print(volume.volume_id, volume.size_gib)  # ziwv1r8ean3dd9sk 10
TypeScript
const volume = await sandboxes.createVolume({ name: "data", sizeGib: 10 });
console.log(volume.volumeId, volume.sizeGib);
Go
volume, err := client.CreateVolume(ctx, &sandboxes.CreateVolumeRequest{Name: "data", SizeGib: 10})
if err != nil {
	log.Fatal(err)
}
fmt.Println(volume.VolumeID, volume.SizeGib)
Rust
let volume = sandboxes
    .create_volume(CreateVolumeRequest { name: "data".into(), size_gib: 10, ..Default::default() })
    .await?;
println!("{} {}", volume.volume_id, volume.size_gib);
CLI
$ pethost sandbox volume new data --size 10
✓ Made the volume data, 10 GiB. Mount it:  pethost sandbox new --mount o2rvhgm1dxaefoj7:/data
o2rvhgm1dxaefoj7

Step 2: Змонтуйте його в пісочницю

Монтування задаються під час створення, кожне — том і абсолютний шлях. Пісочниця працює на сервері тому.

Python
from pethost.sandboxes import Mount

writer = sandboxes.create_sandbox("base", mounts=[Mount(volume_id=volume.volume_id, path="/data")])
sandboxes.run_command(writer.sandbox_id, command="date > /data/first-run.txt")
TypeScript
const writer = await sandboxes.createSandbox({
  template: "base",
  mounts: [{ volumeId: volume.volumeId, path: "/data" }],
});
await sandboxes.runCommand({ sandboxId: writer.sandboxId, command: "date > /data/first-run.txt" });
Go
writer, err := client.CreateSandbox(ctx, &sandboxes.CreateSandboxRequest{
	Template: "base",
	Mounts:   []sandboxes.Mount{{VolumeID: volume.VolumeID, Path: "/data"}},
})
if err != nil {
	log.Fatal(err)
}
_, err = client.RunCommand(ctx, &sandboxes.RunCommandRequest{SandboxID: writer.SandboxID, Command: "date > /data/first-run.txt"})
Rust
let mount = Mount { volume_id: volume.volume_id.clone(), path: "/data".into(), ..Default::default() };
let writer = sandboxes
    .create_sandbox(CreateSandboxRequest { template: "base".into(), mounts: vec![mount], ..Default::default() })
    .await?;
sandboxes
    .run_command(RunCommandRequest {
        sandbox_id: writer.sandbox_id.clone(),
        command: "date > /data/first-run.txt".into(),
        ..Default::default()
    })
    .await?;
CLI
$ pethost sandbox new --name writer --mount o2rvhgm1dxaefoj7:/data
✓ Made sandbox writer (upc3ehxd65rjgz32): default, running, from base@17, in <1 s
upc3ehxd65rjgz32
Next:   pethost sandbox run upc3ehxd65rjgz32 -- <command>   ·   pethost sandbox shell upc3ehxd65rjgz32
$ pethost sandbox run writer -- 'date > /data/first-run.txt'
MCP
CreateSandbox {"name": "writer", "mounts": [{"volume_id": "…", "path": "/data"}]}

Step 3: Діліться ним для читання й видаліть, коли закінчите

Щойно жодна пісочниця не монтує його для читання й запису, будь-яка кількість може змонтувати його лише для читання. Том лишається, коли видаляють пісочниці, що його монтували, і зникає лише через DeleteVolume, який відхиляється, поки том монтує якась пісочниця.

Python
sandboxes.delete_sandbox(writer.sandbox_id)
reader = sandboxes.create_sandbox("base", mounts=[Mount(volume_id=volume.volume_id, path="/data", read_only=True)])
print(sandboxes.run_command(reader.sandbox_id, command="cat /data/first-run.txt").stdout)  # Sun Nov 22 00:25:33 UTC 2026
sandboxes.delete_sandbox(reader.sandbox_id)
sandboxes.delete_volume(volume.volume_id)
TypeScript
await sandboxes.deleteSandbox({ sandboxId: writer.sandboxId });
const reader = await sandboxes.createSandbox({
  template: "base",
  mounts: [{ volumeId: volume.volumeId, path: "/data", readOnly: true }],
});
console.log((await sandboxes.runCommand({ sandboxId: reader.sandboxId, command: "cat /data/first-run.txt" })).stdout);
await sandboxes.deleteSandbox({ sandboxId: reader.sandboxId });
await sandboxes.deleteVolume({ volumeId: volume.volumeId });
Go
if _, err := client.DeleteSandbox(ctx, &sandboxes.DeleteSandboxRequest{SandboxID: writer.SandboxID}); err != nil {
	log.Fatal(err)
}
reader, err := client.CreateSandbox(ctx, &sandboxes.CreateSandboxRequest{
	Template: "base",
	Mounts:   []sandboxes.Mount{{VolumeID: volume.VolumeID, Path: "/data", ReadOnly: true}},
})
if err != nil {
	log.Fatal(err)
}
read, err := client.RunCommand(ctx, &sandboxes.RunCommandRequest{SandboxID: reader.SandboxID, Command: "cat /data/first-run.txt"})
if err != nil {
	log.Fatal(err)
}
fmt.Print(read.Stdout)
_, err = client.DeleteSandbox(ctx, &sandboxes.DeleteSandboxRequest{SandboxID: reader.SandboxID})
if err == nil {
	_, err = client.DeleteVolume(ctx, &sandboxes.DeleteVolumeRequest{VolumeID: volume.VolumeID})
}
Rust
sandboxes
    .delete_sandbox(DeleteSandboxRequest { sandbox_id: writer.sandbox_id.clone(), ..Default::default() })
    .await?;
let mount = Mount { volume_id: volume.volume_id.clone(), path: "/data".into(), read_only: true };
let reader = sandboxes
    .create_sandbox(CreateSandboxRequest { template: "base".into(), mounts: vec![mount], ..Default::default() })
    .await?;
let read = sandboxes
    .run_command(RunCommandRequest {
        sandbox_id: reader.sandbox_id.clone(),
        command: "cat /data/first-run.txt".into(),
        ..Default::default()
    })
    .await?;
print!("{}", read.stdout);
sandboxes
    .delete_sandbox(DeleteSandboxRequest { sandbox_id: reader.sandbox_id.clone(), ..Default::default() })
    .await?;
sandboxes
    .delete_volume(DeleteVolumeRequest { volume_id: volume.volume_id.clone(), ..Default::default() })
    .await?;
CLI
$ pethost sandbox rm writer --yes
upc3ehxd65rjgz32   deleted
$ pethost sandbox new --name reader --mount o2rvhgm1dxaefoj7:/data:ro
✓ Made sandbox reader (zc44605gliwn2v1b): default, running, from base@17, in <1 s
zc44605gliwn2v1b
Next:   pethost sandbox run zc44605gliwn2v1b -- <command>   ·   pethost sandbox shell zc44605gliwn2v1b
$ pethost sandbox run reader -- cat /data/first-run.txt
Sun Nov 22 00:25:40 UTC 2026
$ pethost sandbox rm reader --yes
zc44605gliwn2v1b   deleted
$ pethost sandbox volume rm o2rvhgm1dxaefoj7 --yes
o2rvhgm1dxaefoj7

Де лежить том

Том — це файл на диску одного сервера пісочниць із файловою системою ext4, а пісочниця, що його монтує, працює на цьому сервері. Він не копіюється ні в об’єктне сховище, ні на інший сервер. Це має три наслідки:

  • Якщо його сервер утрачено, утрачено й том: він стає DELETED, а пісочниці, що його монтували, втрачають його. Не тримайте там єдиної копії нічого: те, що важливо, надсилайте ще й у власне сховище.
  • Пісочниця з томом лишається на своєму сервері. Зупинена пісочниця без томів може запуститися на іншому сервері, коли її власний заповнений; пісочниця з томом чекає місця на своєму й тим часом отримує відмову з NoCapacity.
  • Пісочницю з томом для читання й запису не можна скопіювати: у том пише одна пісочниця за раз.

Том ділить швидкість диска з пісочницею, що його монтує, — 64 MiB/s на vCPU. Том, більший за половину диска сервера, відхиляється.

Томи й власний диск пісочниці

Більшості робіт том не потрібен. Власний диск пісочниці переживає її паузи й зупинки: диск зупиненої пісочниці зберігається в об’єктному сховищі й повертається, коли вона продовжується, на будь-якому сервері. Шаблон переносить файли в кожну нову пісочницю. Том — для даних, що переживають пісочниці, які ними користуються, або які багато хто читає одночасно: набір даних, ваги моделі, спільний кеш.

Скільки він коштує

Том рахується за весь розмір, 0,20 $ за GiB на місяць, посекундно, від створення до видалення, чи монтує його пісочниця, чи ні. Ваш тариф обмежує, скільки разом займають томи робочого простору: 100 GiB на тарифі за 20 $, 600 GiB на тарифі за 100 $, 10 GiB у пробному періоді. Workspace.volume_gib_used каже, скільки вони займають зараз.

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

  • FAILED_PRECONDITION, том змонтовано іншою пісочницею: його змонтовано для читання й запису. Змонтуйте його лише для читання або видаліть чи зупиніть пісочницю, що в нього пише.
  • FAILED_PRECONDITION, журнал, можливо, треба відтворити: остання пісочниця, що в нього писала, завершилася, не відмонтувавши його. Змонтуйте його один раз для читання й запису, потім знову лише для читання.
  • FAILED_PRECONDITION на DeleteVolume: його монтує пісочниця. Спершу видаліть ту пісочницю.
  • RESOURCE_EXHAUSTED з LimitReached, volume_gib: томи робочого простору перевищили б GiB тарифу. Видаліть один або зробіть його меншим.
  • UNAVAILABLE з NoCapacity під час створення чи продовження: на сервері тому зараз немає місця, а пісочниця з томом не може піти деінде. Спробуйте пізніше.

Запитання

Чи є в тому бекап?

Ні. Він лежить на диску одного сервера й нікуди не копіюється: тримайте копію важливого деінде.

Чи можуть кілька пісочниць ділити один том?

Лише для читання — будь-яка кількість одночасно. Для читання й запису — одна за раз.

Чи можна змонтувати том у пісочницю, що працює?

Ні: монтування задаються під час створення, до 4 на пісочницю.

Чи оплачується том, поки його ніхто не монтує?

Так, за весь розмір, 0,20 $ за GiB на місяць, доки ви його не видалите.

Чи потрібен том, щоб зберігати файли між сесіями?

Ні. Власний диск пісочниці переживає паузи й зупинки; том — для даних, що переживають пісочницю.

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

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

Почати пробний період