> ## Documentation Index
> Fetch the complete documentation index at: https://docs.coreweave.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Claude Code
> Exécutez Claude Code dans une sandbox CoreWeave et interagissez avec lui depuis votre terminal, les applications Claude ou claude.ai.
Exécutez Claude Code dans une sandbox CoreWeave et choisissez votre mode d’interaction. Avec l’interface utilisateur en mode terminal (TUI), vous pilotez Claude Code dans la sandbox depuis votre terminal local. Avec Remote Control, vous utilisez l’application mobile Claude, Claude Desktop ou [claude.ai/code](https://claude.ai/code). Dans les deux cas, le processus de l’agent, les outils et le Workspace s’exécutent dans la sandbox. Les requêtes au modèle sont envoyées au fournisseur de modèles que vous avez configuré.
| Interface | Où vous interagissez | Authentification Claude |
| - | - | - |
| Terminal (TUI) | Votre terminal local, connecté à la sandbox | Un compte Claude ou des identifiants d’authentification API pris en charge |
| Remote Control | L’application mobile Claude, Claude Desktop ou claude.ai/code | Un abonnement Claude, avec connexion via `/login` |
Pour une intégration dans laquelle Anthropic gère la boucle de l’agent et une sandbox exécute les outils, voir [Claude Managed Agents](/fr/products/sandboxes/agents/claude-managed-agents).
Prérequis
Avant de commencer, vous devez disposer des éléments suivants :
* Un [jeton d’accès à l’API CoreWeave](/fr/products/sandboxes/placement#choose-and-get-credentials) disposant de l’action `SANDBOX_USER`.
* Pour l’interface en terminal, un compte Claude ou des identifiants d’authentification API pris en charge par Claude Code. Pour Remote Control, un abonnement Claude Pro, Max, Team ou Enterprise. Les clés API et les jetons `claude setup-token` ne permettent pas de s’authentifier auprès de Remote Control.
* Une URL de dépôt que la sandbox peut cloner. Les exemples utilisent un dépôt public. Pour les dépôts privés, des identifiants d’authentification Git doivent être disponibles dans la sandbox.
Exportez votre jeton d’accès à l’API CoreWeave dans le terminal à partir duquel vous suivez ce guide :
```bash theme={"system"}
export CWSANDBOX_API_KEY="[API-ACCESS-TOKEN]"
```
Pour Remote Control, les comptes Team et Enterprise nécessitent qu'un Owner active la fonctionnalité. Votre organisation doit également autoriser le stockage de ses transcriptions. Les organisations soumises à des exigences de Zero Data Retention ne peuvent pas l'activer. Consultez les [exigences de Remote Control](https://code.claude.com/docs/en/remote-control#requirements) d'Anthropic.
Les connexions passent par HTTPS sortant et ne nécessitent ni point de terminaison public pour la sandbox ni port entrant.
Les deux méthodes de configuration appliquent une durée de vie de sandbox de 8 heures, soit une journée de travail. Cette durée de vie court dès la création, inclut le temps de configuration et d'inactivité, et ne peut pas être prolongée. À son expiration, la sandbox s'arrête même si Claude est en cours de travail, ce qui met fin à la session. [Enregistrez vos résultats et arrêtez la sandbox](#keep-results-and-stop) une fois votre travail terminé, avant l'expiration de la durée de vie.
Pour un travail de nuit, choisissez 24 heures lors de la création. Avec `cws-agent`, utilisez `--lifetime 24h`. Dans les exemples du kit de développement logiciel (SDK), définissez `max_lifetime_seconds` en Python ou `maxLifetimeSeconds` en TypeScript sur `24 * 3600`.
Démarrage rapide avec cws-agent
Choisissez ce parcours de configuration pour créer la sandbox avec `cws-agent`. Pour la créer directement avec une bibliothèque cliente, passez à la section [Configurer avec le SDK Sandboxes](#set-up-with-the-sandbox-sdk). Les deux parcours prennent en charge l’une ou l’autre interface.
Suivez les [instructions d’installation de `cws-agent`](https://github.com/coreweave/cws-agent#install). L’outil configure un volume d’instantanés qui permet d’enregistrer et de restaurer votre Workspace à l’aide d’[instantanés du système de fichiers](/fr/products/sandboxes/file-system-snapshots#start-a-sandbox-with-a-snapshot-mount).
Avant l’ouverture de Claude, `cws-agent` peut afficher un aperçu des compétences locales et des serveurs Model Context Protocol (MCP) à importer. Pour ce guide, appuyez sur **Enter** à l’invite d’importation pour ignorer cette étape. Vous pourrez configurer les importations ultérieurement en suivant les [recommandations sur les outils d’agent](/fr/products/sandboxes/agents#use-tools-efficiently).
Choisissez l’une des interfaces suivantes. Remplacez `[SANDBOX-NAME]` par un nom de session `cws-agent` et `[REPOSITORY-URL]` par l’URL d’un dépôt public. Le nom de session doit comporter de 1 à 40 lettres minuscules, chiffres ou traits d’union, et commencer par une lettre ou un chiffre.
Utiliser l’interface du terminal
Pour utiliser une clé API Anthropic, chargez-la dans la variable `ANTHROPIC_API_KEY` de votre terminal local avant de lancer ou de restaurer la sandbox. `cws-agent` transmet cette variable à la sandbox. L’authentification par clé API ne nécessite pas de connexion via le navigateur. Voir [Authentification de Claude Code](https://code.claude.com/docs/en/authentication).
Lancez Claude Code et connectez votre terminal local :
```bash theme={"system"}
cws-agent launch [SANDBOX-NAME] --repo-url [REPOSITORY-URL] --lifetime 8h --permission-mode native
```
Claude Code s'ouvre dans le répertoire du projet de la sandbox. Répondez aux éventuelles invites de confiance du Workspace. Pour l'authentification par clé API, approuvez la clé lorsque vous y êtes invité. Si vous avez besoin d'une authentification par compte, quittez Claude et exécutez `cws-agent login [SANDBOX-NAME]`, puis effectuez la procédure `/login` depuis cette session.
L'option `--permission-mode native` applique les paramètres d'approbation propres à Claude. Sans cette option, `cws-agent` ignore par défaut ces invites d'approbation. Voir [modes d'autorisation](https://github.com/coreweave/cws-agent/blob/main/docs/permissions.md).
Si Claude indique `Not logged in` alors qu'une clé API est configurée et ne vous propose jamais de l'approuver, quittez avec `/exit`, puis reconnectez-vous en activant la prise en main :
```bash theme={"system"}
cws-agent connect [SANDBOX-NAME] --cmd 'unset IS_DEMO; exec claude'
```
Cette commande utilise les paramètres d'approbation propres à Claude. Acceptez les invites concernant la confiance accordée au Workspace et la clé d'API avant de continuer.
Passez ensuite à la section [Vérifier la session](#check-the-session) pour envoyer un prompt et contrôler le résultat.
Utiliser Remote Control
Créez une sandbox détachée, puis connectez votre terminal pour vous authentifier avec votre abonnement :
```bash theme={"system"}
cws-agent launch [SANDBOX-NAME] --repo-url [REPOSITORY-URL] --lifetime 8h --detach
cws-agent connect [SANDBOX-NAME] --cmd 'unset IS_DEMO CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC CLAUDE_CODE_OAUTH_TOKEN ANTHROPIC_API_KEY; exec claude'
```
La commande de connexion efface les paramètres qui empêcheraient la connexion par abonnement ou les vérifications de la fonctionnalité Remote Control. Elle supprime également la variable `IS_DEMO` afin d’activer la prise en main. Voir [Variables d’environnement de Claude Code](https://code.claude.com/docs/en/env-vars).
Dans Claude, exécutez `/login` avec le compte associé à votre abonnement Claude, puis acceptez le prompt de confiance du projet. Exécutez `/remote-control` et acceptez la confirmation de première utilisation, puis quittez Claude avec `/exit`. Effectuez cette étape de manière interactive afin de pouvoir répondre à la confirmation avant de démarrer le serveur détaché.
Depuis votre terminal local, démarrez Remote Control avec les paramètres d’approbation propres à Claude :
```bash theme={"system"}
cws-agent rc [SANDBOX-NAME] --permission-mode native
```
Ouvrez l’URL de la session dès qu’elle s’affiche. Un message indiquant qu’un processus a démarré ne suffit pas à confirmer la connexion. Envoyez un prompt depuis le client web, mobile ou de bureau, puis vérifiez le résultat comme indiqué dans [Vérifier la session](#check-the-session).
Si aucune URL ne s’affiche, examinez le journal distant :
```bash theme={"system"}
cws-agent exec [SANDBOX-NAME] 'cat /workspace/home/remote-control.log'
```
Résolvez toute erreur de connexion ou d’éligibilité avant de réessayer. Si le serveur attend une réponse à une invite interactive, redémarrez-le dans une session `tmux` attachée, dans la même sandbox. La commande `cws-agent rc` redirige la sortie vers le journal : si vous vous attachez à sa session existante, les invites ne s’affichent donc pas.
Depuis votre terminal local, arrêtez le serveur en attente et ouvrez une nouvelle session :
```bash theme={"system"}
cws-agent exec [SANDBOX-NAME] 'tmux kill-session -t cws-remote-control'
cws-agent connect [SANDBOX-NAME] --cmd 'tmux new-session -s cws-remote-control'
```
Dans `tmux`, démarrez Remote Control afin que ses sessions utilisent le répertoire du projet :
```bash theme={"system"}
unset IS_DEMO CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC CLAUDE_CODE_OAUTH_TOKEN ANTHROPIC_API_KEY
cd /workspace/project
claude remote-control --spawn same-dir
```
Répondez aux éventuelles invites et ouvrez l’URL Claude Code affichée. Une fois la connexion établie, détachez-vous avec **Ctrl-b**, puis **d**, pour que le serveur continue de s’exécuter. La session de remplacement affiche sa sortie dans `tmux` au lieu de mettre à jour le journal. Pour y revenir, exécutez `cws-agent connect [SANDBOX-NAME] --cmd 'tmux attach -t cws-remote-control'`.
Configurer avec le SDK Sandboxes
Utilisez cette méthode alternative pour créer une sandbox avec le SDK Sandboxes, quelle que soit l’interface choisie. Elle ne dépend pas de `cws-agent` et ne configure pas d’instantanés.
Exécutez les extraits de code Python dans l’environnement virtuel créé au cours de ce guide. Enregistrez les extraits de code TypeScript dans des fichiers `.mts` au sein du projet où vous installez le client, puis exécutez-les avec `npx tsx [FILENAME].mts`.
Créer la sandbox
Choisissez un client et installez-le localement :
Utilisez Python 3.11 ou une version ultérieure, ainsi que `uv` :
```bash theme={"system"}
uv venv --python 3.11
source .venv/bin/activate
uv pip install 'cwsandbox>=1.14.2'
```
Utilisez Node.js 22 ou une version ultérieure. Installez le client et l’exécuteur TypeScript dans votre projet :
```bash theme={"system"}
npm install @coreweave/cwsandbox@0.5.0-beta.0 tsx
```
Enregistrez le script correspondant à votre langage sous le nom de fichier indiqué. Il installe Claude Code et `tmux`, puis clone le dépôt que vous passez en ligne de commande.
Les deux scripts exigent que le conteneur s’exécute en tant que root pour pouvoir installer des paquets avec `apt-get` et utiliser `/root/.local/bin/claude`. La politique de votre exécuteur doit autoriser cet utilisateur.
```python title="create_claude_sandbox.py" theme={"system"}
import sys
from cwsandbox import Sandbox
bootstrap = """
set -o pipefail
apt-get update -qq
DEBIAN_FRONTEND=noninteractive apt-get install -y -qq tmux >/dev/null
curl -fsSL https://claude.ai/install.sh | bash
mkdir -p /workspace
"""
sandbox = Sandbox.run(
container_image="node:22-bookworm",
resources={"cpu": "2", "memory": "4Gi"},
max_lifetime_seconds=8 * 3600,
tags=["claude-code"],
)
try:
sandbox.wait()
commands = [
["bash", "-ec", bootstrap],
["git", "clone", "--", sys.argv[1], "/workspace/project"],
]
for command in commands:
result = sandbox.exec(command, timeout_seconds=900).result()
if result.returncode != 0:
raise RuntimeError(result.stderr or result.stdout)
except BaseException:
sandbox.stop().result()
raise
print(f"Sandbox ID: {sandbox.sandbox_id}")
```
```typescript title="create_claude_sandbox.mts" theme={"system"}
import { createSandboxClientFromEnv } from "@coreweave/cwsandbox/node";
const repository = process.argv[2];
if (!repository) throw new Error("Pass a repository URL.");
const bootstrap = `
set -o pipefail
apt-get update -qq
DEBIAN_FRONTEND=noninteractive apt-get install -y -qq tmux >/dev/null
curl -fsSL https://claude.ai/install.sh | bash
mkdir -p /workspace
`;
const client = createSandboxClientFromEnv();
const sandbox = await client.create({
containerImage: "node:22-bookworm",
resources: { cpu: "2", memory: "4Gi" },
maxLifetimeSeconds: 8 * 3600,
waitUntilRunning: false,
tags: ["claude-code"],
});
try {
await sandbox.wait();
const commands = [
["bash", "-ec", bootstrap],
["git", "clone", "--", repository, "/workspace/project"],
];
for (const command of commands) {
await sandbox.commands.run(command, { timeoutMs: 900_000, check: true });
}
} catch (error) {
await sandbox.stop();
throw error;
}
console.log(`Sandbox ID: ${sandbox.sandboxId}`);
```
Remplacez `[REPOSITORY-URL]` par l’URL de votre dépôt public :
```bash theme={"system"}
python create_claude_sandbox.py [REPOSITORY-URL]
```
```bash theme={"system"}
npx tsx create_claude_sandbox.mts [REPOSITORY-URL]
```
Notez l’ID de sandbox affiché. Dans ces exemples autonomes, la sandbox continue de s’exécuter une fois le script terminé, jusqu’à ce que vous l’arrêtiez ou que sa durée de vie de 8 heures expire. En Python, si vous encapsulez la sandbox dans une `Session` ou un gestionnaire de contexte, ce comportement de nettoyage est différent.
Connecter votre terminal
Utilisez le SDK pour connecter votre terminal local avec les mêmes identifiants d’authentification CoreWeave. Le script transmet les frappes clavier à un shell de la sandbox et restaure votre terminal à la fermeture du shell.
Sous macOS ou Linux, enregistrez ce script sous le nom `attach_sandbox.py` :
```python title="attach_sandbox.py" theme={"system"}
import os
import shutil
import sys
import termios
import threading
import tty
from cwsandbox import Sandbox
if not sys.stdin.isatty() or not sys.stdout.isatty():
raise SystemExit("Run this script in an interactive terminal.")
sandbox = Sandbox.from_id(sys.argv[1]).result()
size = shutil.get_terminal_size()
terminal = sandbox.shell(["/bin/bash"], width=size.columns, height=size.lines)
fd = sys.stdin.fileno()
saved = termios.tcgetattr(fd)
def forward_input():
while data := os.read(fd, 1024):
terminal.stdin.write(data).result()
terminal.stdin.close().result()
try:
tty.setraw(fd)
threading.Thread(target=forward_input, daemon=True).start()
for chunk in terminal.output:
sys.stdout.buffer.write(chunk)
sys.stdout.buffer.flush()
result = terminal.result()
finally:
termios.tcsetattr(fd, termios.TCSADRAIN, saved)
terminal.stdin.close().result()
raise SystemExit(result.returncode)
```
Enregistrez ce script sous le nom `attach_sandbox.mts` :
```typescript title="attach_sandbox.mts" theme={"system"}
import { createSandboxClientFromEnv } from "@coreweave/cwsandbox/node";
if (!process.stdin.isTTY || !process.stdout.isTTY) {
throw new Error("Run this script in an interactive terminal.");
}
const sandboxId = process.argv[2];
if (!sandboxId) throw new Error("Pass a sandbox ID.");
const client = createSandboxClientFromEnv();
const sandbox = await client.fromId(sandboxId);
const terminal = await sandbox.shell({
command: ["/bin/bash"],
cols: process.stdout.columns || 80,
rows: process.stdout.rows || 24,
});
const wasRaw = process.stdin.isRaw;
const forwardInput = (chunk: Buffer) => {
void terminal.stdin.write(chunk).catch((error) => {
console.error(error);
void terminal.cancel();
});
};
try {
process.stdin.setRawMode(true);
process.stdin.on("data", forwardInput);
process.stdin.resume();
for await (const chunk of terminal.output) {
process.stdout.write(chunk);
}
const result = await terminal.wait();
process.exitCode = result.exitCode;
} finally {
process.stdin.off("data", forwardInput);
process.stdin.setRawMode(wasRaw);
process.stdin.pause();
await terminal.stdin.close();
}
```
Remplacez `[SANDBOX-ID]` par l’ID affiché, puis exécutez :
```bash theme={"system"}
python attach_sandbox.py [SANDBOX-ID]
```
```bash theme={"system"}
npx tsx attach_sandbox.mts [SANDBOX-ID]
```
`cwsandbox sh [SANDBOX-ID]` est un raccourci facultatif. Installez l’extra `cli` et veillez à ce que `CWSANDBOX_API_KEY` reste défini sur le jeton d’accès à l’API CoreWeave utilisé pour cette sandbox.
Votre terminal est désormais connecté à un shell dans la sandbox. Choisissez l’une des interfaces suivantes pour lancer Claude Code.
Démarrer l'interface en mode terminal
Pour l'authentification par clé d'API, saisissez la clé dans le shell Bash de la sandbox avant de démarrer Claude. La saisie est masquée et n'apparaît pas dans l'historique des commandes :
```bash theme={"system"}
read -r -s -p 'Anthropic API key: ' ANTHROPIC_API_KEY
export ANTHROPIC_API_KEY
printf '\n'
```
Dans le sandbox, lancez Claude depuis le dépôt cloné :
```bash theme={"system"}
cd /workspace/project
/root/.local/bin/claude
```
Si vous utilisez une clé API, approuvez-la. Sinon, connectez-vous à votre compte. Acceptez ensuite les invites de confiance du Workspace, puis passez à [Vérifier la session](#check-the-session).
Démarrer Remote Control
Pour cette interface, connectez-vous avec votre abonnement Claude. Si vous avez déjà utilisé une clé API dans ce sandbox, supprimez-la du shell et de tous les paramètres Claude avant de vous connecter :
```bash theme={"system"}
unset ANTHROPIC_API_KEY CLAUDE_CODE_OAUTH_TOKEN
```
Dans la sandbox, ouvrez une session `tmux` nommée dans votre projet :
```bash theme={"system"}
cd /workspace/project
tmux new-session -s claude-remote
```
Dans `tmux`, lancez Claude :
```bash theme={"system"}
/root/.local/bin/claude
```
Terminez la connexion avec votre abonnement et acceptez l’invite de confiance du Workspace. Quittez Claude avec `/exit`, puis démarrez le serveur Remote Control dans le même répertoire :
```bash theme={"system"}
/root/.local/bin/claude remote-control --name "CoreWeave sandbox" --spawn same-dir
```
L’option `--spawn same-dir` utilise le répertoire du projet pour les sessions distantes. Si vous y êtes invité, acceptez la confirmation de première utilisation. Ouvrez l’URL Claude Code affichée dans un navigateur connecté au même compte Claude.
Une fois la connexion établie, détachez-vous de `tmux` avec **Ctrl-b**, puis **d**, et quittez le shell de la sandbox. La session `tmux` maintient le serveur en cours d’exécution. Pour revenir à la session, relancez le script de connexion, puis exécutez `tmux attach -t claude-remote`.
Vérifier la session
Pour l’interface de terminal, envoyez le prompt dans la TUI Claude Code associée. Pour Remote Control, ouvrez la session à l’adresse claude.ai/code dans votre navigateur, ou dans l’application Claude mobile ou Desktop, avec le même compte.
Choisissez une valeur de test unique et non secrète, puis remplacez `[PROOF-VALUE]` dans ce prompt :
```text theme={"system"}
Écrivez le texte exact [PROOF-VALUE] dans /workspace/project/sandbox-proof.txt, puis relisez-le.
```
Si cela vous est demandé, autorisez l’écriture du fichier. Si vous avez utilisé l’interface en mode terminal, quittez Claude avec `/exit` puis, pour la configuration avec le SDK, quittez le shell du sandbox avec `exit`. Depuis votre terminal local, vérifiez le résultat à l’aide de la commande correspondant à votre configuration :
```bash theme={"system"}
cws-agent exec [SANDBOX-NAME] 'cat /workspace/project/sandbox-proof.txt'
```
```python theme={"system"}
from cwsandbox import Sandbox
sandbox = Sandbox.from_id("[SANDBOX-ID]").result()
result = sandbox.exec(["cat", "/workspace/project/sandbox-proof.txt"], check=True).result()
print(result.stdout, end="")
```
```typescript theme={"system"}
import { createSandboxClientFromEnv } from "@coreweave/cwsandbox/node";
const client = createSandboxClientFromEnv();
const sandbox = await client.fromId("[SANDBOX-ID]");
const result = await sandbox.commands.run(["cat", "/workspace/project/sandbox-proof.txt"], { check: true });
process.stdout.write(result.stdout);
```
Si la valeur correspond, Claude a bien écrit dans le sandbox que vous avez créé.
Revenir à une sandbox en cours d’exécution
Si vous quittez Claude ou fermez votre terminal, la sandbox continue de s’exécuter. Pour y revenir depuis un autre terminal ou une autre machine, installez le même client et authentifiez-vous avec des identifiants d’authentification ayant accès à la sandbox.
Pour `cws-agent`, trouvez la session par son nom et ouvrez un nouveau terminal Claude :
```bash theme={"system"}
cws-agent list
cws-agent status [SANDBOX-NAME]
cws-agent connect [SANDBOX-NAME] --permission-mode native
```
La commande `connect` utilise la sandbox et les fichiers existants, mais elle ne reprend pas une conversation précédente. Pour poursuivre une conversation enregistrée, quittez d'abord son processus Claude original. Affichez ensuite la liste de l'historique, puis remplacez `[CONVERSATION-ID]` par l'ID de la conversation à reprendre :
```bash theme={"system"}
cws-agent session history [SANDBOX-NAME]
cws-agent session resume [SANDBOX-NAME] [CONVERSATION-ID] --permission-mode native
```
Pour la méthode SDK, relancez le [script de rattachement du terminal](#attach-your-terminal) avec le même ID de sandbox, puis redémarrez Claude. Une session shell SDK prend fin au bout de 24 heures, même si la durée de vie de la sandbox est plus longue. La sandbox continue de s'exécuter : il suffit donc de relancer le script pour vous reconnecter. Pour Remote Control, rouvrez l'URL de la session tant que son serveur est toujours en cours d'exécution.
La connexion à une sandbox et le processus d'un agent ont des durées de vie distinctes. Si un agent de terminal doit continuer à travailler après votre déconnexion, utilisez `tmux` ou les sessions de worktree `cws-agent`.
La reconnexion ne réinitialise pas la durée de vie de la sandbox. Si la sandbox est arrêtée, restaurez plutôt un Workspace enregistré.
Conserver les résultats et arrêter
Enregistrez régulièrement votre progression au cours d’une longue session, sans attendre que la durée de vie soit presque écoulée. Avec `cws-agent`, attendez que Claude ait fini d’écrire et suspendez les autres processus qui écrivent dans le Workspace, puis capturez le répertoire `/workspace` sans arrêter la sandbox :
```bash theme={"system"}
cws-agent snapshot [SANDBOX-NAME]
```
Attendez que la commande signale un instantané `READY`. Un instantané capture les fichiers tels qu’ils sont à cet instant précis. Toute modification ultérieure nécessite un nouvel instantané. Pour en savoir plus sur le comportement de capture et les identifiants d’authentification enregistrés, consultez les [recommandations relatives aux instantanés](https://github.com/coreweave/cws-agent/blob/main/docs/usage.md#snapshots). Ne comptez pas sur l’expiration de la durée de vie pour enregistrer vos dernières modifications.
Dans votre terminal local, copiez le résultat texte vérifié sur votre machine :
```bash theme={"system"}
cws-agent exec [SANDBOX-NAME] 'cat /workspace/project/sandbox-proof.txt' > sandbox-proof.txt
```
Pour les modifications de code, consultez [Récupérer les modifications](https://github.com/coreweave/cws-agent/blob/main/docs/usage.md#get-changes-back). Un instantané conserve le Workspace distant, mais ne copie aucun fichier sur votre machine.
Une fois votre travail terminé, attendez que les tâches actives et les écritures dans le Workspace soient achevées, puis enregistrez le Workspace et arrêtez les ressources de calcul :
```bash theme={"system"}
cws-agent down [SANDBOX-NAME]
```
La commande `down` s’assure qu’un instantané a bien été créé avant l’arrêt. Si la création de l’instantané échoue, la sandbox reste en cours d’exécution. Vérifiez `cws-agent status [SANDBOX-NAME]` et corrigez le problème avant toute nouvelle tentative. Pour arrêter la sandbox sans enregistrer les modifications en cours, utilisez `cws-agent down [SANDBOX-NAME] --no-snapshot`.
Si vous utilisez directement le SDK, cet exemple ne comporte aucun montage persistant. Pour disposer d’un Workspace restaurable, configurez des [instantanés du système de fichiers](/fr/products/sandboxes/file-system-snapshots) lors de la création. Récupérez les résultats à l’aide des [opérations sur les fichiers](/fr/products/sandboxes/client/guides/file-operations), puis arrêtez la sandbox :
```python theme={"system"}
from cwsandbox import Sandbox
sandbox = Sandbox.from_id("[SANDBOX-ID]").result()
sandbox.stop().result()
```
```typescript theme={"system"}
import { createSandboxClientFromEnv } from "@coreweave/cwsandbox/node";
const client = createSandboxClientFromEnv();
const sandbox = await client.fromId("[SANDBOX-ID]");
await sandbox.stop();
```
Quitter Claude ne suffit pas : la sandbox reste en cours d’exécution. L’arrêt de la sandbox met fin à ses processus d’agent, y compris Remote Control. La restauration des fichiers à partir d’un instantané ne relance pas ce processus. Connectez-vous si nécessaire, puis relancez Remote Control.
Pour reprendre un Workspace enregistré par `cws-agent`, restaurez-le dans une nouvelle sandbox. Si l’invite d’importation des compétences/MCP s’affiche, appuyez sur **Enter** pour l’ignorer :
```bash theme={"system"}
cws-agent restore [SANDBOX-NAME] --lifetime 8h --connect --permission-mode native
```
Pour Remote Control, quittez la TUI Claude restaurée avec `/exit`, puis reprenez les [étapes de connexion et de démarrage du serveur](#use-remote-control) à partir de `cws-agent connect`. Ignorez la commande de lancement, car la restauration a déjà créé la sandbox. Pour les conversations enregistrées et les worktrees parallèles, consultez le [guide des sessions `cws-agent`](https://github.com/coreweave/cws-agent/blob/main/docs/sessions.md).
Dépannage
Effectuez ces vérifications pour résoudre les problèmes courants :
* Si la création du sandbox échoue, vérifiez votre jeton d’accès à l’API CoreWeave et vos paramètres d’authentification.
* Si l’installation, le clonage ou les requêtes au modèle échouent, vérifiez la connectivité sortante et les identifiants d’authentification du fournisseur concerné. Pour le [placement sur CoreWeave Kubernetes Service (CKS)](/fr/products/sandboxes/get-started-cks), la politique de votre exécuteur doit autoriser ces destinations.
* Si le terminal se déconnecte, rattachez-vous au sandbox tant qu’il est en cours d’exécution. Pour qu’un processus survive aux déconnexions du terminal, exécutez-le dans un multiplexeur de terminal tel que `tmux`.
* Si Remote Control rejette l’authentification, connectez-vous avec un abonnement Claude. Supprimez de l’environnement distant ou des paramètres de Claude les identifiants d’authentification par clé API qui entrent en conflit.
* Si Remote Control n’est pas disponible, consultez les [instructions de dépannage d’Anthropic](https://code.claude.com/docs/en/remote-control#troubleshooting) concernant les paramètres de l’organisation, les points de terminaison d’API personnalisés et les variables d’environnement qui désactivent des vérifications de fonctionnalités requises.
* Si le sandbox expire, créez-en un nouveau. Sa durée de vie ne peut pas être prolongée après sa création, et cet exemple de SDK n’enregistre pas automatiquement son système de fichiers.
Gestion des données
Les commandes s’exécutent dans la sandbox, tandis que les requêtes adressées au modèle sont envoyées au fournisseur que vous avez configuré. Remote Control envoie à Anthropic les prompts, l’activité des outils et le contenu des conversations, et stocke une transcription afin de synchroniser les appareils connectés. Voir [Sécurité de Remote Control](https://code.claude.com/docs/en/remote-control#connection-and-security) et [Utilisation des données par Claude Code](https://code.claude.com/docs/en/data-usage).
Étapes suivantes
Pour plus d'informations, voir ces guides :
* [Shells interactifs et TTY](/fr/products/sandboxes/client/guides/interactive-shells) traite de l’accès au terminal depuis le SDK.
* [Cycle de vie d’une sandbox](/fr/products/sandboxes/client/guides/sandbox-lifecycle) aborde l’attente, la reconnexion et l’arrêt.
* [Documentation de Claude Code](https://code.claude.com/docs/en/overview) explique la configuration de l’agent et l’authentification.
Pour provisionner une sandbox worker pour chaque nouvelle session cloud que vous démarrez sur claude.ai/code, voir [Sessions cloud Claude Code](/fr/products/sandboxes/agents/claude-code-cloud).