> ## Documentation Index
> Fetch the complete documentation index at: https://novita.ai/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Pause et reprise automatiques

export const SandboxConfigHint = () => {
  if (typeof document === "undefined") {
    return null;
  } else {
    return <Note>Before running the example code in this document, please ensure you have properly configured environment variables. For details, please refer to <a href="/docs/fr/guides/sandbox-your-first-agent-sandbox#configure-environment-variables">Configure Environment Variables</a>.</Note>;
  }
};

Ces fonctionnalités s’appuient sur la [persistance des sandboxes](/docs/fr/guides/sandbox-persistence). La pause automatique conserve l’état de la sandbox lorsque la durée de vie maximale expire. La reprise automatique réveille une sandbox en pause lorsqu’une nouvelle activité arrive.

<SandboxConfigHint />

## Configurer

Lors de la création d’une sandbox, transmettez une configuration `lifecycle`. Cela contrôle le comportement du délai d’expiration et indique si une sandbox en pause peut se réveiller automatiquement.

<CodeGroup>
  ```js JavaScript & TypeScript icon="js" theme={"system"}
  import { Sandbox } from 'novita-sandbox'

  const sandbox = await Sandbox.create({
    timeoutMs: 10 * 60 * 1000,
    lifecycle: {
      onTimeout: 'pause',
      autoResume: true, // resume when activity arrives
    },
  })
  ```

  ```python Python icon="python" theme={"system"}
  from novita_sandbox.core import Sandbox

  sandbox = Sandbox.create(
      timeout=10 * 60,
      lifecycle={
          "on_timeout": "pause",
          "auto_resume": True,  # resume when activity arrives
      },
  )
  ```
</CodeGroup>

### Options de cycle de vie

Le paramètre `lifecycle` prend en charge ces champs :

| Paramètre                                  | Option    | Signification                                                                                                                                           |
| ------------------------------------------ | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `onTimeout` (JS) / `on_timeout` (Python)   | `"kill"`  | Comportement par défaut. La sandbox est supprimée après son délai d’expiration.                                                                         |
| `onTimeout` (JS) / `on_timeout` (Python)   | `"pause"` | La sandbox est mise en pause après le délai d’expiration au lieu d’être supprimée.                                                                      |
| `autoResume` (JS) / `auto_resume` (Python) | `false`   | Comportement par défaut. Les sandboxes en pause restent en pause jusqu’à une reprise manuelle.                                                          |
| `autoResume` (JS) / `auto_resume` (Python) | `true`    | Les sandboxes en pause redémarrent lorsqu’une activité prise en charge arrive. Cela nécessite que le comportement du délai d’expiration soit `"pause"`. |

Si la reprise automatique est désactivée ou omise, une sandbox en pause peut toujours être reprise manuellement avec `Sandbox.connect()`.

## Pause automatique

Par défaut, une sandbox est arrêtée lorsque son délai d’expiration arrive à échéance. Pour conserver l’état à la place, définissez `onTimeout` en JavaScript ou `on_timeout` en Python afin de mettre en pause à l’expiration.

<CodeGroup>
  ```js JavaScript & TypeScript icon="js" theme={"system"}
  import { Sandbox } from 'novita-sandbox/code-interpreter'

  const sandbox = await Sandbox.create({
    timeoutMs: 300_000,
    lifecycle: {
      onTimeout: 'pause',
      autoResume: false,
    },
  })

  await sandbox.kill()
  ```

  ```python Python icon="python" theme={"system"}
  from novita_sandbox.code_interpreter import Sandbox

  sandbox = Sandbox.create(
      timeout=300,
      lifecycle={
          "on_timeout": "pause",
          "auto_resume": False,
      },
  )

  sandbox.kill()
  ```
</CodeGroup>

## Reprise automatique

La reprise automatique peut réveiller une sandbox en pause lorsqu’une activité prise en charge arrive. Cela fonctionne uniquement lorsque la sandbox est configurée pour se mettre en pause à l’expiration.

### Délai d’expiration après une reprise automatique

Après une reprise automatique, la sandbox obtient un délai d’expiration d’au moins cinq minutes. Si le délai d’expiration initial était supérieur à cinq minutes, la valeur initiale plus longue est réutilisée.

Le minuteur du délai d’expiration démarre lorsque la sandbox reprend, et non lorsqu’elle a été créée initialement.

Exemple avec un délai d’expiration de deux minutes :

1. La sandbox s’exécute pendant deux minutes, puis se met en pause.
2. Une nouvelle activité atteint la sandbox, ce qui provoque sa reprise.
3. La sandbox reprise reçoit un délai d’expiration de cinq minutes, car il s’agit du minimum.
4. Si rien ne réinitialise le minuteur, la sandbox se remet en pause après cinq minutes.

Exemple avec un délai d’expiration d’une heure :

* La sandbox reprend avec un délai d’expiration d’une heure, car le délai initial est supérieur au minimum de cinq minutes.

Ce comportement se poursuit lors des futurs cycles de pause et de reprise, car les paramètres de cycle de vie restent attachés à la sandbox.

<Note>
  Vous pouvez mettre à jour le délai d’expiration après la reprise en utilisant `setTimeout()` en JavaScript ou `set_timeout()` en Python.
</Note>

### Ce qui compte comme activité

La reprise automatique peut être déclenchée par des actions SDK et du trafic HTTP.

Exemples pris en charge :

* `sandbox.commands.run(...)`
* `sandbox.files.read(...)`
* `sandbox.files.write(...)`
* Visiter l’URL d’une application exposée via tunnel
* Envoyer des requêtes à un service exécuté à l’intérieur de la sandbox

Lorsqu’une sandbox est en pause et que la reprise automatique est activée, l’action prise en charge suivante la reprend automatiquement. Vous n’avez pas besoin d’appeler `Sandbox.connect()` au préalable.

### Exemple SDK : mettre en pause, puis lire un fichier

Cet exemple crée une sandbox, écrit un fichier, met la sandbox en pause, puis lit le fichier. L’opération de lecture provoque la reprise de la sandbox.

<CodeGroup>
  ```js JavaScript & TypeScript icon="js" theme={"system"}
  import { Sandbox } from 'novita-sandbox'

  const sandbox = await Sandbox.create({
    timeoutMs: 10 * 60 * 1000,
    lifecycle: {
      onTimeout: 'pause',
      autoResume: true,
    },
  })

  await sandbox.files.write('/home/user/hello.txt', 'hello from a paused sandbox')
  await sandbox.pause()

  const content = await sandbox.files.read('/home/user/hello.txt')
  console.log(content)
  console.log(`State after read: ${(await sandbox.getInfo()).state}`)
  ```

  ```python Python icon="python" theme={"system"}
  from novita_sandbox.core import Sandbox

  sandbox = Sandbox.create(
      timeout=10 * 60,
      lifecycle={
          "on_timeout": "pause",
          "auto_resume": True,
      },
  )

  sandbox.files.write("/home/user/hello.txt", "hello from a paused sandbox")
  sandbox.pause()

  content = sandbox.files.read("/home/user/hello.txt")
  print(content)
  print(f"State after read: {sandbox.get_info().state}")
  ```
</CodeGroup>

### Exemple : serveur web avec reprise automatique

La reprise automatique fonctionne bien pour les environnements de prévisualisation et les serveurs web. Après la mise en pause de la sandbox, une requête HTTP entrante vers le service exposé peut la réveiller.

L’exemple ci-dessous démarre un serveur HTTP Python simple et affiche une URL de prévisualisation publique. Vous pouvez utiliser `getHost()` en JavaScript ou `get_host()` en Python pour récupérer le nom d’hôte public d’un port.

<CodeGroup>
  ```js JavaScript & TypeScript icon="js" theme={"system"}
  import { Sandbox } from 'novita-sandbox'

  const sandbox = await Sandbox.create({
    timeoutMs: 5 * 60 * 1000,
    lifecycle: {
      onTimeout: 'pause',
      autoResume: true,
    },
  })

  await sandbox.commands.run('python3 -m http.server 3000', { background: true })

  const host = sandbox.getHost(3000)
  // Once the sandbox times out and pauses, any request to the preview URL will automatically resume it.
  console.log(`Preview URL: https://${host}`)
  ```

  ```python Python icon="python" theme={"system"}
  from novita_sandbox.core import Sandbox

  sandbox = Sandbox.create(
      timeout=5 * 60,
      lifecycle={
          "on_timeout": "pause",
          "auto_resume": True,
      },
  )

  sandbox.commands.run("python3 -m http.server 3000", background=True)

  host = sandbox.get_host(3000)
  # Once the sandbox times out and pauses, any request to the preview URL will automatically resume it.
  print(f"Preview URL: https://{host}")
  ```
</CodeGroup>

## Nettoyage

La reprise automatique reste activée au fil des cycles répétés de reprise et de pause. Chaque reprise démarre une nouvelle période d’expiration, en utilisant au moins cinq minutes ou le délai d’expiration initial plus long.

Après la reprise de la sandbox, les clients doivent se reconnecter à tous les services qu’ils utilisaient. Les connexions HTTP, WebSocket, base de données et terminal existantes ne restent pas ouvertes pendant que la sandbox est en pause.

Vous pouvez appeler `.kill()` pour supprimer définitivement la sandbox. Après cela, elle ne peut plus être reprise.