> ## 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 des sandboxs de longue durée

> Configurez des durées de vie de sandbox allant jusqu’à 30 jours avec un placement sans serveur ou CKS.

Les sandboxs CoreWeave peuvent s’exécuter jusqu’à 30 jours (2 592 000 secondes), avec un placement sans serveur ou CoreWeave Kubernetes Service (CKS). Définissez la durée de vie lors de la création du sandbox afin de laisser à un agent, à un environnement de développement ou à une charge de travail par lots le temps nécessaire pour se terminer.

Ce guide explique aux développeurs comment demander une durée de vie plus longue, et aux administrateurs comment définir une valeur par défaut pour les sandboxs d’un exécuteur CKS.

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

Effectuez la [configuration de la sandbox](/fr/products/sandboxes/get-started#coreweave-api-access-token), installez le client Python, puis définissez votre jeton d’accès à l’API CoreWeave :

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

Pour un placement CKS, suivez également la procédure [Utiliser votre propre capacité de calcul](/fr/products/sandboxes/get-started-cks). Dans l’exemple CKS, remplacez `[RUNNER-ID]` par l’ID de l’exécuteur que vous avez configuré. Pour un placement sans serveur avec une clé API Forge, utilisez la configuration d’authentification explicite décrite dans [Premiers pas](/fr/products/sandboxes/get-started#forge-api-key).

<h2 id="choose-a-lifetime">
  Choisir une durée de vie
</h2>

La durée de vie fixe la durée d’exécution maximale de la sandbox. La plateforme y met fin à l’expiration de la durée de vie, même si des tâches sont encore en cours. La sandbox peut s’arrêter plus tôt si la charge de travail se termine ou si vous l’arrêtez vous-même.

| Paramètre | Sans serveur | CKS |
| - | - | - |
| Durée de vie par sandbox | Définissez-la dans le kit de développement logiciel (SDK) ou dans la requête de création de sandbox. | Définissez-la dans le SDK ou dans la requête de création de sandbox. |
| Valeur par défaut de la politique de l’exécuteur | Gérée par CoreWeave. | Un administrateur peut définir `constraints.lifecycle.default_lifetime_seconds` dans la politique de l’exécuteur. |
| Durée de vie maximale | 30 jours. | 30 jours, y compris sur votre propre cluster. |

Une durée de vie explicite prévaut sur la valeur par défaut de la politique de l’exécuteur. Si vous ne précisez pas de durée de vie, la plateforme applique la valeur par défaut de la politique concernée. Si aucune valeur par défaut positive n’est définie, la plateforme applique une durée de 10 minutes (600 secondes). Pour les tâches de longue durée, définissez explicitement la durée de vie plutôt que de vous fier à une valeur par défaut.

La plateforme rejette les requêtes supérieures à 30 jours. La valeur `0` ne signifie pas une durée d’exécution illimitée. Une politique CKS ne peut pas relever le maximum de la plateforme.

Vous ne pouvez pas prolonger la durée de vie une fois la sandbox démarrée. Prévoyez une durée suffisante lors de la création et pensez à enregistrer votre travail avant l’échéance.

<h2 id="set-the-lifetime-when-creating-a-sandbox">
  Définir la durée de vie lors de la création d’une sandbox
</h2>

En Python, utilisez `max_lifetime_seconds`. Les exemples suivants demandent la durée maximale de 30 jours et affichent l’ID de la sandbox pour que vous puissiez vous y reconnecter plus tard. Choisissez l’onglet correspondant à votre mode de placement :

<Tabs>
  <Tab title="Sans serveur">
    ```python title="Créer une sandbox sans serveur" theme={"system"}
    from cwsandbox import AuthStrategy, Sandbox

    sandbox = Sandbox.run(
        "sleep", "infinity",
        auth=AuthStrategy.COREWEAVE_API_KEY,
        placement_mode="serverless",
        container_image="python:3.11",
        resources={"cpu": "2", "memory": "4Gi"},
        max_lifetime_seconds=30 * 24 * 60 * 60,
    )
    sandbox.wait()
    print(sandbox.sandbox_id)
    ```
  </Tab>

  <Tab title="CKS">
    ```python title="Créer une sandbox sur un exécuteur CKS" theme={"system"}
    from cwsandbox import AuthStrategy, Sandbox

    sandbox = Sandbox.run(
        "sleep", "infinity",
        auth=AuthStrategy.COREWEAVE_API_KEY,
        placement_mode="cks",
        runner_ids=["[RUNNER-ID]"],
        container_image="python:3.11",
        resources={"cpu": "2", "memory": "4Gi"},
        max_lifetime_seconds=30 * 24 * 60 * 60,
    )
    sandbox.wait()
    print(sandbox.sandbox_id)
    ```
  </Tab>
</Tabs>

Le script affiche l’ID de la sandbox. Dans ces exemples, `sleep infinity` maintient le processus principal actif, et la sandbox continue de s’exécuter une fois le script terminé. Arrêtez la sandbox lorsque vous n’en avez plus besoin.

La même durée de vie peut être définie depuis les autres interfaces client :

| Interface | Configuration de la durée de vie |
| - | - |
| SDK Python | `Sandbox.run(max_lifetime_seconds=2592000, ...)`. Pour définir des valeurs par défaut partagées au niveau du client, utilisez `SandboxDefaults(max_lifetime_seconds=2592000)`. Un argument explicite remplace la valeur par défaut du client. |
| SDK TypeScript | Passez `maxLifetimeSeconds: 2592000` dans les options de `client.run()`. |
| API REST | Définissez `spec.maxLifetimeSeconds` sur `2592000` dans le corps JSON de `POST /v1/sandboxes`. |
| Importation d’un fichier Compose | Définissez le champ de premier niveau `maxLifetimeSeconds` de la requête sur `2592000` dans `POST /v1/sandboxes:createFromFile`. La durée de vie est un paramètre de la requête, et non une propriété de service Compose. |

Pour connaître les formats de requête complets, consultez la [Référence de l’API](/fr/products/sandboxes/reference/control-plane-api) et [Créer une sandbox à partir d’un fichier Compose](/fr/products/sandboxes/create-from-file). Pour les valeurs par défaut du client Python, consultez [Configuration du sandbox](/fr/products/sandboxes/client/guides/sandbox-configuration#max_lifetime_seconds).

<h2 id="set-a-default-for-a-cks-runner">
  Définir une valeur par défaut pour un exécuteur CKS
</h2>

Une valeur par défaut définie dans la politique de l’exécuteur s’applique aux nouveaux sandboxs qui ne demandent pas leur propre durée de vie. Utilisez-la lorsque les charges de travail d’un exécuteur CKS doivent, en règle générale, bénéficier d’une durée de vie plus longue. Pour modifier la politique, vous devez disposer de l’action `SANDBOX_ADMIN` de la Gestion des identités et des accès (IAM).

Toute mise à jour de politique remplace l’intégralité du document de politique. Ne soumettez pas l’extrait ci-dessous en remplacement d’une politique existante : cela supprimerait ses autres contraintes.

1. Dans un terminal interactif, ouvrez la politique actuelle de l’exécuteur avec le [CoreWeave Intelligent CLI](https://github.com/coreweave/cwic) authentifié :

   ```bash theme={"system"}
   cwic sandbox runner policy edit [RUNNER-ID]
   ```

2. Définissez `constraints.lifecycle.default_lifetime_seconds` sur le nombre de secondes souhaité. L’extrait YAML suivant illustre une valeur par défaut de 30 jours. Conservez le reste de la politique existante :

   ```yaml title="Runner policy excerpt" theme={"system"}
   constraints:
     lifecycle:
       default_lifetime_seconds: 2592000
   ```

3. Enregistrez et fermez l’éditeur pour soumettre la mise à jour. Récupérez ensuite la politique pour vérifier la valeur :

   ```bash theme={"system"}
   cwic sandbox runner policy get [RUNNER-ID]
   ```

Vous pouvez également mettre à jour la politique via l’API REST des exécuteurs managés. En JSON, le champ correspondant est `policy.constraints.lifecycle.defaultLifetimeSeconds`. Consultez [Mettre à jour une politique](/fr/products/sandboxes/profiles/configure#update-a-policy) pour la procédure complète de lecture, de modification et de remplacement.

La valeur par défaut s’applique aux sandboxs créés après la mise à jour. Elle ne prolonge pas les sandboxs déjà en cours d’exécution. Un sandbox peut demander explicitement une durée de vie différente, dans la limite de 30 jours. N’ajoutez pas `max_lifetime_seconds` à la politique : ce champ a été retiré, et CoreWeave Intelligent CLI rejette tout document de politique qui le contient encore. La politique fournit une valeur par défaut, tandis que la plateforme impose le maximum.

<h2 id="keep-working-across-client-sessions">
  Poursuivre le travail d’une session client à l’autre
</h2>

Lorsqu’une sandbox doit survivre au script Python qui la lance, créez une sandbox autonome, comme dans les exemples précédents. Un contexte `with Sandbox.run(...)` arrête la sandbox à la sortie du bloc, même si sa durée de vie configurée est de 30 jours. Une `Session` gère également le nettoyage des sandboxs dont elle est propriétaire. Voir [Modèles de nettoyage](/fr/products/sandboxes/client/guides/cleanup-patterns).

Pour vous reconnecter depuis un autre script, remplacez `[SANDBOX-ID]` par l’ID affiché lors de la création. Utilisez le même identifiant d’authentification que celui employé pour créer la sandbox. Ces exemples utilisent le jeton d’accès à l’API CoreWeave obtenu lors de la configuration :

```python title="Reconnect to a running sandbox" theme={"system"}
from cwsandbox import AuthStrategy, Sandbox

sandbox = Sandbox.from_id(
    "[SANDBOX-ID]",
    auth=AuthStrategy.COREWEAVE_API_KEY,
).result()
result = sandbox.exec(["echo", "Connected"]).result()
print(result.stdout)
```

La commande affiche `Connected`. Une reconnexion ne réinitialise pas la durée de vie. Lorsque vous avez terminé, arrêtez explicitement la sandbox :

```python title="Stop a sandbox" theme={"system"}
from cwsandbox import AuthStrategy, Sandbox

sandbox = Sandbox.from_id(
    "[SANDBOX-ID]",
    auth=AuthStrategy.COREWEAVE_API_KEY,
).result()
sandbox.stop().result()
```

<h2 id="plan-for-expiry">
  Anticiper l’expiration
</h2>

Enregistrez les résultats ou les points de contrôle en dehors du sandbox avant la fin de sa durée de vie. Si un flux de travail nécessite plus de 30 jours, créez un sandbox de remplacement et reprenez à partir de l’état enregistré. Pour les options de stockage et d’instantané prises en charge, voir [Volumes de sandbox](/fr/products/sandboxes/volumes) et [Instantanés du système de fichiers](/fr/products/sandboxes/file-system-snapshots).

La durée de vie du sandbox est indépendante du délai d’expiration d’une commande ou d’une requête API. Augmenter `timeout_seconds` ou `request_timeout_seconds` ne prolonge pas la durée de vie du sandbox. Pour les différences, voir [Délais d’expiration](/fr/products/sandboxes/client/guides/sandbox-configuration#timeouts).