---
title: "Volúmenes: un disco que sobrevive a los sandboxes | Pethost Agent Sandboxes"
description: "Crea un volumen, móntalo en sandboxes en un path, de lectura y escritura en uno o de solo lectura en muchos, y entiende dónde vive y cuánto cuesta."
---

[Documentación de Agent Sandboxes](https://pethost.dev/es/docs/sandboxes/) · Tareas

# Volúmenes: un disco que sobrevive a los sandboxes

Actualizado 22 de noviembre de 2026 · 6 min de lectura

Un volumen es un disco fuera de todos los sandboxes, montado en uno en un path: un dataset que leen muchos sandboxes, una caché que sobrevive a cada trabajo, archivos que un sandbox que eliminas debería dejar atrás. Vive en el disco de un servidor, y eso es lo que tienes que saber antes de poner nada en él.

**En resumen**

- **`CreateVolume`** crea uno de 1 a 1000 GiB; `CreateSandbox` monta hasta 4 al crear, cada uno en un path.
- **De lectura y escritura para un sandbox cada vez,** de solo lectura para cualquier número.
- **En un servidor,** sin copia: un sandbox que lo monta se ejecuta allí, y si ese servidor se pierde, el volumen también.
- **Se factura por su tamaño entero,** 0,20 US$ por GiB al mes, se use o no.

### Step 1: Crea un volumen

Un volumen se crea vacío, en un servidor con espacio, y su raíz pertenece a `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: Móntalo en un sandbox

Los montajes se indican al crear, cada uno un volumen y un path absoluto. El sandbox se ejecuta en el servidor del volumen.

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: Compártelo de solo lectura, y elimínalo al terminar

Cuando ningún sandbox lo monta de lectura y escritura, cualquier número puede montarlo de solo lectura. Un volumen se queda cuando se eliminan los sandboxes que lo montaron, y solo desaparece con `DeleteVolume`, que se rechaza mientras un sandbox lo monte.

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

## Dónde vive un volumen

Un volumen es un archivo en el disco de un servidor de sandboxes, con un sistema de archivos ext4, y un sandbox que lo monta se ejecuta en ese servidor. No se copia a almacenamiento de objetos ni a otro servidor. Eso tiene tres efectos:

- **Si se pierde su servidor, se pierde el volumen:** pasa a DELETED, y los sandboxes que lo montaban lo pierden. No guardes ahí la única copia de nada: sube también lo importante a un almacenamiento propio.
- **Un sandbox con un volumen se queda en su servidor.** Un sandbox detenido sin volúmenes puede iniciarse en otro servidor cuando el suyo está lleno; uno con un volumen espera a que haya espacio en el suyo, y mientras tanto se rechaza con `NoCapacity`.
- **No se puede hacer un fork de un sandbox con un volumen de lectura y escritura:** un volumen lo escribe un sandbox cada vez.

Un volumen comparte la velocidad de disco del sandbox que lo monta, 64 MiB/s por vCPU. Uno mayor que la mitad del disco de un servidor se rechaza.

## Los volúmenes y el disco propio de un sandbox

Casi ningún trabajo necesita un volumen. El disco propio de un sandbox sobrevive a sus pausas y detenciones: el disco de un sandbox detenido se guarda en almacenamiento de objetos, y vuelve cuando se reanuda, en cualquier servidor. Una plantilla lleva archivos a cada sandbox nuevo. Un volumen es para datos que sobreviven a los sandboxes que los usan, o que leen muchos a la vez: un dataset, los pesos de un modelo, una caché compartida.

## Cuánto cuesta

Un volumen cuenta su tamaño entero, 0,20 US$ por GiB al mes, por segundo, desde su creación hasta su eliminación, lo monte un sandbox o no. Tu plan limita lo que ocupan juntos los volúmenes del espacio de trabajo: 100 GiB con el plan de 20 US$, 600 GiB con el de 100 US$, 10 GiB en la prueba gratis. `Workspace.volume_gib_used` dice lo que ocupan ahora.

## Cuando no funciona

- **`FAILED_PRECONDITION`, el volumen lo monta otro sandbox:** está montado de lectura y escritura. Móntalo de solo lectura, o elimina o detén el sandbox que lo escribe.
- **`FAILED_PRECONDITION`, puede que haya que reproducir su journal:** el último sandbox que lo escribió terminó antes de desmontarlo. Móntalo una vez de lectura y escritura, y después otra vez de solo lectura.
- **`FAILED_PRECONDITION` en `DeleteVolume`:** un sandbox lo monta. Elimina antes ese sandbox.
- **`RESOURCE_EXHAUSTED` con `LimitReached`, `volume_gib`:** los volúmenes del espacio de trabajo superarían los GiB del plan. Elimina uno, o hazlo más pequeño.
- **`UNAVAILABLE` con `NoCapacity` al crear o reanudar:** el servidor del volumen no tiene espacio ahora, y un sandbox con un volumen no puede ir a otro sitio. Vuelve a intentarlo más tarde.

## Preguntas

### ¿Un volumen tiene backup?

No. Vive en el disco de un servidor y no se copia a ningún sitio: guarda en otro lugar una copia de lo importante.

### ¿Varios sandboxes pueden compartir un volumen?

De solo lectura, cualquier número a la vez. De lectura y escritura, uno cada vez.

### ¿Puedo montar un volumen en un sandbox en ejecución?

No: los montajes se indican al crear, hasta 4 por sandbox.

### ¿Un volumen se factura mientras nada lo monta?

Sí, por su tamaño entero, 0,20 US$ por GiB al mes, hasta que lo eliminas.

### ¿Necesito un volumen para conservar archivos entre sesiones?

No. El disco propio de un sandbox sobrevive a pausas y detenciones; un volumen es para datos que sobreviven al sandbox.

[AnteriorHaz un fork de un sandbox, memoria y procesos incluidos](https://pethost.dev/es/docs/sandboxes/forks/) [SiguienteSSH a un sandbox: shell, scp, SFTP y túneles](https://pethost.dev/es/docs/sandboxes/ssh/)

## Prueba Pethost Agent Sandboxes

Una prueba gratis de 7 días con 1 US$ de uso y 4 vCPU, con tarjeta. Después, un plan desde 20 US$ al mes, que incluye ese mismo importe en uso.

[Empezar la prueba gratis](https://console.pethost.dev/)

Pethost · Stephan Gomer · NIP 1133096755

Pethost

- [Plantillas](https://pethost.dev/es/templates/)
- [Sobre nosotros](https://pethost.dev/about/)
- [Docs](https://pethost.dev/docs/)
- [Blog](https://pethost.dev/es/blog/)
- [API](https://pethost.dev/docs/api/)
- [CLI](https://pethost.dev/docs/cli/)
- [Plugin](https://github.com/pethost-dev/plugin)
- [Términos](https://pethost.dev/terms/)
- [Privacidad](https://pethost.dev/privacy/)
- [Reembolsos](https://pethost.dev/refunds/)
- [support@pethost.dev](mailto:support@pethost.dev)

Bases de datos

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

Agent Sandboxes

- [Sandboxes](https://pethost.dev/es/sandboxes/)
- [Precios](https://pethost.dev/es/sandboxes/#pricing)
- [Docs](https://pethost.dev/es/docs/sandboxes/)
- [API](https://pethost.dev/docs/sandboxes/api/)

Comparativas

- [Coolify vs Dokploy vs CapRover vs Dokku](https://pethost.dev/es/blog/coolify-vs-dokploy-vs-caprover-vs-dokku/)
- [Coolify Cloud vs Dokploy Cloud](https://pethost.dev/es/blog/coolify-cloud-vs-dokploy-cloud/)
- [Precios de Railway vs Render vs Fly.io](https://pethost.dev/es/blog/railway-vs-render-vs-fly-io-pricing/)
- [Hosting gestionado para Docker Compose](https://pethost.dev/es/blog/managed-docker-compose-hosting/)

Alternativas

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