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

# Variables d’environnement

> Définir et gérer les variables d’environnement dans les instances CWSandbox, y compris les valeurs par défaut au niveau de la session

Ces exemples utilisent un jeton d’accès à l’API CoreWeave défini dans `CWSANDBOX_API_KEY`. Pour l’authentification par clé API Forge, voir [Premiers pas](/fr/products/sandboxes/get-started). Pour les exigences propres à CKS, voir [Modes de placement](/fr/products/sandboxes/placement).

Ce guide vous explique comment définir et gérer les variables d’environnement dans les instances CWSandbox. Les variables d’environnement permettent de transmettre à vos sandboxes des valeurs de configuration non sensibles, comme des niveaux de journalisation ou des identifiants de projet. Vous pouvez les définir sur un sandbox donné, les partager entre les sandboxes d’une même session ou limiter leur portée à des fonctions distantes.

<Warning>
  Ne codez pas en dur de clés API, de mots de passe ni d’autres identifiants d’authentification dans `environment_variables`, et ne les écrivez pas dans les journaux. Privilégiez les références de secret plutôt que la transmission d’identifiants d’authentification en clair. Conservez les valeurs sensibles dans un gestionnaire de secrets, même lorsque l’injection de secrets Forge n’est pas disponible. Ces recommandations s’appliquent aussi bien aux sandboxes sans serveur qu’aux sandboxes CKS.
</Warning>

Pour les sandboxes sans serveur authentifiés avec Forge, utilisez les [secrets Forge](/fr/products/sandboxes/secrets). Le serveur résout ces références et injecte les valeurs sous forme de variables d’environnement. L’injection de secrets Forge n’est disponible ni pour le placement CKS ni pour les sandboxes authentifiés avec un jeton d’accès à l’API CoreWeave. Pour CKS, utilisez la méthode approuvée par votre organisation pour transmettre des secrets aux charges de travail.

<h2 id="basic-usage">
  Utilisation de base
</h2>

Pour rendre des valeurs disponibles aux processus exécutés dans la sandbox, transmettez un dictionnaire `environment_variables` à `Sandbox.run` :

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

with Sandbox.run(
    environment_variables={"LOG_LEVEL": "info"},
) as sandbox:
    result = sandbox.exec([
        "python",
        "-c",
        "import os; print(os.environ.get('LOG_LEVEL'));",
    ]).result()
    print(result.stdout.strip())  # "info"
```

<h2 id="session-level-defaults">
  Valeurs par défaut au niveau de la session
</h2>

Lorsque vous avez besoin des mêmes variables dans plusieurs sandboxes, définissez-les une seule fois dans une session plutôt que de les répéter pour chaque sandbox. Chaque sandbox peut remplacer les valeurs par défaut de la session ou ajouter ses propres variables :

```python theme={"system"}
from cwsandbox import SandboxDefaults, Session

defaults = SandboxDefaults(
    environment_variables={
        "PROJECT_ID": "my-project",
        "LOG_LEVEL": "info",
    },
)

with Session(defaults) as session:
    with session.sandbox() as sb1:
        result = sb1.exec([
            "python",
            "-c",
            "import os; print(os.environ.get('LOG_LEVEL'));",
        ]).result()
        print(result.stdout.strip())  # "info"

    # Remplacer LOG_LEVEL et ajouter une nouvelle variable
    with session.sandbox(
        environment_variables={
            "LOG_LEVEL": "debug",  # Remplacer la valeur par défaut de la session
            "MODEL_NAME": "gpt-4",  # Ajouter une nouvelle variable
        }
    ) as sb2:
        result = sb2.exec([
            "python",
            "-c",
            "import os; "
            "print(os.environ.get('PROJECT_ID')); "
            "print(os.environ.get('LOG_LEVEL')); "
            "print(os.environ.get('MODEL_NAME'));",
        ]).result()
        lines = result.stdout.strip().split("\n")
        print(lines)  # ["my-project", "debug", "gpt-4"]
```

<h2 id="remote-functions">
  Fonctions distantes
</h2>

Les fonctions distantes héritent des variables d’environnement de la session et peuvent déclarer les leurs à l’aide du décorateur `@session.function`. Au moment de l’appel, le SDK fusionne les variables définies au niveau de la fonction avec les valeurs par défaut de la session :

```python theme={"system"}
with Session(defaults) as session:
    @session.function(environment_variables={"MODEL_VERSION": "v2.0"})
    def process(task_id: int) -> dict:
        import os
        return {
            "task": task_id,
            "project": os.environ.get("PROJECT_ID"),  # Provient des valeurs par défaut de la session
            "version": os.environ.get("MODEL_VERSION"),  # Provient du décorateur de fonction
        }

    result = process.remote(42).result()
    print(result)  # {"task": 42, "project": "my-project", "version": "v2.0"}
```

<Warning>
  Les variables d’environnement sont transmises par référence. Les appels de fonctions ultérieurs tiennent compte des modifications apportées au dictionnaire après l’application du décorateur, comme le montre l’exemple suivant.
</Warning>

```python theme={"system"}
env_vars = {"MODEL_VERSION": "v2.0"}

@session.function(environment_variables=env_vars)
def process(task_id: int) -> dict:
    import os
    return {"version": os.environ.get("MODEL_VERSION")}

result = process.remote(42).result()  # version : "v2.0"

env_vars["MODEL_VERSION"] = "v3.0"  # Modification du dictionnaire

result = process.remote(42).result()  # version : "v3.0" (modifiée)
```