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

# Persistance du sandbox

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

La persistance du sandbox vous permet de mettre en pause un sandbox et de le reprendre plus tard avec le même système de fichiers et le même état mémoire. C’est utile pour les tâches d’agents de longue durée, les applications interactives et les workflows qui doivent survivre à des périodes d’inactivité sans garder les ressources de calcul actives.

Lorsqu’un sandbox est mis en pause :

* Les fichiers créés dans le sandbox sont conservés.
* L’état en mémoire est conservé, y compris les processus en cours d’exécution et les variables.
* Les connexions réseau sont interrompues jusqu’à la reprise du sandbox.
* Le sandbox reste stocké jusqu’à ce que vous le repreniez puis le supprimiez, ou que vous le supprimiez pendant qu’il est en pause.

Pour la mise en pause automatique lors d’un timeout et la reprise automatique en cas d’activité, consultez [Auto Pause and Resume](/docs/fr/guides/sandbox-auto-resume). Pour le délai d’inactivité, consultez [Idle timeout](/docs/fr/guides/sandbox-idle-timeout).

<SandboxConfigHint />

<Warning>
  Veuillez noter :

  * Il faut environ 4 secondes par 1 Go de RAM pour mettre le sandbox en pause.
  * Il faut environ 1 seconde pour reprendre le sandbox.
  * Les données d’un sandbox en pause sont conservées jusqu’à ce que vous appeliez explicitement la méthode `kill`.
</Warning>

## Mettre un sandbox en pause

Vous pouvez appeler la méthode `pause` lorsque vous souhaitez enregistrer l’état actuel.

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

  const sandbox = await Sandbox.create()
  await sandbox.commands.run('echo hello > /tmp/message.txt')

  const sandboxId = sandbox.sandboxId
  await sandbox.pause()

  console.log('Sandbox paused', sandboxId)
  ```

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

  sandbox = Sandbox.create()
  sandbox.commands.run("echo hello > /tmp/message.txt")

  sandbox_id = sandbox.sandbox_id
  sandbox.pause()

  print('Sandbox paused', sandbox_id)
  ```
</CodeGroup>

## Reprendre un sandbox

Utilisez l’ID de sandbox enregistré pour vous reconnecter. Si le sandbox est en pause, vous pouvez utiliser la méthode `connect` pour le reprendre avant de le retourner.

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

  const sandbox = await Sandbox.connect(sandboxId)
  const result = await sandbox.commands.run('cat /tmp/message.txt')
  console.log(result.stdout)

  await sandbox.kill()
  ```

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

  sandbox = Sandbox.connect(sandbox_id)
  result = sandbox.commands.run("cat /tmp/message.txt")
  print(result.stdout)

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

Vous pouvez transmettre un nouveau `timeout` lors de la reconnexion.

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

  const sandbox = await Sandbox.connect(sandboxId, { timeoutMs: 600_000 })

  await sandbox.kill()
  ```

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

  sandbox = Sandbox.connect(sandbox_id, timeout=600)

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

Pour un sandbox en cours d’exécution, le timeout n’est mis à jour que lorsque le nouveau timeout est plus long que l’existant. Pour un sandbox en pause, le timeout s’applique après sa reprise.

## Lister les sandboxes en pause

Vous pouvez utiliser la méthode `list` avec un filtre d’état pour trouver les sandboxes en pause. Vous trouverez plus d’informations sur l’utilisation de cette méthode dans [List Sandboxes](/docs/fr/guides/sandbox-list).

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

  const paginator = Sandbox.list({
    query: {
      state: ['paused'],
    },
  })

  while (paginator.hasNext) {
    const items = await paginator.nextItems()
    for (const info of items) {
      console.log(info.sandboxId, info.state, info.metadata)
    }
  }
  ```

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

  paginator = Sandbox.list(
      query=SandboxQuery(state=[SandboxState.PAUSED])
  )

  while paginator.has_next:
      for info in paginator.next_items():
          print(info.sandbox_id, info.state, info.metadata)
  ```
</CodeGroup>

Les filtres de métadonnées sont utiles lorsque vous devez trouver des sandboxes créés par un utilisateur, une session ou une tâche spécifique.

## Supprimer un sandbox en pause

Les sandboxes en pause restent stockés jusqu’à ce que vous les supprimiez. Vous pouvez utiliser la méthode `kill` pour supprimer les sandboxes en pause dont vous n’avez plus besoin.

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

  await Sandbox.kill(sandboxId)
  ```

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

  Sandbox.kill(sandbox_id)
  ```
</CodeGroup>

## Persistance vs snapshots

La persistance sert à continuer le même sandbox plus tard. Utilisez-la lorsque l’ID exact du sandbox et son état d’exécution actuel sont importants pour vous.

Les snapshots servent à créer des états enregistrés réutilisables. Utilisez un snapshot lorsque vous souhaitez démarrer un ou plusieurs nouveaux sandboxes à partir du même état capturé du système de fichiers et de la mémoire.

Pour les états réutilisables, consultez [Sandbox Snapshot](/docs/fr/guides/sandbox-snapshot).

## Réseau

Si vous mettez en pause un sandbox qui dispose d’un service en cours d’exécution, ce service devient inaccessible depuis l’extérieur du sandbox et tous les clients connectés sont déconnectés. Une fois le sandbox repris, le service redevient accessible, mais les clients doivent se reconnecter.