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

# Premiers pas avec CoreWeave Sandboxes

> Exécutez votre première sandbox sur une capacité sans serveur avec une clé API Forge ou un jeton d’accès à l’API CoreWeave.

Exécutez une commande dans une sandbox sur une capacité sans serveur, puis affichez sa sortie. Aucune configuration de cluster n’est nécessaire.

<h2 id="before-you-begin">
  Avant de commencer
</h2>

Les sandboxes sans serveur sont en disponibilité générale, et leur utilisation est facturée. L’accès est activé pour chaque organisation. Pour demander l’accès pour votre organisation, contactez l’[assistance](mailto:forge-support@coreweave.com).

Si votre organisation utilise le Cloud dédié Forge, consultez [Utiliser les sandboxes avec le Cloud dédié Forge](/fr/products/sandboxes/dedicated-cloud).

<h2 id="run-your-first-sandbox">
  Exécuter votre premier sandbox
</h2>

<span id="choose-a-credential" />

<span id="run-a-sandbox-on-serverless-capacity" />

Choisissez l’identifiant d’authentification du compte qui possède votre sandbox et auquel celui-ci est facturé. Une clé API Forge prend en charge le placement sans serveur. Un jeton d’accès à l’API CoreWeave prend en charge le placement sans serveur et sur CoreWeave Kubernetes Service (CKS). Pour connaître les exigences relatives au compte, consultez [Choisir et obtenir des identifiants d’authentification](/fr/products/sandboxes/placement#choose-and-get-credentials). Suivez la section qui correspond à votre identifiant d’authentification, puis [vérifiez le résultat](#verify-the-result).

<h3 id="forge-api-key">
  Clé API Forge
</h3>

Obtenez votre [clé API Forge](https://forge.coreweave.com/settings#apikeys). Si vous n'avez pas de compte, inscrivez-vous via ce même lien. Définissez ensuite la clé dans votre terminal. Les exemples lisent explicitement `FORGE_API_KEY` ; le SDK ne détecte pas cette variable automatiquement :

```bash theme={"system"}
export FORGE_API_KEY="[FORGE-API-KEY]"
```

<Tabs>
  <Tab title="Python">
    Une fois [`uv`](https://docs.astral.sh/uv/getting-started/installation/) installé, enregistrez ce code sous le nom `hello.py` :

    ```python title="hello.py" theme={"system"}
    import os
    from cwsandbox import AuthHeaders, Sandbox

    forge_auth = AuthHeaders(
        headers={"x-wandb-api-key": os.environ["FORGE_API_KEY"]},
        strategy="wandb_api_key",
    )

    with Sandbox.run(
        auth=forge_auth,
        resources={"cpu": "1", "memory": "1Gi"},
    ) as sandbox:
        print(sandbox.exec(["echo", "Hello!"]).result().stdout)
    ```

    Exécutez-le avec Python 3.11 et le client sandbox, que la commande installe au besoin :

    ```bash theme={"system"}
    uv run --python 3.11 --with 'cwsandbox>=1.14.2' hello.py
    ```
  </Tab>

  <Tab title="TypeScript">
    Une fois Node.js 22 (ou version ultérieure) installé, installez le client :

    ```bash theme={"system"}
    npm install @coreweave/cwsandbox
    ```

    Enregistrez ce code sous le nom `hello.mts` :

    ```typescript title="hello.mts" theme={"system"}
    import { createSandboxClient } from "@coreweave/cwsandbox/wandb";

    const client = createSandboxClient({
      apiKey: process.env.FORGE_API_KEY,
    });
    const result = await client.withSandbox(
      async (sandbox) => sandbox.commands.run(["echo", "Hello!"]),
      { resources: { cpu: "1", memory: "1Gi" } },
    );
    console.log(result.stdout);
    ```

    Exécutez-le avec `tsx` :

    ```bash theme={"system"}
    npx --yes --package=tsx tsx hello.mts
    ```
  </Tab>
</Tabs>

L’en-tête `x-wandb-api-key`, l’identifiant de stratégie `wandb_api_key` et le point d’entrée TypeScript `/wandb` sont les identifiants actuels du SDK pour l’authentification Forge. Conservez-les tels quels.

<h3 id="coreweave-api-access-token">
  Jeton d’accès à l’API CoreWeave
</h3>

Demandez à votre administrateur de créer ou de mettre à jour une [politique d’accès](https://console.coreweave.com/organization/iam/access-policies) qui vous attribue le rôle **Sandbox User**. Pour connaître la procédure, voir [Créer une politique d’accès](/security/iam/access-policies/manage#create-an-access-policy).

Créez un jeton d’accès à l’API sur la page [Tokens](https://console.coreweave.com/tokens), copiez son **Token Secret**, puis définissez-le dans votre terminal :

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

<Tabs>
  <Tab title="Python">
    Une fois [`uv`](https://docs.astral.sh/uv/getting-started/installation/) installé, enregistrez ce code dans `hello.py` :

    ```python title="hello.py" theme={"system"}
    from cwsandbox import AuthStrategy, Sandbox

    with Sandbox.run(
        auth=AuthStrategy.COREWEAVE_API_KEY,
        resources={"cpu": "1", "memory": "1Gi"},
    ) as sandbox:
        print(sandbox.exec(["echo", "Hello!"]).result().stdout)
    ```

    Exécutez-le avec Python 3.11 et le client sandbox, que la commande installe au besoin :

    ```bash theme={"system"}
    uv run --python 3.11 --with 'cwsandbox>=1.10.0' hello.py
    ```
  </Tab>

  <Tab title="TypeScript">
    Une fois Node.js 22 (ou version ultérieure) installé, installez le client :

    ```bash theme={"system"}
    npm install @coreweave/cwsandbox
    ```

    Enregistrez ce code dans `hello.mts` :

    ```typescript title="hello.mts" theme={"system"}
    import { createSandboxClientFromEnv } from "@coreweave/cwsandbox/node";

    const client = createSandboxClientFromEnv();
    const result = await client.withSandbox(
      async (sandbox) => sandbox.commands.run(["echo", "Hello!"]),
      { resources: { cpu: "1", memory: "1Gi" } },
    );
    console.log(result.stdout);
    ```

    Exécutez-le avec `tsx` :

    ```bash theme={"system"}
    npx --yes --package=tsx tsx hello.mts
    ```
  </Tab>
</Tabs>

<h3 id="verify-the-result">
  Vérifier le résultat
</h3>

L’exemple affiche la sortie suivante, puis arrête la sandbox une fois son exécution terminée :

```text title="Output" theme={"system"}
Hello!
```

Le sandbox dispose de 1 CPU et de 1 Gio de mémoire. En mode sans serveur, les limites de ressources sont égales aux demandes de ressources. Modifiez `resources` pour choisir son CPU et sa mémoire.

Pour en savoir plus sur les quotas de simultanéité, les limites de débit des requêtes de création et les erreurs de quota, voir [Limites et quotas](/fr/products/sandboxes/reference/limits-and-quotas).

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

<span id="choose-a-placement-mode" />

<span id="spill-over-between-modes" />

<span id="deploy-sandboxes-on-your-own-cks-cluster" />

Poursuivez avec le guide adapté à votre charge de travail :

* [Utiliser votre propre capacité de calcul](/fr/products/sandboxes/get-started-cks) : activez un exécuteur sur votre cluster et exécutez-y une sandbox.
* [Placement des sandboxes et débordement](/fr/products/sandboxes/placement) : comparez la capacité sans serveur et la capacité CKS, puis configurez le basculement.
* [Exécuter des agents de développement](/fr/products/sandboxes/agents) : connectez un agent de développement à une sandbox.
* [Sandboxes GPU](/fr/products/sandboxes/gpu-sandboxes) : demandez l’accès aux GPU et exécutez une charge de travail GPU.
* [Client Python](/fr/products/sandboxes/client) : exécutez des commandes, manipulez des fichiers et configurez des sandboxes.