---
title: "Wolumeny: dysk, który przeżywa sandboxy | Pethost Agent Sandboxes"
description: "Utwórz wolumen, zamontuj go w sandboxach pod ścieżką, do zapisu w jednym albo do odczytu w wielu, i dowiedz się, gdzie leży i ile kosztuje."
---

[Dokumentacja Agent Sandboxes](https://pethost.dev/pl/docs/sandboxes/) · Zadania

# Wolumeny: dysk, który przeżywa sandboxy

Zaktualizowano 22 listopada 2026 · 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.

[PoprzedniaFork sandboxa, razem z pamięcią i procesami](https://pethost.dev/pl/docs/sandboxes/forks/) [NastępnaSSH do sandboxa: powłoka, scp, SFTP i tunele](https://pethost.dev/pl/docs/sandboxes/ssh/)

## 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](https://console.pethost.dev/)

Pethost · Stephan Gomer · NIP 1133096755

Pethost

- [Szablony](https://pethost.dev/pl/templates/)
- [O nas](https://pethost.dev/about/)
- [Dokumentacja](https://pethost.dev/docs/)
- [Blog](https://pethost.dev/pl/blog/)
- [API](https://pethost.dev/docs/api/)
- [CLI](https://pethost.dev/docs/cli/)
- [Plugin](https://github.com/pethost-dev/plugin)
- [Regulamin](https://pethost.dev/terms/)
- [Prywatność](https://pethost.dev/privacy/)
- [Zwroty](https://pethost.dev/refunds/)
- [support@pethost.dev](mailto:support@pethost.dev)

Bazy danych

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

Agent Sandboxes

- [Sandboxy](https://pethost.dev/pl/sandboxes/)
- [Cennik](https://pethost.dev/pl/sandboxes/#pricing)
- [Dokumentacja](https://pethost.dev/pl/docs/sandboxes/)
- [API](https://pethost.dev/docs/sandboxes/api/)

Porównania

- [Coolify vs Dokploy vs CapRover vs Dokku](https://pethost.dev/pl/blog/coolify-vs-dokploy-vs-caprover-vs-dokku/)
- [Coolify Cloud vs Dokploy Cloud](https://pethost.dev/pl/blog/coolify-cloud-vs-dokploy-cloud/)
- [Cennik Railway vs Render vs Fly.io](https://pethost.dev/pl/blog/railway-vs-render-vs-fly-io-pricing/)
- [Zarządzany hosting Docker Compose](https://pethost.dev/pl/blog/managed-docker-compose-hosting/)

Alternatywy

- [Alternatywy dla Railway](https://pethost.dev/pl/blog/railway-alternatives/)
- [Alternatywy dla Heroku](https://pethost.dev/pl/blog/heroku-alternatives/)
- [Alternatywy dla Dokploy](https://pethost.dev/pl/blog/dokploy-alternatives/)
- [Alternatywy dla Coolify](https://pethost.dev/pl/blog/coolify-alternatives/)
- [Alternatywy dla Render](https://pethost.dev/pl/blog/render-alternatives/)
- [Alternatywy dla Sliplane](https://pethost.dev/pl/blog/sliplane-alternatives/)
