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

# Utiliser les secrets W&B

> Injectez les secrets d’équipe W&B dans des sandboxes serverless avec Python ou TypeScript.

Utilisez W\&B Secret Manager pour mettre des jetons d’API et d’autres identifiants d’authentification à disposition dans une sandbox serverless. Votre application transmet des noms de secrets à l’API Sandbox. Lorsque l’API crée la sandbox, elle résout les valeurs correspondantes à partir de votre équipe W\&B et les injecte sous forme de variables d’environnement.

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

L’injection de secrets W\&B nécessite une sandbox authentifiée avec une clé API W\&B. Elle est disponible pour les sandboxes serverless, mais pas pour les sandboxes exécutées sur votre propre cluster CoreWeave Kubernetes Service (CKS). Le placement sur CKS utilise un jeton d’accès à l’API CoreWeave. Vous ne pouvez pas combiner ce jeton avec une clé W\&B distincte pour résoudre les secrets d’une sandbox CKS.

| Placement de la sandbox | Identifiant d’authentification de la sandbox | Injection de secrets W\&B |
| - | - | - |
| Serverless | Clé API W\&B | Prise en charge. Utilisez le magasin `wandb`. |
| Serverless | Jeton d’accès à l’API CoreWeave | Non prise en charge. |
| Votre cluster CKS | Jeton d’accès à l’API CoreWeave | Non prise en charge. L’ajout de `WANDB_API_KEY` ne suffit pas à l’activer. |

Pour suivre les exemples, vous devez disposer des éléments suivants :

* Un compte W\&B SaaS (software-as-a-service) avec un [accès aux sandboxes serverless](/fr/products/sandboxes/serverless/get-started).
* Un secret nommé `HF_TOKEN` dans le Secret Manager de votre équipe W\&B. Si ce secret n’existe pas, demandez à un administrateur W\&B de l’[ajouter](/fr/products/wandb/platform/secrets#add-a-secret).
* Une clé API W\&B ayant accès à cette équipe.

Définissez `WANDB_API_KEY` dans l’environnement du processus qui crée la sandbox. Remplacez `[WANDB-API-KEY]` par votre clé API W\&B :

```bash theme={"system"}
export WANDB_API_KEY="[WANDB-API-KEY]"
```

`WANDB_ENTITY` est facultatif et correspond par défaut à l'entity par défaut de la clé API. Si le secret appartient à une autre équipe, définissez `WANDB_ENTITY` sur cette équipe. Remplacez `[WANDB-TEAM]` par le nom de l'équipe :

```bash theme={"system"}
export WANDB_ENTITY="[WANDB-TEAM]"
```

Installez le client correspondant à votre langage :

<Tabs>
  <Tab title="Python">
    Utilisez Python 3.11 ou une version ultérieure et, si nécessaire, [installez `uv`](https://docs.astral.sh/uv/getting-started/installation/). Dans votre environnement Python, installez le client avec sa dépendance d’authentification W\&B :

    ```bash theme={"system"}
    uv pip install 'cwsandbox[wandb]'
    ```
  </Tab>

  <Tab title="TypeScript">
    Utilisez Node.js 22 ou une version ultérieure. Installez le client TypeScript ainsi que `tsx` pour exécuter les exemples :

    ```bash theme={"system"}
    npm install @coreweave/cwsandbox
    npm install --save-dev tsx
    ```

    Enregistrez l’exemple TypeScript à exécuter sous le nom `secrets.mts`, puis lancez `npx tsx secrets.mts`.
  </Tab>
</Tabs>

<h2 id="inject-a-secret">
  Injecter un secret
</h2>

Utilisez `store="wandb"` en Python ou `store: "wandb"` en TypeScript. Ce magasin résout les secrets pour l’équipe W\&B authentifiée. Vous n’avez pas besoin d’enregistrer de magasin de secrets d’organisation pour ce flux.

Les exemples suivants injectent `HF_TOKEN` et vérifient sa présence sans afficher sa valeur. Dans le sandbox, la variable d’environnement porte par défaut le nom du secret.

<Tabs>
  <Tab title="Python">
    Sélectionnez explicitement l’authentification W\&B avec `AuthStrategy.WANDB` :

    ```python theme={"system"}
    from cwsandbox import AuthStrategy, Sandbox, Secret

    with Sandbox.run(
      auth=AuthStrategy.WANDB,
      placement_mode="serverless",
      container_image="python:3.11",
      resources={"cpu": "1", "memory": "1Gi"},
      secrets=[Secret(store="wandb", name="HF_TOKEN")],
    ) as sandbox:
      result = sandbox.exec([
        "python", "-c",
        "import os; assert os.environ.get('HF_TOKEN'); print('Secret is available')",
      ]).result()
      print(result.stdout)
    ```
  </Tab>

  <Tab title="TypeScript">
    Importez le client depuis le point d’entrée W\&B. Si vous omettez `runnerIds`, le client utilise le placement serverless :

    ```typescript theme={"system"}
    import { createSandboxClientFromEnv } from "@coreweave/cwsandbox/wandb";

    const client = createSandboxClientFromEnv();

    const result = await client.withSandbox(
      async (sandbox) => sandbox.commands.run([
        "python", "-c",
        "import os; assert os.environ.get('HF_TOKEN'); print('Secret is available')",
      ]),
      {
        containerImage: "python:3.11",
        resources: { cpu: "1", memory: "1Gi" },
        secrets: [{ store: "wandb", name: "HF_TOKEN" }],
      },
    );

    console.log(result.stdout);
    ```
  </Tab>
</Tabs>

Les deux exemples affichent `Secret is available` et arrêtent le sandbox une fois l’opération terminée. Le code exécuté dans le sandbox peut lire la valeur depuis `HF_TOKEN`.

Dans `secrets`, transmettez le nom du secret, et non sa valeur. C’est le serveur qui résout la valeur. Ne l’affichez pas et ne l’écrivez pas dans les journaux.

<h2 id="secret-reference-fields">
  Champs de référence de secret
</h2>

Utilisez ces champs dans un `Secret` Python ou dans une entrée `secrets` TypeScript :

| Champ Python | Champ TypeScript | Requis | Description |
| - | - | - | - |
| `store` | `store` | Oui | Nom du magasin de secrets. Utilisez `wandb` pour W\&B Secret Manager. |
| `name` | `name` | Oui | Nom du secret dans le Secret Manager de l’équipe W\&B sélectionnée. |
| `field` | `field` | Non | Clé de premier niveau à sélectionner dans un secret dont la valeur est un objet JSON. Omettez ce champ pour injecter la totalité de la valeur du secret. |
| `env_var` | `envVar` | Non | Variable d’environnement qui reçoit la valeur. Par défaut : `name`. |

<h2 id="use-a-custom-environment-variable-name">
  Utiliser un nom de variable d’environnement personnalisé
</h2>

Pour choisir la variable d’environnement qui reçoit le secret, définissez `env_var` en Python ou `envVar` en TypeScript. Les exemples suivants exposent le secret `HF_TOKEN` sous le nom `HUGGINGFACE_TOKEN` :

<Tabs>
  <Tab title="Python">
    ```python theme={"system"}
    from cwsandbox import AuthStrategy, Sandbox, Secret

    with Sandbox.run(
      auth=AuthStrategy.WANDB,
      placement_mode="serverless",
      container_image="python:3.11",
      secrets=[Secret(
        store="wandb",
        name="HF_TOKEN",
        env_var="HUGGINGFACE_TOKEN",
      )],
    ) as sandbox:
      result = sandbox.exec([
        "python", "-c",
        "import os; assert os.environ.get('HUGGINGFACE_TOKEN'); print('Secret is available')",
      ]).result()
      print(result.stdout)
    ```
  </Tab>

  <Tab title="TypeScript">
    ```typescript theme={"system"}
    import { createSandboxClientFromEnv } from "@coreweave/cwsandbox/wandb";

    const client = createSandboxClientFromEnv();

    const result = await client.withSandbox(
      async (sandbox) => sandbox.commands.run([
        "python", "-c",
        "import os; assert os.environ.get('HUGGINGFACE_TOKEN'); print('Secret is available')",
      ]),
      {
        containerImage: "python:3.11",
        secrets: [{
          store: "wandb",
          name: "HF_TOKEN",
          envVar: "HUGGINGFACE_TOKEN",
        }],
      },
    );

    console.log(result.stdout);
    ```
  </Tab>
</Tabs>

Les deux exemples affichent `Secret is available` après avoir vérifié la présence de `HUGGINGFACE_TOKEN`.

<h2 id="select-a-field-from-a-structured-secret">
  Sélectionner un champ d’un secret structuré
</h2>

Pour injecter une seule valeur d’un objet JSON, définissez `field` sur sa clé de premier niveau. Les chemins imbriqués ne sont pas pris en charge. Si la valeur est une chaîne JSON, elle est injectée sans les guillemets JSON qui l’entourent.

Pour cet exemple, ajoutez un secret d’équipe nommé `DB_CREDENTIALS` dont la valeur est un objet JSON tel que `{"password":"[DB-PASSWORD]"}`. Remplacez `[DB-PASSWORD]` par le mot de passe avant d’enregistrer le secret. Les exemples injectent son champ `password` dans `DB_PASSWORD` :

<Tabs>
  <Tab title="Python">
    ```python theme={"system"}
    from cwsandbox import AuthStrategy, Sandbox, Secret

    with Sandbox.run(
      auth=AuthStrategy.WANDB,
      placement_mode="serverless",
      container_image="python:3.11",
      secrets=[Secret(
        store="wandb",
        name="DB_CREDENTIALS",
        field="password",
        env_var="DB_PASSWORD",
      )],
    ) as sandbox:
      result = sandbox.exec([
        "python", "-c",
        "import os; assert os.environ.get('DB_PASSWORD'); print('Secret is available')",
      ]).result()
      print(result.stdout)
    ```
  </Tab>

  <Tab title="TypeScript">
    ```typescript theme={"system"}
    import { createSandboxClientFromEnv } from "@coreweave/cwsandbox/wandb";

    const client = createSandboxClientFromEnv();

    const result = await client.withSandbox(
      async (sandbox) => sandbox.commands.run([
        "python", "-c",
        "import os; assert os.environ.get('DB_PASSWORD'); print('Secret is available')",
      ]),
      {
        containerImage: "python:3.11",
        secrets: [{
          store: "wandb",
          name: "DB_CREDENTIALS",
          field: "password",
          envVar: "DB_PASSWORD",
        }],
      },
    );

    console.log(result.stdout);
    ```
  </Tab>
</Tabs>

Les deux exemples affichent `Secret is available` sans révéler le mot de passe. La sélection d’un champ échoue si le secret n’est pas un objet JSON, si la clé n’existe pas ou si sa valeur est `null`.

<h2 id="reuse-secret-references">
  Réutiliser les références de secrets
</h2>

Pour les sessions Python, placez les références de secrets partagées dans `SandboxDefaults`. En TypeScript, réutilisez un même tableau `secrets` lorsque vous créez des sandboxes :

<Tabs>
  <Tab title="Python">
    ```python theme={"system"}
    from cwsandbox import AuthStrategy, SandboxDefaults, Secret, Session

    defaults = SandboxDefaults(
      auth=AuthStrategy.WANDB,
      placement_mode="serverless",
      secrets=(Secret(store="wandb", name="HF_TOKEN"),),
    )

    with Session(defaults) as session:
      sandbox = session.sandbox()
      result = sandbox.exec([
        "python", "-c",
        "import os; assert os.environ.get('HF_TOKEN'); print('Secret is available')",
      ]).result()
      print(result.stdout)
    ```

    Le client Python fusionne les valeurs par défaut de la session avec les `secrets` propres à chaque sandbox, en ignorant les doublons exacts. Si des références différentes ciblent la même variable d’environnement, le client lève une `ValueError` avant de créer la sandbox. Pour la signature de type Python, consultez la [référence Secret](/products/sandboxes/client/ref/configuration/secret).
  </Tab>

  <Tab title="TypeScript">
    ```typescript theme={"system"}
    import { createSandboxClientFromEnv } from "@coreweave/cwsandbox/wandb";

    const client = createSandboxClientFromEnv();
    const secrets = [{ store: "wandb", name: "HF_TOKEN" }];

    const result = await client.withSandbox(
      async (sandbox) => sandbox.commands.run([
        "python", "-c",
        "import os; assert os.environ.get('HF_TOKEN'); print('Secret is available')",
      ]),
      { containerImage: "python:3.11", secrets },
    );

    console.log(result.stdout);
    ```
  </Tab>
</Tabs>

<h2 id="troubleshoot-secret-injection">
  Résoudre les problèmes d’injection de secrets
</h2>

Si le sandbox ne parvient pas à démarrer avec une référence de secret, servez-vous du texte de l’erreur pour vérifier l’authentification, l’équipe sélectionnée et le placement :

| Texte de l’erreur | Éléments à vérifier |
| - | - |
| `secret store "wandb" not found` | Vérifiez si le client a sélectionné l’authentification CoreWeave. Pour un placement serverless, sélectionnez `auth=AuthStrategy.WANDB` en Python ou le point d’entrée `@coreweave/cwsandbox/wandb` en TypeScript. La seule définition de `WANDB_API_KEY` ne suffit pas à faire basculer vers W\&B un client authentifié auprès de CoreWeave. Il n’est pas nécessaire d’enregistrer un magasin de secrets. |
| `one or more W&B secrets not found` | Vérifiez le nom du secret et l’équipe W\&B sélectionnée. Définissez `WANDB_ENTITY` si le secret appartient à une autre équipe que l’entity par défaut de la clé API, et vérifiez que votre compte W\&B peut y accéder. |
| `entity not found` | Vérifiez que `WANDB_ENTITY` ne contient pas de faute de frappe, que l’équipe existe et que votre compte W\&B peut y accéder. |
| `no eligible runner is available on this replica right now; retry shortly` | Si vous avez sélectionné un runner CKS avec l’authentification W\&B, cette combinaison n’est pas prise en charge et une nouvelle tentative n’y changera rien. Pour l’injection de secrets, utilisez l’authentification W\&B avec un placement serverless. Dans le cas d’une requête serverless, cette erreur peut signaler une indisponibilité temporaire des runners. |

L’injection de secrets W\&B n’est pas disponible pour le placement CKS, même si vous définissez à la fois un jeton d’accès à l’API CoreWeave et une clé API W\&B.