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

# Pausa y reanudación automáticas

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/es/guides/sandbox-your-first-agent-sandbox#configure-environment-variables">Configure Environment Variables</a>.</Note>;
  }
};

Estas funciones se basan en [Persistencia de sandbox](/docs/es/guides/sandbox-persistence). La pausa automática conserva el estado del sandbox cuando expira la vida útil máxima. La reanudación automática despierta un sandbox en pausa cuando llega nueva actividad.

<SandboxConfigHint />

## Configurar

Al crear un sandbox, pasa una configuración `lifecycle`. Esto controla el comportamiento del tiempo de espera y si un sandbox en pausa puede activarse automáticamente.

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

### Opciones de ciclo de vida

La configuración `lifecycle` admite estos campos:

| Configuración                              | Opción    | Significado                                                                                                                                    |
| ------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------- |
| `onTimeout` (JS) / `on_timeout` (Python)   | `"kill"`  | Comportamiento predeterminado. El sandbox se elimina después de su tiempo de espera.                                                           |
| `onTimeout` (JS) / `on_timeout` (Python)   | `"pause"` | El sandbox se pausa después del tiempo de espera en lugar de eliminarse.                                                                       |
| `autoResume` (JS) / `auto_resume` (Python) | `false`   | Comportamiento predeterminado. Los sandboxes en pausa permanecen en pausa hasta que se reanudan manualmente.                                   |
| `autoResume` (JS) / `auto_resume` (Python) | `true`    | Los sandboxes en pausa se reinician cuando llega actividad compatible. Esto requiere que el comportamiento del tiempo de espera sea `"pause"`. |

Si la reanudación automática está deshabilitada o se omite, un sandbox en pausa aún puede reanudarse manualmente con `Sandbox.connect()`.

## Pausa automática

De forma predeterminada, un sandbox se termina cuando expira su tiempo de espera. Para conservar el estado en su lugar, establece `onTimeout` en JavaScript o `on_timeout` en Python para pausar al agotarse el tiempo de espera.

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

## Reanudación automática

La reanudación automática puede despertar un sandbox en pausa cuando llega actividad compatible. Esto solo funciona cuando el sandbox está configurado para pausarse al agotarse el tiempo de espera.

### Tiempo de espera después de la reanudación automática

Después de una reanudación automática, el sandbox recibe un tiempo de espera de al menos cinco minutos. Si el tiempo de espera original era superior a cinco minutos, se reutiliza el valor original más largo.

El temporizador de tiempo de espera comienza cuando el sandbox se reanuda, no cuando se creó originalmente.

Ejemplo con un tiempo de espera de dos minutos:

1. El sandbox se ejecuta durante dos minutos y luego se pausa.
2. Nueva actividad llega al sandbox, lo que hace que se reanude.
3. El sandbox reanudado recibe un tiempo de espera de cinco minutos porque ese es el mínimo.
4. Si nada restablece el temporizador, el sandbox vuelve a pausarse después de cinco minutos.

Ejemplo con un tiempo de espera de una hora:

* El sandbox se reanuda con un tiempo de espera de una hora, porque el tiempo de espera original es mayor que el mínimo de cinco minutos.

Este comportamiento continúa en futuros ciclos de pausa y reanudación, porque la configuración del ciclo de vida permanece asociada al sandbox.

<Note>
  Puedes actualizar el tiempo de espera después de reanudar usando `setTimeout()` en JavaScript o `set_timeout()` en Python.
</Note>

### Qué cuenta como actividad

La reanudación automática puede activarse mediante acciones del SDK y tráfico HTTP.

Ejemplos compatibles incluyen:

* `sandbox.commands.run(...)`
* `sandbox.files.read(...)`
* `sandbox.files.write(...)`
* Visitar una URL de aplicación con túnel
* Enviar solicitudes a un servicio que se ejecuta dentro del sandbox

Cuando un sandbox está en pausa y la reanudación automática está habilitada, la siguiente acción compatible lo reanuda automáticamente. No necesitas llamar primero a `Sandbox.connect()`.

### Ejemplo de SDK: pausar y luego leer un archivo

Este ejemplo crea un sandbox, escribe un archivo, pausa el sandbox y luego lee el archivo. La operación de lectura hace que el sandbox se reanude.

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

### Ejemplo: servidor web con reanudación automática

La reanudación automática funciona bien para entornos de vista previa y servidores web. Después de que el sandbox se pausa, una solicitud HTTP entrante al servicio expuesto puede despertarlo.

El siguiente ejemplo inicia un servidor HTTP simple de Python e imprime una URL pública de vista previa. Puedes usar `getHost()` en JavaScript o `get_host()` en Python para recuperar el nombre de host público de un puerto.

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

## Limpieza

La reanudación automática permanece habilitada a lo largo de ciclos repetidos de reanudación y pausa. Cada reanudación inicia un nuevo período de tiempo de espera, usando al menos cinco minutos o el tiempo de espera original más largo.

Después de que el sandbox se reanuda, los clientes deben volver a conectarse a cualquier servicio que estuvieran usando. Las conexiones HTTP, WebSocket, de base de datos y de terminal existentes no permanecen abiertas mientras el sandbox está en pausa.

Puedes llamar a `.kill()` para eliminar el sandbox de forma permanente. Después de eso, no se puede reanudar.