---
title: "Templates próprios a partir de um sandbox rodando · Pethost"
description: "Salve o disco de um sandbox do Pethost, com pacotes e imagens Docker, como template, e inicie novos sandboxes a partir dele em cerca de 0,22 s. Grátis no plano."
---

[Agent Sandboxes](https://pethost.dev/pt/sandboxes/) Salve um sandbox como template

# Templates: instale uma vez, inicie todo sandbox a partir dele

Instale uma vez o que o seu trabalho precisa, em um sandbox, manualmente ou com um agente. Salve o disco do sandbox como template, e todo sandbox novo já inicia com tudo no lugar: pacotes, arquivos, imagens Docker.

Um sandbox com os pacotes e as imagens Docker dele é salvo como o template my-app@3 em 1,2 s, e três sandboxes novos iniciam a partir dele em dois servidores.

## O nosso: base

Todo sandbox inicia a partir de um template. O nosso é o `base`: Ubuntu 24.04 com build-essential, git, curl, wget, ripgrep e jq; Python 3 com pip e venv; Node.js 22; Claude Code, Codex e OpenCode com os SDKs deles; Docker com Compose e Buildx; e um desktop de 1280×800 com Google Chrome. Você trabalha como `user`, com sudo e sem senha. O sistema de arquivos raiz é somente leitura e lido direto do disco do servidor, então o que um sandbox não roda não lhe custa memória, e nem o desktop nem o Docker iniciam até algo pedir por eles.

Cada versão do `base` é nomeada pelo sha256 do que ela contém: o sistema operacional, os pacotes e o kernel do guest. Criamos uma nova todo mês, e na hora para uma correção de segurança do Chrome, do kernel ou dos pacotes. Sandboxes novos iniciam na mais recente; um sandbox, e um template salvo a partir dele, mantêm a base em que o sandbox iniciou.

## Templates próprios, salvos de um sandbox

Um template próprio é o disco de um sandbox salvo sobre a nossa base. Configure o sandbox, manualmente ou com um agente, e `create_template` salva o disco dele como a próxima versão de um nome: `my-app@1`, depois `my-app@2`. Ele salva só arquivos: nada de memória, nada de processos rodando, nem o histórico de comandos ou as conversas de agentes do sandbox, sem os quais os novos sandboxes iniciam.

A chamada responde em 28 a 49 ms com a versão em SAVING. Um sandbox rodando continua rodando, suspenso por alguns milissegundos enquanto o disco é capturado. Depois o servidor confere o sistema de arquivos e o reduz ao que ele contém, em uma VM auxiliar própria, e envia ao armazenamento de objetos só os blocos que são seus, comprimidos e criptografados com uma chave só daquela versão. A versão de um sandbox pequeno fica READY de 0,9 a 1,5 s depois da chamada; em geral leva cerca de 5 s, mais 10 s para cada GiB de dados seus. Uma versão READY indica o seu `min_size`, o menor tamanho cujo disco comporta o que ela salvou.

## Iniciar sandboxes a partir dele

Indique o template ao criar um sandbox: `my-app` pega a versão READY mais recente, `my-app@3` exatamente essa. Qualquer servidor inicia sandboxes a partir de qualquer versão. O painel pede primeiro aos servidores que já têm a versão, e lá uma criação leva de 218 a 225 ms. Um servidor que não a tem a busca uma vez, cerca de 10 s para cada GiB que a versão contém, e a guarda para a próxima. Um sandbox a partir de um template aceita qualquer tamanho a partir do `min_size` da versão.

As imagens do Docker ficam no disco do sandbox, então um template as leva junto: um sandbox criado a partir dele roda `docker run` com uma imagem que nunca baixou. (Os tempos aqui foram medidos por um painel a 16 ms do servidor.)

Python

CLI

```
import time

from pethost.sandboxes import Sandboxes

sandboxes = Sandboxes()  # lê o PETHOST_TOKEN
sandbox = sandboxes.create_sandbox()  # a partir do 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)  # o pandas e a imagem do postgres estão lá
print(sandboxes.run_command(copy.sandbox_id, command="docker images postgres").stdout)
```

```
pethost sandbox template save api-dev my-app   # o disco dele, como a próxima versão de my-app
pethost sandbox template show my-app           # SAVING, depois READY
pethost sandbox new --template my-app          # um sandbox novo a partir da versão mais recente
```

## Versões, espaço e preço

Um nome guarda até 10 versões. Um espaço de trabalho salva uma versão por vez, e as versões dele juntas cabem no espaço de templates do plano, contado pelo que ocupam no armazenamento de objetos, comprimidas:

| Plano | Espaço de templates |
| --- | --- |
| US$ 20 por mês | 5 GiB |
| US$ 100 por mês | 30 GiB |
| US$ 500 por mês | 175 GiB |
| US$ 2.000 por mês | 800 GiB |

Templates não custam nada além desse espaço. Excluir um template, todas as versões do nome dele, libera o espaço na hora, e os sandboxes criados a partir dele continuam rodando, pausando, parando e retomando: o armazenamento de objetos guarda uma versão até o último deles ser excluído.

## O que os templates ainda não fazem

Ainda não há build a partir de um Dockerfile: instale em um sandbox e salve-o, como acima. Um template leva arquivos, nunca processos rodando. Para copiar um sandbox com memória e processos, um dev server rodando ou um agente no meio de uma tarefa, [faça um fork dele](https://pethost.dev/pt/sandboxes/fork/). Cada sandbox, a partir de um template ou não, é a própria [microVM Firecracker](https://pethost.dev/pt/sandboxes/firecracker-microvm/), com o próprio kernel. O [guia de templates](https://pethost.dev/pt/docs/sandboxes/templates/) tem todas as chamadas e campos.

## Como se compara

Em 21 de novembro de 2026, o E2B criava templates com o construtor de templates dele, e o Daytona criava snapshots a partir de uma imagem ou de um Dockerfile, o que o Pethost ainda não faz. O boat.dev salva snapshots e cobra US$ 0,056 por snapshot por dia além dos que o plano inclui. Um template do Pethost não custa nada dentro do espaço de templates do seu plano.

[Ler a documentação](https://pethost.dev/pt/docs/sandboxes/templates/)

## Perguntas

**Dá para criar um template de sandbox a partir de um Dockerfile?**

Ainda não. Inicie um sandbox a partir do `base`, rode nele os passos do seu Dockerfile como comandos e salve-o. Você também pode rodar `docker build` dentro de um sandbox: a imagem que ele cria fica no disco do sandbox, e o template a leva junto.

**Quanto custa um template?**

Nada. As versões dele contam no espaço de templates do seu plano, 5 GiB no plano de US$ 20, medidas como estão guardadas, comprimidas.

**Um template guarda processos rodando?**

Não, ele guarda arquivos. Um fork copia um sandbox com a memória e os processos rodando.

**Com que rapidez um sandbox inicia a partir de um template?**

Em 218 a 225 ms em um servidor que tem a versão. O primeiro início em um servidor que não a tem a busca antes, cerca de 10 s para cada GiB que ela contém.

## Relacionados

- [Um sandbox rodando no passo 41 de uma tarefa vira três cópias por fork em 0,25 s; cada uma segue sozinha a partir do passo 41. Fork com memória e tudo Copie um sandbox rodando, com memória, processos e disco, para novos sandboxes em uma chamada. Três cópias levam cerca de um quarto de segundo. Como funciona](https://pethost.dev/pt/sandboxes/fork/)
- [Três sandboxes em um servidor, cada um uma microVM com kernel próprio e shell root próprio; um quarto inicia em 0,12 s. Uma microVM por sandbox Cada sandbox é uma microVM Firecracker com kernel Linux próprio, root lá dentro e rede própria, iniciada a partir de um snapshot em cerca de 0,15 s. Como funciona](https://pethost.dev/pt/sandboxes/firecracker-microvm/)

## Dê um computador ao seu agente em 0,15 s

[Começar o teste grátis](https://console.pethost.dev/welcome?kind=sandboxes)

Pethost · Stephan Gomer · NIP 1133096755

Pethost

- [Templates](https://pethost.dev/pt/templates/)
- [Sobre nós](https://pethost.dev/about/)
- [Docs](https://pethost.dev/docs/)
- [Blog](https://pethost.dev/pt/blog/)
- [API](https://pethost.dev/docs/api/)
- [CLI](https://pethost.dev/docs/cli/)
- [Plugin](https://github.com/pethost-dev/plugin)
- [Termos](https://pethost.dev/terms/)
- [Privacidade](https://pethost.dev/privacy/)
- [Reembolsos](https://pethost.dev/refunds/)
- [support@pethost.dev](mailto:support@pethost.dev)

Bancos de dados

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

Agent Sandboxes

- [Sandboxes](https://pethost.dev/pt/sandboxes/)
- [Preços](https://pethost.dev/pt/sandboxes/#pricing)
- [Docs](https://pethost.dev/pt/docs/sandboxes/)
- [API](https://pethost.dev/docs/sandboxes/api/)

Comparativos

- [Coolify vs Dokploy vs CapRover vs Dokku](https://pethost.dev/pt/blog/coolify-vs-dokploy-vs-caprover-vs-dokku/)
- [Coolify Cloud vs Dokploy Cloud](https://pethost.dev/pt/blog/coolify-cloud-vs-dokploy-cloud/)
- [Preços Railway vs Render vs Fly.io](https://pethost.dev/pt/blog/railway-vs-render-vs-fly-io-pricing/)
- [Hospedagem gerenciada de Docker Compose](https://pethost.dev/pt/blog/managed-docker-compose-hosting/)

Alternativas

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