---
title: "Plantillas de sandbox propias, desde un sandbox · Pethost"
description: "Guarda el disco de un sandbox de Pethost, con paquetes e imágenes de Docker, como plantilla, e inicia otros desde ella en unos 0,22 s. Gratis dentro del plan."
---

[Agent Sandboxes](https://pethost.dev/es/sandboxes/) Guarda un sandbox como plantilla

# Plantillas: instala una vez e inicia cada sandbox desde ella

Instala lo que necesita tu trabajo una vez, en un sandbox, a mano o con un agente. Guarda el disco del sandbox como plantilla, y cada sandbox nuevo se inicia con todo en su sitio: paquetes, archivos, imágenes de Docker.

Un sandbox con sus paquetes e imágenes de Docker se guarda como la plantilla my-app@3 en 1,2 s, y tres sandboxes nuevos se inician desde ella en dos servidores.

## La nuestra: base

Todo sandbox parte de una plantilla. La nuestra es `base`: Ubuntu 24.04 con build-essential, git, curl, wget, ripgrep y jq; Python 3 con pip y venv; Node.js 22; Claude Code, Codex y OpenCode con sus SDK; Docker con Compose y Buildx; y un escritorio de 1280×800 con Google Chrome. Trabajas como `user`, con sudo y sin contraseña. Su sistema de archivos raíz es de solo lectura y se lee directamente del disco del servidor, así que lo que un sandbox no ejecuta no le cuesta memoria, y ni el escritorio ni Docker se inician hasta que algo los pide.

Cada versión de `base` se nombra por el sha256 de lo que contiene: el sistema operativo, sus paquetes y el kernel del sistema invitado. Construimos una nueva cada mes, y al momento ante un parche de seguridad de Chrome, del kernel o de los paquetes. Los sandboxes nuevos parten de la más reciente; un sandbox, y una plantilla guardada desde él, conservan la base con la que se inició el sandbox.

## Plantillas propias, guardadas desde un sandbox

Una plantilla propia es el disco de un sandbox guardado sobre nuestra base. Prepara el sandbox, a mano o con un agente, y `create_template` guarda su disco como la siguiente versión de un nombre: `my-app@1`, luego `my-app@2`. Solo guarda archivos: ni memoria, ni procesos en ejecución, ni el historial de comandos del sandbox ni las conversaciones de sus agentes, sin los que empiezan los sandboxes nuevos.

La llamada responde en 28 a 49 ms con la versión en SAVING. Un sandbox en ejecución sigue en ejecución, detenido unos milisegundos mientras se toma su disco. Después el servidor comprueba el sistema de archivos y lo reduce a lo que contiene, en una VM auxiliar propia, y sube al almacenamiento de objetos solo los fragmentos que son tuyos, comprimidos y cifrados con una clave solo para esa versión. La versión de un sandbox pequeño está READY entre 0,9 y 1,5 s después de la llamada; en general tarda unos 5 s, más 10 s por cada GiB de datos propios. Una versión READY indica su `min_size`, el tamaño más pequeño cuyo disco cabe lo que guardó.

## Iniciar sandboxes desde ella

Nombra la plantilla al crear un sandbox: `my-app` toma su versión READY más reciente, `my-app@3` exactamente esa. Cualquier servidor inicia sandboxes desde cualquier versión. El panel pregunta primero a los servidores que ya tienen la versión, y allí una creación tarda de 218 a 225 ms. Un servidor que no la tiene la descarga una vez, unos 10 s por cada GiB que contiene la versión, y la conserva para la siguiente. Un sandbox desde una plantilla admite cualquier tamaño a partir del `min_size` de la versión.

Las imágenes de Docker viven en el disco del sandbox, así que una plantilla las lleva consigo: un sandbox creado desde ella ejecuta `docker run` con una imagen que nunca descargó. (Los tiempos de esta página se midieron a través de un panel a 16 ms del servidor).

Python

CLI

```
import time

from pethost.sandboxes import Sandboxes

sandboxes = Sandboxes()  # lee PETHOST_TOKEN
sandbox = sandboxes.create_sandbox()  # desde base
sandboxes.run_command(
    sandbox.sandbox_id,
    command="python3 -m venv ~/venv && ~/venv/bin/pip install pandas && docker pull postgres:18",
)

version = sandboxes.create_template("my-app", sandbox_id=sandbox.sandbox_id)
name = f"my-app@{version.version}"
while sandboxes.get_template(name).state.name == "SAVING":
    time.sleep(1)

copy = sandboxes.create_sandbox(name)  # pandas y la imagen de postgres ya están
print(sandboxes.run_command(copy.sandbox_id, command="docker images postgres").stdout)
```

```
pethost sandbox template save api-dev my-app   # su disco, como la siguiente versión de my-app
pethost sandbox template show my-app           # SAVING, luego READY
pethost sandbox new --template my-app          # un sandbox nuevo desde la versión más reciente
```

## Versiones, espacio y precio

Un nombre guarda hasta 10 versiones. Un espacio de trabajo guarda una versión a la vez, y sus versiones juntas caben en el espacio para plantillas de su plan, contado como lo que ocupan en almacenamiento de objetos, comprimidas:

| Plan | Espacio para plantillas |
| --- | --- |
| 20 US$ al mes | 5 GiB |
| 100 US$ al mes | 30 GiB |
| 500 US$ al mes | 175 GiB |
| 2000 US$ al mes | 800 GiB |

Las plantillas no cuestan nada más allá de ese espacio. Eliminar una plantilla, todas las versiones de su nombre, libera su espacio al momento, y los sandboxes creados desde ella siguen ejecutándose, pausándose, deteniéndose y reanudándose: el almacenamiento de objetos conserva una versión hasta que se elimina el último de ellos.

## Lo que las plantillas aún no hacen

Aún no se construyen desde un Dockerfile: instala en un sandbox y guárdalo, como arriba. Una plantilla lleva archivos, nunca procesos en ejecución. Para copiar un sandbox con su memoria y sus procesos, con un servidor de desarrollo en ejecución o un agente a mitad de una tarea, [haz un fork](https://pethost.dev/es/sandboxes/fork/). Cada sandbox, venga o no de una plantilla, es su propia [microVM Firecracker](https://pethost.dev/es/sandboxes/firecracker-microvm/) con su propio kernel. La [guía de plantillas](https://pethost.dev/es/docs/sandboxes/templates/) tiene cada llamada y cada campo.

## Cómo se compara

El 21 de noviembre de 2026, E2B construía plantillas con su constructor de plantillas, y Daytona creaba snapshots desde una imagen o un Dockerfile, algo que Pethost aún no hace. boat.dev guarda snapshots y cobra 0,056 US$ por snapshot al día pasados los que incluye su plan. Una plantilla de Pethost no cuesta nada dentro del espacio de tu plan.

[Leer la documentación](https://pethost.dev/es/docs/sandboxes/templates/)

## Preguntas

**¿Puedo construir una plantilla de sandbox desde un Dockerfile?**

Aún no. Inicia un sandbox desde `base`, ejecuta en él los pasos de tu Dockerfile como comandos y guárdalo. También puedes ejecutar `docker build` dentro de un sandbox: la imagen que construye queda en el disco del sandbox, y la plantilla la lleva consigo.

**¿Cuánto cuesta una plantilla?**

Nada. Sus versiones cuentan para el espacio para plantillas de tu plan, 5 GiB en el plan de 20 US$, medido como se guardan, comprimidas.

**¿Una plantilla conserva los procesos en ejecución?**

No, conserva archivos. Un fork copia un sandbox con su memoria y sus procesos en ejecución.

**¿Qué tan rápido se inicia un sandbox desde una plantilla?**

En 218 a 225 ms en un servidor que tiene la versión. El primer inicio en un servidor que no la tiene la descarga antes, unos 10 s por cada GiB que contiene.

## Relacionado

- [Un sandbox en ejecución en el paso 41 de una tarea se copia en tres en 0,25 s; cada copia sigue por su cuenta desde el paso 41. Fork con memoria y todo Copia un sandbox en ejecución, con su memoria, sus procesos y su disco, en sandboxes nuevos en una llamada. Tres copias tardan alrededor de un cuarto de segundo. Cómo funciona](https://pethost.dev/es/sandboxes/fork/)
- [Tres sandboxes en un servidor, cada uno una microVM con su propio kernel y su propio shell de root; un cuarto se inicia en 0,12 s. Una microVM por sandbox Cada sandbox es una microVM Firecracker con su propio kernel Linux, root dentro y su propia red, iniciada desde un snapshot en unos 0,15 s. Cómo funciona](https://pethost.dev/es/sandboxes/firecracker-microvm/)

## Dale a tu agente una VM en 0,15 s

[Empezar la prueba gratis](https://console.pethost.dev/welcome?kind=sandboxes)

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/)
