---
title: "Templates créés à partir d’une sandbox · Pethost"
description: "Enregistrez le disque d’une sandbox, paquets et images Docker compris, comme template, et démarrez-en de nouvelles en 0,22 s environ. Gratuit dans votre offre."
---

[Agent Sandboxes](https://pethost.dev/fr/sandboxes/) Enregistrer une sandbox comme template

# Templates : installez une fois, démarrez chaque sandbox à partir de là

Installez une fois ce dont votre travail a besoin, dans une sandbox, à la main ou par un agent. Enregistrez le disque de la sandbox comme template, et chaque nouvelle sandbox démarre avec tout en place : paquets, fichiers, images Docker.

Une sandbox avec ses paquets et ses images Docker est enregistrée comme template my-app@3 en 1,2 s, et trois nouvelles sandboxes en démarrent sur deux serveurs.

## Le nôtre : base

Chaque sandbox part d’un template. Le nôtre est `base` : Ubuntu 24.04 avec build-essential, git, curl, wget, ripgrep et jq ; Python 3 avec pip et venv ; Node.js 22 ; Claude Code, Codex et OpenCode avec leurs SDK ; Docker avec Compose et Buildx ; et un bureau 1280×800 avec Google Chrome. Vous travaillez en tant que `user`, avec sudo sans mot de passe. Son système de fichiers racine est en lecture seule et lu directement depuis le disque du serveur : ce qu’une sandbox ne lance pas ne lui coûte aucune mémoire, et ni le bureau ni Docker ne démarrent tant que rien ne les demande.

Chaque version de `base` est nommée par le sha256 de ce qu’elle contient : le système d’exploitation, ses paquets et le noyau invité. Nous en construisons une nouvelle chaque mois, et aussitôt pour un correctif de sécurité de Chrome, du noyau ou des paquets. Les nouvelles sandboxes démarrent sur la plus récente ; une sandbox, et un template enregistré à partir d’elle, gardent la base sur laquelle la sandbox a démarré.

## Des templates personnalisés, enregistrés depuis une sandbox

Un template personnalisé, c’est le disque d’une sandbox enregistré par-dessus notre base. Préparez la sandbox, à la main ou par un agent, puis `create_template` enregistre son disque comme version suivante d’un nom : `my-app@1`, puis `my-app@2`. Il n’enregistre que des fichiers : pas de mémoire, pas de processus en cours, ni l’historique des commandes ou les conversations d’agents de la sandbox, que les nouvelles sandboxes n’ont pas au départ.

L’appel répond en 28 à 49 ms avec la version en SAVING. Une sandbox active continue de tourner, arrêtée quelques millisecondes le temps de prendre son disque. Ensuite, le serveur vérifie le système de fichiers et le réduit à ce qu’il contient, dans une VM auxiliaire à part, puis n’envoie au stockage objet que les blocs qui sont à vous, compressés et chiffrés avec une clé propre à cette version. La version d’une petite sandbox est READY 0,9 à 1,5 s après l’appel ; en général, cela prend environ 5 s, plus 10 s par GiB de vos propres données. Une version READY indique sa `min_size`, la plus petite taille dont le disque contient ce qu’elle a enregistré.

## Démarrer des sandboxes à partir de lui

Nommez le template en créant une sandbox : `my-app` prend sa version READY la plus récente, `my-app@3` exactement celle-là. N’importe quel serveur démarre des sandboxes à partir de n’importe quelle version. La console s’adresse d’abord aux serveurs qui ont déjà la version, et là une création prend 218 à 225 ms. Un serveur qui ne l’a pas la récupère une fois, environ 10 s par GiB que contient la version, et la garde pour la suite. Une sandbox issue d’un template prend n’importe quelle taille à partir de la `min_size` de la version.

Les images Docker vivent sur le disque de la sandbox, donc un template les emporte : une sandbox créée à partir de lui lance `docker run` sur une image qu’elle n’a jamais téléchargée. (Les temps ci-dessus ont été mesurés via une console à 16 ms du serveur.)

Python

CLI

```
import time

from pethost.sandboxes import Sandboxes

sandboxes = Sandboxes()  # lit PETHOST_TOKEN
sandbox = sandboxes.create_sandbox()  # depuis 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 et l'image postgres sont là
print(sandboxes.run_command(copy.sandbox_id, command="docker images postgres").stdout)
```

```
pethost sandbox template save api-dev my-app   # son disque, comme version suivante de my-app
pethost sandbox template show my-app           # SAVING, puis READY
pethost sandbox new --template my-app          # une nouvelle sandbox depuis la version la plus récente
```

## Versions, place et prix

Un nom contient jusqu’à 10 versions. Un espace de travail enregistre une version à la fois, et ses versions tiennent ensemble dans la place que son offre donne aux templates, comptée selon ce qu’elles occupent dans le stockage objet, compressées :

| Offre | Place pour les templates |
| --- | --- |
| 20 $ par mois | 5 GiB |
| 100 $ par mois | 30 GiB |
| 500 $ par mois | 175 GiB |
| 2 000 $ par mois | 800 GiB |

Les templates ne coûtent rien au-delà de cette place. Supprimer un template, toutes les versions de son nom, libère sa place aussitôt, et les sandboxes créées à partir de lui continuent de tourner, de se mettre en pause, de s’arrêter et de reprendre : le stockage objet garde une version jusqu’à ce que la dernière d’entre elles soit supprimée.

## Ce que les templates ne font pas encore

Il n’y a pas encore de build depuis un Dockerfile : installez dans une sandbox et enregistrez-la, comme ci-dessus. Un template emporte des fichiers, jamais des processus en cours. Pour copier une sandbox avec sa mémoire et ses processus, un serveur de développement qui tourne ou un agent à mi-chemin d’une tâche, [dupliquez-la](https://pethost.dev/fr/sandboxes/fork/). Chaque sandbox, issue d’un template ou non, est sa propre [microVM Firecracker](https://pethost.dev/fr/sandboxes/firecracker-microvm/) avec son propre noyau. Le [guide des templates](https://pethost.dev/fr/docs/sandboxes/templates/) détaille chaque appel et chaque champ.

## Face aux autres

Le 21 novembre 2026, E2B construisait les templates avec son outil dédié, et Daytona créait des snapshots à partir d’une image ou d’un Dockerfile, ce que Pethost ne fait pas encore. boat.dev enregistre des snapshots et facture 0,056 $ par snapshot et par jour au-delà de ceux que son offre inclut. Un template Pethost ne coûte rien dans la place que donne votre offre.

[Lire la documentation](https://pethost.dev/fr/docs/sandboxes/templates/)

## Questions

**Puis-je construire un template de sandbox à partir d’un Dockerfile ?**

Pas encore. Démarrez une sandbox depuis `base`, exécutez-y les étapes de votre Dockerfile comme des commandes, et enregistrez-la. Vous pouvez aussi lancer `docker build` dans une sandbox : l’image construite est sur le disque de la sandbox, et le template l’emporte.

**Que coûte un template ?**

Rien. Ses versions comptent dans la place que votre offre donne aux templates, 5 GiB avec l’offre à 20 $, mesurées telles qu’elles sont stockées, compressées.

**Un template garde-t-il les processus en cours ?**

Non, il garde des fichiers. Une duplication copie une sandbox avec sa mémoire et ses processus en cours.

**À quelle vitesse une sandbox démarre-t-elle depuis un template ?**

En 218 à 225 ms sur un serveur qui a la version. Le premier démarrage sur un serveur qui ne l’a pas la récupère d’abord, environ 10 s par GiB qu’elle contient.

## Voir aussi

- [Une sandbox active, à l’étape 41 d’une tâche, est dupliquée en trois copies en 0,25 s ; chacune poursuit seule depuis l’étape 41. Duplication, mémoire comprise Copiez une sandbox active, sa mémoire, ses processus et son disque, dans de nouvelles sandboxes en un appel. Trois copies prennent environ un quart de seconde. Comment ça marche](https://pethost.dev/fr/sandboxes/fork/)
- [Trois sandboxes sur un serveur, chacune une microVM avec son propre noyau et son propre shell root ; une quatrième démarre en 0,12 s. Une microVM par sandbox Chaque sandbox est une microVM Firecracker avec son propre noyau Linux, root à l’intérieur et son propre réseau, démarrée depuis un snapshot en 0,15 s environ. Comment ça marche](https://pethost.dev/fr/sandboxes/firecracker-microvm/)

## Donnez un ordinateur à votre agent en 0,15 s

[Démarrer l’essai gratuit](https://console.pethost.dev/welcome?kind=sandboxes)

Pethost · Stephan Gomer · NIP 1133096755

Pethost

- [Templates](https://pethost.dev/fr/templates/)
- [À propos](https://pethost.dev/about/)
- [Docs](https://pethost.dev/docs/)
- [Blog](https://pethost.dev/fr/blog/)
- [API](https://pethost.dev/docs/api/)
- [CLI](https://pethost.dev/docs/cli/)
- [Plugin](https://github.com/pethost-dev/plugin)
- [Conditions](https://pethost.dev/terms/)
- [Confidentialité](https://pethost.dev/privacy/)
- [Remboursements](https://pethost.dev/refunds/)
- [support@pethost.dev](mailto:support@pethost.dev)

Bases de données

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

Agent Sandboxes

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

Comparatifs

- [Coolify vs Dokploy vs CapRover vs Dokku](https://pethost.dev/fr/blog/coolify-vs-dokploy-vs-caprover-vs-dokku/)
- [Coolify Cloud vs Dokploy Cloud](https://pethost.dev/fr/blog/coolify-cloud-vs-dokploy-cloud/)
- [Tarifs Railway vs Render vs Fly.io](https://pethost.dev/fr/blog/railway-vs-render-vs-fly-io-pricing/)
- [Hébergement Docker Compose managé](https://pethost.dev/fr/blog/managed-docker-compose-hosting/)

Alternatives

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