Polski
Menu dokumentacji

Dokumentacja Agent Sandboxes · Zadania

Wolumeny: dysk, który przeżywa sandboxy

Zaktualizowano · 5 min czytania

Wolumen to dysk poza wszystkimi sandboxami, montowany w sandboxie pod ścieżką: zbiór danych czytany przez wiele sandboxów, cache, który przeżywa każde zadanie, pliki, które ma po sobie zostawić usuwany sandbox. Leży na dysku jednego serwera i to musisz wiedzieć, zanim cokolwiek na nim położysz.

W skrócie
  • CreateVolume tworzy wolumen od 1 do 1000 GiB; CreateSandbox montuje przy tworzeniu do 4, każdy pod ścieżką.
  • Do zapisu w jednym sandboxie naraz, do odczytu w dowolnej liczbie.
  • Na jednym serwerze, bez kopii: sandbox, który go montuje, działa tam, a gdy ten serwer przepadnie, przepada też wolumen.
  • Rozliczany za cały rozmiar, 0,20 $ miesięcznie za GiB, zajęty czy nie.

Step 1: Utwórz wolumen

Wolumen powstaje pusty, na serwerze z wolnym miejscem, a jego katalog główny należy do 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: Zamontuj go w sandboxie

Montowania podaje się przy tworzeniu, każde to wolumen i ścieżka bezwzględna. Sandbox działa na serwerze wolumenu.

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: Udostępnij go do odczytu, a na koniec usuń

Gdy żaden sandbox nie montuje go do zapisu, dowolna liczba może zamontować go do odczytu. Wolumen zostaje, gdy sandboxy, które go montowały, zostaną usunięte, i znika tylko przez DeleteVolume, które jest odrzucane, dopóki montuje go jakiś sandbox.

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

Gdzie leży wolumen

Wolumen to plik na dysku jednego serwera sandboxów, z systemem plików ext4, a sandbox, który go montuje, działa na tym serwerze. Nie jest kopiowany do magazynu obiektów ani na inny serwer. Ma to trzy skutki:

  • Gdy jego serwer przepadnie, przepada wolumen: przechodzi w DELETED, a sandboxy, które go montowały, go tracą. Nie trzymaj tam jedynej kopii niczego: to, co ważne, wysyłaj też do własnego magazynu.
  • Sandbox z wolumenem zostaje na swoim serwerze. Zatrzymany sandbox bez wolumenów może wystartować na innym serwerze, gdy jego własny jest pełny; taki z wolumenem czeka na miejsce na własnym, a w tym czasie jest odrzucany z NoCapacity.
  • Z sandboxa z wolumenem do zapisu nie da się zrobić forka: wolumen zapisuje naraz jeden sandbox.

Wolumen dzieli szybkość dysku z sandboxem, który go montuje, 64 MiB/s na vCPU. Wolumen większy niż połowa dysku serwera jest odrzucany.

Wolumeny a własny dysk sandboxa

Większość pracy nie potrzebuje wolumenu. Własny dysk sandboxa przetrwa jego wstrzymania i zatrzymania: dysk zatrzymanego sandboxa jest trzymany w magazynie obiektów i wraca, gdy sandbox się wznowi, na dowolnym serwerze. Szablon przenosi pliki do każdego nowego sandboxa. Wolumen jest dla danych, które przeżywają używające ich sandboxy albo które wiele z nich czyta naraz: zbioru danych, wag modelu, współdzielonego cache.

Ile kosztuje

Wolumen liczy cały swój rozmiar, 0,20 $ miesięcznie za GiB, co do sekundy, od utworzenia do usunięcia, niezależnie od tego, czy montuje go jakiś sandbox. Twój plan ogranicza, ile zajmują razem wolumeny przestrzeni roboczej: 100 GiB w planie za 20 $, 600 GiB w planie za 100 $, 10 GiB w okresie próbnym. Workspace.volume_gib_used mówi, ile zajmują teraz.

Gdy to nie działa

  • FAILED_PRECONDITION, wolumen jest zamontowany w innym sandboxie: jest zamontowany do zapisu. Zamontuj go do odczytu albo usuń lub zatrzymaj sandbox, który go zapisuje.
  • FAILED_PRECONDITION, jego dziennik może wymagać odtworzenia: ostatni sandbox, który go zapisywał, zakończył się przed odmontowaniem. Zamontuj go raz do zapisu, a potem znów do odczytu.
  • FAILED_PRECONDITION przy DeleteVolume: montuje go jakiś sandbox. Najpierw usuń ten sandbox.
  • RESOURCE_EXHAUSTED z LimitReached, volume_gib: wolumeny przestrzeni roboczej przekroczyłyby GiB planu. Usuń któryś albo zrób mniejszy.
  • UNAVAILABLE z NoCapacity przy utworzeniu albo wznowieniu: serwer wolumenu nie ma teraz miejsca, a sandbox z wolumenem nie może pójść gdzie indziej. Spróbuj później.

Pytania

Czy wolumen jest objęty backupem?

Nie. Leży na dysku jednego serwera i nie jest nigdzie kopiowany: kopię tego, co ważne, trzymaj gdzie indziej.

Czy kilka sandboxów może dzielić wolumen?

Do odczytu dowolna liczba naraz. Do zapisu jeden naraz.

Czy mogę zamontować wolumen w działającym sandboxie?

Nie: montowania podaje się przy tworzeniu, do 4 na sandbox.

Czy wolumen jest rozliczany, gdy nic go nie montuje?

Tak, za cały rozmiar, 0,20 $ miesięcznie za GiB, dopóki go nie usuniesz.

Czy potrzebuję wolumenu, żeby zachować pliki między sesjami?

Nie. Własny dysk sandboxa przetrwa wstrzymania i zatrzymania; wolumen jest dla danych, które przeżywają sandbox.

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