Dokumentacja Agent Sandboxes · Zadania
Wolumeny: dysk, który przeżywa sandboxy
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.
CreateVolumetworzy wolumen od 1 do 1000 GiB;CreateSandboxmontuje 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.
volume = sandboxes.create_volume("data", size_gib=10)
print(volume.volume_id, volume.size_gib) # ziwv1r8ean3dd9sk 10
const volume = await sandboxes.createVolume({ name: "data", sizeGib: 10 });
console.log(volume.volumeId, volume.sizeGib);
volume, err := client.CreateVolume(ctx, &sandboxes.CreateVolumeRequest{Name: "data", SizeGib: 10})
if err != nil {
log.Fatal(err)
}
fmt.Println(volume.VolumeID, volume.SizeGib)
let volume = sandboxes
.create_volume(CreateVolumeRequest { name: "data".into(), size_gib: 10, ..Default::default() })
.await?;
println!("{} {}", volume.volume_id, volume.size_gib);
$ 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.
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")
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" });
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"})
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?;
$ 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'
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.
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)
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 });
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})
}
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?;
$ 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_PRECONDITIONprzyDeleteVolume: montuje go jakiś sandbox. Najpierw usuń ten sandbox.RESOURCE_EXHAUSTEDzLimitReached,volume_gib: wolumeny przestrzeni roboczej przekroczyłyby GiB planu. Usuń któryś albo zrób mniejszy.UNAVAILABLEzNoCapacityprzy 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.