> ## 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.

# Exécuter OpenCode dans une sandbox

> Exécutez OpenCode dans une sandbox avec Serverless Inference ou un autre fournisseur de modèles.

Exécutez OpenCode sur un dépôt dans une sandbox CoreWeave. Envoyez une tâche depuis votre
terminal, vérifiez les fichiers produits et enregistrez le Workspace pour le réutiliser ultérieurement. Le processus
de l’agent, le Workspace et les commandes s’exécutent dans la sandbox. Les requêtes adressées au modèle sont envoyées au
fournisseur que vous avez configuré.

<h2 id="prerequisites">
  Prérequis
</h2>

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) doté de l’action `SANDBOX_USER` pour accéder à la sandbox.
* Un accès à un modèle via Serverless Inference ou un autre
  fournisseur OpenCode. L’accès au fournisseur et
  la facturation sont indépendants de l’accès à la sandbox.
* L’URL d’un dépôt public. Pour un dépôt privé, des identifiants d’authentification Git sont nécessaires dans
  la sandbox.
* `cws-agent`, installé selon ses
  [instructions d’installation](https://github.com/coreweave/cws-agent#install).

Dans votre terminal local, remplacez `[API-ACCESS-TOKEN]` par votre jeton d’accès à l’API CoreWeave :

```bash theme={"system"}
export CWSANDBOX_API_KEY="[API-ACCESS-TOKEN]"
```

<h2 id="launch-opencode-with-cws-agent">
  Lancer OpenCode avec cws-agent
</h2>

Utilisez `cws-agent` pour installer OpenCode dans une sandbox, cloner votre dépôt dans
le répertoire `/workspace/project` et configurer un point de montage d’instantanés pour les
[instantanés du système de fichiers](/fr/products/sandboxes/file-system-snapshots).

Choisissez l’une des options de fournisseur suivantes. Remplacez `[SANDBOX-NAME]` par un
nom de session composé de 1 à 40 lettres minuscules, chiffres ou traits d’union. Le
nom doit commencer par une lettre ou un chiffre. Remplacez `[REPOSITORY-URL]` par l’URL de votre dépôt public.

<h3 id="use-wb-serverless-inference-recommended">
  Utiliser Serverless Inference (recommandé)
</h3>

Serverless Inference est le fournisseur recommandé pour ce guide. Il vous permet
d’accéder à des modèles ouverts hébergés. Vous pouvez aussi utiliser n’importe quel modèle et fournisseur pris en charge par
OpenCode. Dans ce cas, suivez la section
[Utiliser un autre fournisseur de modèles](#use-another-model-provider).

Remplissez les [prérequis de Serverless Inference](/fr/products/inference/serverless/api-reference#prerequisites),
notamment la création d’un projet Forge, et vérifiez vos
[crédits d’inférence](/fr/products/inference/serverless/usage-limits) disponibles.
Définissez une clé API Forge pour l’inférence. Cet exemple sélectionne explicitement GLM 5.2 :

```bash theme={"system"}
export FORGE_API_KEY="[FORGE-API-KEY]"
WANDB_API_KEY="$FORGE_API_KEY" cws-agent launch [SANDBOX-NAME] --agent opencode \
  --repo-url [REPOSITORY-URL] --lifetime 2h \
  --wandb --wandb-model zai-org/GLM-5.2 \
  --permission-mode native --detach
```

Le préréglage `--wandb` configure le point de terminaison d'inférence de Forge et limite OpenCode à ce fournisseur. Ce préréglage de la CLI attend une variable d’environnement nommée `WANDB_API_KEY` : la commande associe donc votre `FORGE_API_KEY` à ce nom et la transmet à la sandbox. L’accès à la sandbox s’effectue avec `CWSANDBOX_API_KEY`. Pour choisir un autre
modèle Forge, remplacez `zai-org/GLM-5.2` par un ID figurant dans la liste des
[modèles disponibles](/fr/products/inference/serverless/models).

<h3 id="use-another-model-provider">
  Utiliser un autre fournisseur de modèles
</h3>

Pour utiliser un autre fournisseur, omettez `--wandb` et `--wandb-model` lors de la création de la
sandbox. Exportez localement la clé API de ce fournisseur. Par exemple, choisissez l'une de
ces options et remplacez la valeur de substitution de la clé :

<Tabs>
  <Tab title="Anthropic">
    ```bash theme={"system"}
    export ANTHROPIC_API_KEY="[ANTHROPIC-API-KEY]"
    ```
  </Tab>

  <Tab title="OpenAI">
    ```bash theme={"system"}
    export OPENAI_API_KEY="[OPENAI-API-KEY]"
    ```
  </Tab>
</Tabs>

Dans les deux champs, remplacez `[PROVIDER-ID]/[MODEL-ID]` par votre identifiant de modèle
OpenCode, avec le préfixe de fournisseur `anthropic/` ou `openai/` selon le cas.
Le champ `small_model` définit le modèle utilisé pour les tâches légères, comme la génération
de titres. Voir [Modèles OpenCode](https://opencode.ai/docs/models/).

```bash theme={"system"}
export OPENCODE_CONFIG_CONTENT='{"model":"[PROVIDER-ID]/[MODEL-ID]","small_model":"[PROVIDER-ID]/[MODEL-ID]"}'
cws-agent launch [SANDBOX-NAME] --agent opencode \
  --repo-url [REPOSITORY-URL] --lifetime 2h \
  --env-passthrough OPENCODE_CONFIG_CONTENT \
  --permission-mode native --detach
```

Si elles sont définies, `cws-agent` transmet `ANTHROPIC_API_KEY` et `OPENAI_API_KEY`.
Pour les fournisseurs dont les clés ne sont pas transmises automatiquement, suivez leur
[configuration de fournisseur OpenCode](https://opencode.ai/docs/providers/) et utilisez
`--env-passthrough [VARIABLE-NAME]` pour transmettre d’autres variables d’environnement.

Les deux options de lancement affichent `session ready.` une fois la configuration terminée. `--detach` laisse la
sandbox s’exécuter sans ouvrir l’interface du terminal ni importer les compétences locales
ni la configuration Model Context Protocol (MCP). La durée de vie de 2 heures correspond à une
limite en temps réel, configuration comprise. Arrêtez les ressources de calcul lorsque vous avez terminé.

<h2 id="run-a-task-and-check-the-result">
  Exécuter une tâche et vérifier le résultat
</h2>

Depuis votre terminal local, demandez à OpenCode d’écrire puis de lire un fichier :

```bash theme={"system"}
cws-agent run [SANDBOX-NAME] \
  'Create sandbox-proof.txt in the current directory containing exactly Hello from CoreWeave followed by a newline, then read it back. Do not commit or push anything.' \
  --permission-mode native
```

Cette commande exécute OpenCode sans terminal interactif. `--permission-mode native`
conserve les autorisations configurées dans OpenCode. Sans cette option, `cws-agent` accepte par défaut
les demandes d'approbation. Si votre politique OpenCode exige une approbation pour la
tâche, utilisez une session interactive pour l'approuver. Voir
[Autorisations OpenCode](https://opencode.ai/docs/permissions/).

Vérifiez le fichier lui-même, indépendamment de la réponse de l'agent :

```bash theme={"system"}
cws-agent exec [SANDBOX-NAME] 'cat /workspace/project/sandbox-proof.txt'
```

Vous devriez obtenir la sortie `Hello from CoreWeave`. Avant d’arrêter les ressources de calcul, récupérez
une copie locale :

```bash theme={"system"}
cws-agent exec [SANDBOX-NAME] 'cat /workspace/project/sandbox-proof.txt' > sandbox-proof.txt
```

<h3 id="optional-work-interactively">
  Facultatif : travailler de manière interactive
</h3>

Depuis un terminal interactif sous macOS ou Linux, ouvrez OpenCode dans le
même Workspace :

```bash theme={"system"}
cws-agent connect [SANDBOX-NAME] --permission-mode native --no-config-sync
```

L’option `--no-config-sync` ignore les compétences locales et les importations MCP. Envoyez des prompts et
approuvez des actions dans OpenCode, puis utilisez `/exit` pour revenir à votre terminal local.
Lorsque vous quittez OpenCode, la sandbox continue de s’exécuter. Relancez la commande de
connexion pour rouvrir OpenCode. Aucune conversation précédente n’est sélectionnée automatiquement.
Pour l’historique des conversations et les commandes de reprise, consultez
[Sessions `cws-agent`](https://github.com/coreweave/cws-agent/blob/main/docs/sessions.md).

<h2 id="save-stop-and-restore">
  Enregistrer, arrêter et restaurer
</h2>

Une fois l’agent terminé, créez un instantané du Workspace et arrêtez les ressources de calcul :

```bash theme={"system"}
cws-agent down [SANDBOX-NAME]
```

`down` enregistre le répertoire `/workspace` avant d’arrêter la sandbox. Si l’instantané échoue,
la sandbox continue de s’exécuter. Examinez l’erreur, corrigez-la, puis effectuez une nouvelle tentative.
Pour arrêter la sandbox sans attendre d’instantané explicite, exécutez :

```bash theme={"system"}
cws-agent down [SANDBOX-NAME] --no-snapshot
```

Ne comptez pas sur cette commande pour enregistrer les modifications. Copiez les résultats ailleurs ou vérifiez qu'un instantané est terminé avant l'arrêt. La restauration nécessite un instantané terminé.

Pour revenir à un Workspace enregistré avec l'inférence Forge, assurez-vous que `FORGE_API_KEY` est
toujours exportée dans votre terminal local, puis exécutez :

```bash theme={"system"}
WANDB_API_KEY="$FORGE_API_KEY" cws-agent restore [SANDBOX-NAME] --wandb --wandb-model zai-org/GLM-5.2 --lifetime 2h --no-config-sync
```

Utilisez la même valeur `--wandb-model` que lors du lancement. Si vous l’omettez en utilisant
`--wandb`, la restauration sélectionne le modèle par défaut du préréglage.

Pour un autre fournisseur, exportez à nouveau sa clé et `OPENCODE_CONFIG_CONTENT`, puis exécutez :

```bash theme={"system"}
cws-agent restore [SANDBOX-NAME] --env-passthrough OPENCODE_CONFIG_CONTENT --lifetime 2h --no-config-sync
```

La restauration crée un nouveau sandbox à partir du Workspace enregistré. Fournissez de nouveau les identifiants
d’authentification définis uniquement dans l’environnement. Les instantanés peuvent contenir les connexions OpenCode enregistrées
et les données de conversation, mais ils ne conservent pas les processus en cours d’exécution.

Relancez la vérification du fichier pour confirmer que le fichier `sandbox-proof.txt` a bien été conservé. Poursuivez avec
`cws-agent run` ou la commande de connexion interactive. Une fois terminé, arrêtez le sandbox restauré
avec `cws-agent down`.

<h2 id="troubleshoot">
  Dépannage
</h2>

Si la configuration ou une tâche échoue, effectuez les vérifications suivantes :

* Échec de l’authentification à la sandbox : vérifiez votre jeton d’accès à l’API CoreWeave et
  votre accès à la sandbox.
* Échec des requêtes vers les modèles Forge : vérifiez votre accès à l’inférence, vos crédits et l’ID du
  modèle. L’accès à la sandbox ne suffit pas à lui seul à obtenir l’accès à l’inférence.
* Un autre fournisseur n’est pas disponible : démarrez une nouvelle session sans `--wandb`.
  Le préréglage Forge est enregistré dans le Workspace : l’omission de `--wandb` lors de la restauration
  ne le supprime donc pas. Pour un Workspace existant, voir
  [Configuration du préréglage Forge](https://github.com/coreweave/cws-agent/blob/main/docs/opencode.md#resume-and-restore).
* Une tâche en mode headless nécessite une approbation : connectez-vous de manière interactive et répondez aux
  invites d’approbation d’OpenCode avant de continuer.

<h2 id="next-steps">
  Étapes suivantes
</h2>

Pour plus d'informations, consultez les guides suivants :

* [Exécuter des agents dans les bacs à sable CoreWeave](/fr/products/sandboxes/agents) présente les modèles
  d'exécution des agents et la durée de vie des Workspaces.
* [Configuration d'OpenCode](https://opencode.ai/docs/config/) détaille les paramètres de modèle,
  de fournisseur et de projet.
* [Utiliser le SDK Sandboxes](/fr/products/sandboxes/client/guides/execution) explique comment
  gérer l'exécution des commandes directement depuis votre application.