Instantanés du système de fichiers

Le client TypeScript prend en charge les montages d’instantanés, les restaurations, les instantanés en cours d’exécution et la gestion des instantanés, mais pas la création d’instantanés à l’arrêt.

Les instantanés du système de fichiers (FSS) permettent à un sandbox d’écrire dans un répertoire de travail local, de capturer ce répertoire dans le stockage d’objets sous forme d’instantané immuable, puis de le restaurer ultérieurement dans de nouveaux sandboxes. Utilisez les FSS pour suspendre et reprendre le système de fichiers d’un sandbox d’un run à l’autre, ou pour créer une branche à partir d’un instantané dans plusieurs sandboxes qui évoluent ensuite indépendamment les uns des autres.

Choisir l’authentification

Ces exemples s’exécutent sur une capacité sans serveur, sauf si une section indique CoreWeave Kubernetes Service (CKS). Choisissez l’identifiant d’authentification du compte propriétaire de vos Sandbox. Consultez Choisir et obtenir des identifiants pour obtenir une clé ou un jeton. Enregistrez la configuration correspondant à votre langage dans le même répertoire que les scripts que vous exécutez depuis cette page. Les exemples Python importent AUTH depuis sandbox_auth.py. Les exemples TypeScript importent client depuis sandbox-client.mts. Ces fichiers sélectionnent l’authentification sans stocker votre identifiant d’authentification. Pour Python, utilisez un environnement virtuel actif. Pour TypeScript, installez d’abord le client avec npm install @coreweave/cwsandbox@1.0.0.

Clé API Forge
Jeton d’accès à l’API CoreWeave

Utilisez votre clé API Forge avec l’intégration wandb du SDK. Remplacez [WANDB-API-KEY] par votre clé API :

export WANDB_API_KEY="[WANDB-API-KEY]"
sandbox_headers=(-H "x-wandb-api-key: $WANDB_API_KEY")

Python
TypeScript

uv pip install 'cwsandbox[wandb]>=1.14.2'

sandbox_auth.py

from cwsandbox import AuthStrategy

AUTH = AuthStrategy.WANDB

sandbox-client.mts

import { createSandboxClientFromEnv } from "@coreweave/cwsandbox/wandb";

export const client = createSandboxClientFromEnv();

Utilisez le jeton de votre organisation CoreWeave. Remplacez [API-ACCESS-TOKEN] par votre jeton :

export CWSANDBOX_API_KEY="[API-ACCESS-TOKEN]"
sandbox_headers=(-H "Authorization: Bearer $CWSANDBOX_API_KEY")

Python
TypeScript

uv pip install 'cwsandbox>=1.14.2'

sandbox_auth.py

from cwsandbox import AuthStrategy

AUTH = AuthStrategy.COREWEAVE_API_KEY

sandbox-client.mts

import { createSandboxClientFromEnv } from "@coreweave/cwsandbox/node";

export const client = createSandboxClientFromEnv();

Pour un placement sur CKS, choisissez le jeton CoreWeave, activez un exécuteur et définissez placement_mode="cks" lors de la création du Sandbox ou dans SandboxDefaults. En TypeScript, choisissez le jeton CoreWeave et définissez un tableau runnerIds non vide pour sélectionner CKS. La création d’une session Python avec auth=AUTH authentifie également les Sandbox qui lui appartiennent. Conservez le même identifiant d’authentification pour vous reconnecter à vos Sandbox, les lister ou les nettoyer. Pour les exemples d’API HTTP, exécutez les commandes Bash de l’onglet correspondant à votre identifiant d’authentification dans le même shell que les requêtes. Le tableau sandbox_headers fournit l’en-tête d’authentification sélectionné. Les exemples de création via HTTP utilisent un placement sans serveur.

Fonctionnement

Une Sandbox avec FSS monte un système de fichiers temporaire accessible en écriture à l’emplacement de votre choix. L’exécuteur s’appuie sur un EmptyDir pour ce montage, et non sur un montage direct du stockage d’objets. Les opérations d’instantané et de restauration copient une archive tar entre ce système de fichiers local et un bucket de stockage d’objets limité à l’organisation. Chaque instantané est une ressource FileSystemSnapshot identifiée par un fileSystemSnapshotId attribué par le serveur. Les instantanés se caractérisent par trois propriétés :

Immuable : la création d’un instantané écrit une seule archive. La restauration d’un instantané ne modifie jamais l’instantané source ; une restauration ultérieure retrouve donc toujours les octets d’origine.
Limité à l’organisation : vous ne pouvez restaurer que les instantanés créés dans votre propre organisation. Un membre de votre équipe disposant d’un accès aux Sandbox dans la même organisation peut restaurer votre instantané avec ses propres identifiants d’authentification. Un ID d’instantané provenant d’une autre organisation est considéré comme introuvable.
Cycle de vie indépendant : les instantanés sont gérés séparément des Sandbox. La suppression d’une Sandbox ne supprime pas ses instantanés, et la suppression d’un instantané n’a aucune incidence sur les Sandbox déjà lancées à partir de celui-ci.

Par défaut, CoreWeave provisionne et gère le bucket de stockage d’objets qui contient vos instantanés. Pour stocker plutôt vos instantanés dans un bucket que vous possédez et contrôlez, consultez Utilisez votre propre bucket, qui détaille les prérequis relatifs au compte CoreWeave et au bucket.

Démarrer un sandbox avec un montage d’instantané

Un sandbox peut démarrer à partir de l’une de ces deux sources de système de fichiers : un système de fichiers temporaire, neuf et vide, ou la restauration d’un instantané existant.

Système de fichiers temporaire vierge

Un système de fichiers temporaire vierge est vide au démarrage et peut faire l’objet d’un instantané par la suite. Utilisez-le pour les flux de travail qui nécessitent un état local accessible en écriture pendant l’exécution.

Python
TypeScript
API HTTP

from sandbox_auth import AUTH
from cwsandbox import Sandbox, FileSystemSnapshotOptions

with Sandbox.run(
    container_image="ubuntu:22.04",
    file_system_snapshot=FileSystemSnapshotOptions(mount_path="/work", size="10Gi"),
    resources={"cpu": "1", "memory": "1Gi"},
    auth=AUTH,
) as sandbox:
    sandbox.exec(["sh", "-c", "echo hello > /work/data.txt"]).result()

import { client } from "./sandbox-client.mts";

await client.withSandbox(
  (sandbox) => sandbox.commands.run(["sh", "-c", "echo hello > /work/data.txt"], { check: true }),
  {
    containerImage: "ubuntu:22.04",
    fileSystemSnapshot: { mountPath: "/work", size: "10Gi" },
  },
);

Définissez fileSystem.mountPath et fileSystem.size. Ne définissez pas fileSystemSnapshot pour démarrer avec un système de fichiers vide.

curl -X POST https://api.cwsandbox.com/v1beta2/sandboxes \
  "${sandbox_headers[@]}" \
  -H "Content-Type: application/json" \
  -d '{
    "containerImage": "ubuntu:22.04",
    "command": "sleep",
    "args": ["3600"],
    "fileSystem": {
      "mountPath": "/work",
      "size": "10Gi"
    }
  }'

Restaurer à partir d’un instantané

Une restauration initialise le système de fichiers à partir d’un instantané existant. Indiquez l’ID de l’instantané dans la source d’instantané du point de montage.

Python
TypeScript
API HTTP

from sandbox_auth import AUTH
from cwsandbox import Sandbox, FileSystemSnapshotOptions

with Sandbox.run(
    container_image="ubuntu:22.04",
    file_system_snapshot=FileSystemSnapshotOptions(
        mount_path="/work",
        file_system_snapshot_id="fss_...",
    ),
    resources={"cpu": "1", "memory": "1Gi"},
    auth=AUTH,
) as sandbox:
    contents = sandbox.exec(["cat", "/work/data.txt"]).result()
    print(contents.stdout)

Indiquez l’ID de l’instantané dans restoreFromSnapshotId :

import { client } from "./sandbox-client.mts";

const contents = await client.withSandbox(
  (sandbox) => sandbox.commands.run(["cat", "/work/data.txt"]),
  {
    containerImage: "ubuntu:22.04",
    fileSystemSnapshot: { mountPath: "/work", restoreFromSnapshotId: "fss_..." },
  },
);
console.log(contents.stdout);

curl -X POST https://api.cwsandbox.com/v1beta2/sandboxes \
  "${sandbox_headers[@]}" \
  -H "Content-Type: application/json" \
  -d '{
    "containerImage": "ubuntu:22.04",
    "command": "sleep",
    "args": ["3600"],
    "fileSystem": {
      "mountPath": "/work",
      "size": "10Gi",
      "fileSystemSnapshot": {
        "fileSystemSnapshotId": "fss_..."
      }
    }
  }'

Un instantané doit être à l’état READY pour pouvoir être restauré. La restauration d’un instantané encore à l’état CREATING échoue. Consultez Statut et échecs des instantanés.

Prévoir le temps de restauration

Lors de la restauration d’un instantané, son archive est copiée puis extraite avant que la sandbox puisse exécuter votre application. La restauration d’instantanés de modèles volumineux peut prendre plusieurs minutes. Le temps de démarrage dépend des facteurs suivants :

Taille de l’archive
Nombre de fichiers
CPU disponible
Stockage local
Débit réseau
Opérations de démarrage de l’image

La capacité de montage demandée ne suffit pas, à elle seule, à prédire le temps de restauration. Pour choisir un délai de démarrage, mesurez des lancements à froid avec votre image, votre instantané et vos demandes de ressources. Le statut CREATING ne permet pas, à lui seul, de distinguer l’attente de l’ordonnancement de la restauration des fichiers. Avant de supprimer un lancement lent, vérifiez le champ status_reason de la sandbox et conservez son ID pour l’assistance. Un délai fixe permet de borner votre attente, mais le temps écoulé ne suffit pas à établir qu’une restauration a échoué.

Prendre un instantané

Vous pouvez capturer un instantané de deux façons : à l’arrêt, lorsqu’une sandbox s’éteint, ou en cours d’exécution, depuis une sandbox active.

Instantané à l’arrêt

Pour conserver le système de fichiers d’une sandbox lors de son arrêt, arrêtez-la en activant l’instantané à l’arrêt. C’est la méthode à suivre pour suspendre puis reprendre une sandbox : arrêtez-la avec un instantané, puis démarrez ultérieurement une nouvelle sandbox qui le restaure.

Python
TypeScript
API HTTP

sandbox.stop(snapshot_on_stop=True).result()
print(sandbox.file_system_snapshot_id)

Le client TypeScript ne prend pas en charge l’instantané à l’arrêt : stop() ne propose aucune option d’instantané. Créez plutôt un instantané en cours d’exécution avant d’arrêter la sandbox. Cette capture n’est pas atomique. Si vous avez besoin d’un état cohérent, suspendez les écritures de l’application pendant la capture ou utilisez un point de contrôle applicatif. Les écritures effectuées après le retour de snapshot() ne sont pas capturées.

const { snapshotId } = await sandbox.snapshot();
await sandbox.stop();
console.log(snapshotId);

StopSandbox renvoie un fileSystemSnapshotId lorsque la requête d’instantané est acceptée. Si waitForReady est défini sur true, l’appel attend que l’instantané atteigne l’état READY ou FAILED, dans la limite de maxTimeoutSeconds. Sinon, l’appel peut se terminer alors que l’instantané est encore à l’état CREATING. Remplacez [SANDBOX-ID] par l’ID de la sandbox à arrêter.

curl -X POST https://api.cwsandbox.com/v1beta2/sandboxes/[SANDBOX-ID]/stop \
  "${sandbox_headers[@]}" \
  -H "Content-Type: application/json" \
  -d '{
    "sandboxId": "[SANDBOX-ID]",
    "fileSystemSnapshotOnStop": true,
    "waitForReady": true,
    "idempotencyKey": "stop-[SANDBOX-ID]-snapshot-1",
    "maxTimeoutSeconds": 600
  }'

Instantané en cours d’exécution

Un instantané en cours d’exécution capture une sandbox active sans l’arrêter. La sandbox continue de s’exécuter pendant et après la capture. La capture parcourt le système de fichiers actif et n’est pas atomique : les écritures effectuées pendant la capture risquent donc de ne pas être capturées de manière cohérente. Si vous avez besoin d’un état cohérent, suspendez les écritures de l’application pendant la capture ou créez un point de contrôle applicatif au préalable.

Python
TypeScript
API HTTP

Par défaut, snapshot() attend que l’instantané soit READY, puis renvoie son ID.

snapshot_id = sandbox.snapshot().result()
print(f"Created snapshot {snapshot_id}")

snapshot() attend que le state de l’instantané soit "ready", puis renvoie l’enregistrement complet de l’instantané, et pas seulement son ID.

const snapshot = await sandbox.snapshot();
console.log(`Created snapshot ${snapshot.snapshotId}`);

CreateFileSystemSnapshot accepte les mêmes paramètres de contrôle idempotencyKey, waitForReady et maxTimeoutSeconds que l’instantané à l’arrêt. Contrairement à StopSandbox, waitForReady a pour valeur par défaut true. Remplacez [SANDBOX-ID] par l’ID de la sandbox active dont vous souhaitez créer un instantané.

curl -X POST https://api.cwsandbox.com/v1beta2/sandboxes/[SANDBOX-ID]/file-system-snapshots \
  "${sandbox_headers[@]}" \
  -H "Content-Type: application/json" \
  -d '{
    "sandboxId": "[SANDBOX-ID]",
    "waitForReady": true,
    "maxTimeoutSeconds": 600
  }'

Lorsque waitForReady est défini sur false, une réponse réussie signifie simplement que la ligne de l’instantané a été créée et que la commande d’instantané a été envoyée. L’archive peut encore être à l’état CREATING et passer ultérieurement à l’état FAILED. Interrogez l’état de l’instantané avant de le restaurer.

Créer une branche à partir d’un instantané

Un même instantané peut être restauré dans plusieurs sandbox. Comme chaque instantané est immuable, les sandbox restaurées démarrent à partir d’octets identiques, puis divergent au fil de leurs écritures.

Créez un instantané READY, soit avec un instantané à l’arrêt, soit avec un instantané en cours d’exécution.
Démarrez la sandbox A en définissant fileSystemSnapshotId sur cet instantané.
Démarrez la sandbox B avec le même fileSystemSnapshotId.
Les écritures effectuées dans la sandbox A et dans la sandbox B divergent indépendamment les unes des autres. L’instantané source n’est pas modifié : une restauration ultérieure à partir du même ID retrouve donc l’instantané original, et non les écritures de l’une ou l’autre branche.

Python
TypeScript

from sandbox_auth import AUTH
from cwsandbox import Sandbox, FileSystemSnapshotOptions

# Restaurer le même instantané dans deux bacs à sable indépendants.
with Sandbox.run(
    file_system_snapshot=FileSystemSnapshotOptions(mount_path="/work", file_system_snapshot_id=snapshot_id),
    resources={"cpu": "1", "memory": "1Gi"},
    auth=AUTH,
) as fork_a, Sandbox.run(
    file_system_snapshot=FileSystemSnapshotOptions(mount_path="/work", file_system_snapshot_id=snapshot_id),
    resources={"cpu": "1", "memory": "1Gi"},
    auth=AUTH,
) as fork_b:
    fork_a.exec(["sh", "-c", "echo a >> /work/data.txt"]).result()
    fork_b.exec(["sh", "-c", "echo b >> /work/data.txt"]).result()

import { client } from "./sandbox-client.mts";


// Restaurer le même instantané dans deux bacs à sable indépendants.
await Promise.all(
  ["a", "b"].map((name) =>
    client.withSandbox(
      (fork) => fork.commands.run(["sh", "-c", `echo ${name} >> /work/data.txt`], { check: true }),
      { fileSystemSnapshot: { mountPath: "/work", restoreFromSnapshotId: snapshotId } },
    ),
  ),
);

Gérer les instantanés

Listez, récupérez et supprimez les instantanés indépendamment des Sandbox qui les ont créés.

Python
TypeScript
API HTTP

from cwsandbox import Sandbox
from sandbox_auth import AUTH

# Lister tous les instantanés de votre organisation.
snapshots = Sandbox.list_snapshots(auth=AUTH).result()

# Récupérer les détails d’un instantané.
snapshot = Sandbox.get_snapshot(snapshot_id, auth=AUTH).result()
print(f"{snapshot.file_system_snapshot_id}: {snapshot.size_bytes} bytes")

# Supprimer un instantané. missing_ok rend l’appel idempotent.
Sandbox.delete_snapshot(snapshot_id, missing_ok=True, auth=AUTH).result()

import { client } from "./sandbox-client.mts";


// Lister tous les instantanés de votre organisation.
const snapshots = await client.listSnapshots();

// Récupérer les détails d’un instantané.
const snapshot = await client.getSnapshot(snapshotId);
if (snapshot.sizeBytes !== undefined) {
  console.log(`${snapshot.snapshotId}: ${snapshot.sizeBytes} bytes`);
} else {
  console.log(snapshot.snapshotId);
}

// Supprimer un instantané. missingOk rend l’appel idempotent.
await client.deleteSnapshot(snapshotId, { missingOk: true });

Remplacez [SNAPSHOT-ID] par l’ID de l’instantané à récupérer ou à supprimer.

# Lister les instantanés limités à l’organisation.
curl https://api.cwsandbox.com/v1beta2/file-system-snapshots \
  "${sandbox_headers[@]}"

# Obtenir un instantané.
curl https://api.cwsandbox.com/v1beta2/file-system-snapshots/[SNAPSHOT-ID] \
  "${sandbox_headers[@]}"

# Supprimer un instantané.
curl -X DELETE https://api.cwsandbox.com/v1beta2/file-system-snapshots/[SNAPSHOT-ID] \
  "${sandbox_headers[@]}"

list_snapshots(), get_snapshot() et delete_snapshot() acceptent également un objet AuthHeaders via le paramètre auth.

Statut des instantanés et échecs

Les instantanés sont créés de manière asynchrone. Une requête d’instantané peut réussir et renvoyer un fileSystemSnapshotId alors que l’archive est encore en cours d’écriture, puis l’instantané peut échouer par la suite. Cela se produit le plus souvent lorsque waitForReady vaut false, ou lorsque le délai d’expiration côté client est atteint alors que l’exécuteur est encore en train d’archiver. Pour suivre la progression via l’API HTTP, récupérez l’instantané et consultez les champs suivants :

status : l’état du cycle de vie. Les valeurs finales sont FILE_SYSTEM_SNAPSHOT_STATUS_READY et FILE_SYSTEM_SNAPSHOT_STATUS_FAILED.
statusReason : renseigné lorsque status vaut FILE_SYSTEM_SNAPSHOT_STATUS_FAILED, pour indiquer la cause de l’échec.

En TypeScript, consultez les champs state et stateReason de l’enregistrement de l’instantané. Les valeurs d’état correspondantes sont "ready" et "failed". Interrogez GetFileSystemSnapshot jusqu’à ce que l’instantané soit prêt avant de le restaurer. Les méthodes snapshot() et get_snapshot() du client Python se chargent de cette interrogation pour vous lorsque vous attendez le résultat. La méthode snapshot() du client TypeScript attend que state vaille "ready" et lève une exception si l’instantané échoue.

Récupérer après l’échec d’une requête d’instantané

Pendant la récupération après l’échec d’un instantané en cours d’exécution, laissez la sandbox source en fonctionnement. L’échec d’un appel de procédure à distance (RPC) d’instantané ne supprime pas en soi la sandbox ni son point de montage. En revanche, si vous quittez un gestionnaire de contexte de sandbox Python ou exécutez du code de démontage, la sandbox peut s’arrêter. Les données qui ne figurent pas encore dans un instantané prêt peuvent alors être perdues. Traitez l’échec avant que ce nettoyage ne s’exécute. Lors de la première utilisation, le provisionnement du bucket peut renvoyer CWSANDBOX_FSS_BUCKET_PROVISIONING. Le client Python effectue automatiquement de nouvelles tentatives en cas d’échecs transitoires des RPC d’instantané, dans la limite d’un budget défini. Si le provisionnement dure plus longtemps que ce budget, réessayez en espaçant progressivement les tentatives, tout en conservant la sandbox source. Lorsque vous relancez la même requête après un échec de transport ambigu, réutilisez un request_id explicite afin que le serveur puisse la dédupliquer. Si un ID d’instantané est disponible après l’expiration du délai, vérifiez cet instantané avant de demander une nouvelle archive. Un instantané passé à l’état FAILED nécessite une nouvelle requête pour capturer à nouveau les données. Avec le client Python 1.19.6, les échecs transitoires d’instantané peuvent lever SandboxUnavailableError, tandis que les autres échecs d’instantané lèvent SandboxSnapshotError. Pour préserver une compilation, gérez ces deux exceptions et utilisez le champ reason de l’erreur pour déterminer s’il convient de réessayer. En cas d’échec lié au quota ou à la configuration, ne réessayez pas sans en avoir d’abord corrigé la cause. Le tableau suivant répertorie les causes d’échec courantes et la marche à suivre pour chacune.

Raison	Signification	Marche à suivre
`CWSANDBOX_FSS_BUCKET_PROVISIONING`	Le bucket d’instantanés par défaut est encore en cours de provisionnement.	Réessayez dans quelques instants. Si l’erreur persiste, contactez l’assistance.
`CWSANDBOX_FSS_AUTH_FAILED`	L’échange d’identifiants d’authentification ou l’autorisation d’accès au bucket a échoué.	Réessayez une fois la politique du bucket ou la politique WIF corrigée. S’il s’agit d’un bucket managé par CoreWeave, contactez l’assistance.
`CWSANDBOX_FSS_TRANSPORT_FAILED`	L’exécuteur n’a pas pu joindre le stockage d’objets, ou le transfert de l’archive a échoué.	Réessayez. Si le problème se reproduit, contactez l’assistance en indiquant l’ID de l’instantané.
`CWSANDBOX_FSS_BACKEND_THROTTLED`	Le stockage d’objets a renvoyé une limitation de débit prolongée ou des erreurs backend.	Réessayez plus tard.
`CWSANDBOX_FSS_CREATE_TIMED_OUT`	L’instantané ne s’est pas terminé dans le délai d’expiration configuré.	Réessayez avec une valeur `maxTimeoutSeconds` plus élevée, ou réduisez le volume de données.
`CWSANDBOX_FSS_CANCELED`	L’instantané a été annulé, généralement à la suite d’une suppression forcée de la sandbox pendant une opération en cours.	Relancez l’instantané si vous avez toujours besoin des données.
`CWSANDBOX_FSS_QUOTA_EXCEEDED`	L’organisation a atteint son plafond de nombre d’instantanés ou de stockage.	Supprimez les instantanés inutilisés, ou demandez une augmentation de quota.
`CWSANDBOX_FSS_NOT_READY`	Une restauration faisait référence à un instantané qui n’est pas `READY`.	Interrogez l’instantané jusqu’à ce qu’il soit `READY`, ou choisissez-en un autre.
`CWSANDBOX_FSS_NOT_FOUND`	L’instantané n’existe pas dans votre organisation.	Vérifiez l’ID de l’instantané et l’organisation.
`CWSANDBOX_FSS_SIZE_EXCEEDED`	La taille de système de fichiers demandée dépasse la taille d’espace temporaire prise en charge.	Demandez un système de fichiers plus petit, ou contactez l’assistance au sujet des limites.

Si un exécuteur termine le téléversement de l’archive sans parvenir à enregistrer le résultat, la ligne de l’instantané peut passer à l’état FAILED alors même qu’un objet existe dans le bucket. Dans ce cas, relancez l’instantané. En cas d’échec asynchrone, la plateforme émet également un événement sandbox.file_system_snapshot.async_fail, ce qui permet aux systèmes de notification en aval de réagir aux instantanés qui échouent après le retour de l’appel initial.

Limitations

La version 1 de FSS fournit un stockage local temporaire adossé à des instantanés. Il ne s’agit pas d’un système de fichiers partagé, et il ne permet pas de montages actifs accessibles en écriture par plusieurs clients. Pendant leur exécution, les bacs à sable ne peuvent ni lire ni écrire dans les systèmes de fichiers des autres bacs à sable. Ils ne partagent leur état que par la création et la restauration d’instantanés.

Exemple avec le SDK

Pour un exemple Python complet et exécutable qui démarre une sandbox, réalise un instantané en cours d’exécution, en crée une branche, capture un instantané à l’arrêt et gère les instantanés, consultez file_system_snapshots.py dans le dépôt cwsandbox-client. Pour TypeScript, le fichier file-system-snapshots.ts du dépôt cwsandbox-js réalise un instantané en cours d’exécution, le restaure et gère les instantanés.

Utilisez votre propre bucket pour les instantanés du système de fichiers : stockez les instantanés dans un bucket dont vous êtes propriétaire.
Volumes : volumes temporaires et Volumes enregistrés partagés entre plusieurs bacs à sable.
Cycle de vie d’une sandbox : fonctionnement de stop() et des différents états d’une sandbox.
Client Python : installez le SDK et explorez l’API.

Sandbox

Utiliser les Sandbox

Gérer les bacs à sable

Référence

Instantanés du système de fichiers

Choisir l’authentification

Fonctionnement

Démarrer un sandbox avec un montage d’instantané

Système de fichiers temporaire vierge

Restaurer à partir d’un instantané

Prévoir le temps de restauration

Prendre un instantané

Instantané à l’arrêt

Instantané en cours d’exécution

Créer une branche à partir d’un instantané

Gérer les instantanés

Statut des instantanés et échecs

Récupérer après l’échec d’une requête d’instantané

Limitations

Exemple avec le SDK

​Choisir l’authentification

​Fonctionnement

​Démarrer un sandbox avec un montage d’instantané

​Système de fichiers temporaire vierge

​Restaurer à partir d’un instantané

​Prévoir le temps de restauration

​Prendre un instantané

​Instantané à l’arrêt

​Instantané en cours d’exécution

​Créer une branche à partir d’un instantané

​Gérer les instantanés

​Statut des instantanés et échecs

​Récupérer après l’échec d’une requête d’instantané

​Limitations

​Exemple avec le SDK

​Ressources associées

Choisir l’authentification

Fonctionnement

Démarrer un sandbox avec un montage d’instantané

Système de fichiers temporaire vierge

Restaurer à partir d’un instantané

Prévoir le temps de restauration

Prendre un instantané

Instantané à l’arrêt

Instantané en cours d’exécution

Créer une branche à partir d’un instantané

Gérer les instantanés

Statut des instantanés et échecs

Récupérer après l’échec d’une requête d’instantané

Limitations

Exemple avec le SDK

Ressources associées