Utiliser les secrets W&B - CoreWeave Docs

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.

Avant de commencer

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

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 :

export WANDB_ENTITY="[WANDB-TEAM]"

Installez le client correspondant à votre langage :

Python
TypeScript

Utilisez Python 3.11 ou une version ultérieure et, si nécessaire, installez uv. Dans votre environnement Python, installez le client avec sa dépendance d’authentification W&B :

uv pip install 'cwsandbox[wandb]'

Utilisez Node.js 22 ou une version ultérieure. Installez le client TypeScript ainsi que tsx pour exécuter les exemples :

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.

Injecter un secret

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.

Python
TypeScript

Sélectionnez explicitement l’authentification W&B avec AuthStrategy.WANDB :

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)

Importez le client depuis le point d’entrée W&B. Si vous omettez runnerIds, le client utilise le placement serverless :

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);

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.

Champs de référence de secret

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

Utiliser un nom de variable d’environnement personnalisé

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 :

Python
TypeScript

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)

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);

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

Sélectionner un champ d’un secret structuré

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 :

Python
TypeScript

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)

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);

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.

Réutiliser les références de secrets

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 :

Python
TypeScript

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.

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);

Résoudre les problèmes d’injection de secrets

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.

​Avant de commencer

​Injecter un secret

​Champs de référence de secret

​Utiliser un nom de variable d’environnement personnalisé

​Sélectionner un champ d’un secret structuré

​Réutiliser les références de secrets

​Résoudre les problèmes d’injection de secrets