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

# Instantánea de sandbox

Una instantánea es un estado guardado reutilizable de un sandbox. Captura el sistema de archivos y el estado de la memoria del sandbox para que puedas iniciar nuevos sandboxes desde ese punto más adelante.

Novita también describe este concepto como confirmar un sandbox en una instantánea. Usa instantáneas cuando quieras:

* Preparar dependencias una vez y reutilizarlas en sandboxes posteriores.
* Guardar un estado conocido como correcto antes de ejecutar trabajo riesgoso o costoso.
* Iniciar varios sandboxes desde el mismo entorno capturado.
* Conservar un estado reutilizable después de que el sandbox original ya no sea necesario.

Para continuar el mismo sandbox más adelante, usa [Persistencia de sandbox](/docs/es/guides/sandbox-persistence). Para crear nuevos sandboxes desde un punto guardado, usa instantáneas.

## Terminología

* **Sandbox de origen**: La instancia de sandbox usada para crear la instantánea.
* **Instantánea**: El estado guardado que puede usarse para crear nuevos sandboxes.
* **Nuevo sandbox**: Un sandbox creado desde la instantánea.

## Crear una instantánea

Puedes usar el método `createSnapshot` en JavaScript o el método `create_snapshot` en Python para crear una instantánea desde un sandbox en ejecución. El sandbox se pausa mientras se crea la instantánea y luego puede continuar ejecutándose cuando se completa la operación.

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

  sandbox = Sandbox.create()
  sandbox.commands.run("echo ready > /tmp/status.txt")

  snapshot = sandbox.create_snapshot()
  print(snapshot.snapshot_id)
  ```

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

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

  const snapshot = await sandbox.createSnapshot()
  console.log(snapshot.snapshotId)
  ```
</CodeGroup>

También puedes crear una instantánea mediante el ID del sandbox.

<CodeGroup>
  ```python Python icon="python" theme={"system"}
  snapshot = Sandbox.create_snapshot(sandbox_id)
  ```

  ```js JavaScript & TypeScript icon="js" theme={"system"}
  const snapshot = await Sandbox.createSnapshot(sandboxId)
  ```
</CodeGroup>

Guarda el ID de instantánea devuelto. Luego puedes usarlo como plantilla al crear un nuevo sandbox.

## Crear un sandbox desde una instantánea

Puedes pasar el ID de instantánea a `create` para iniciar un nuevo sandbox desde el estado capturado.

<CodeGroup>
  ```python Python icon="python" theme={"system"}
  snapshot_id = snapshot.snapshot_id

  new_sandbox = Sandbox.create(template=snapshot_id)
  result = new_sandbox.commands.run("cat /tmp/status.txt")
  print(result.stdout)
  ```

  ```js JavaScript & TypeScript icon="js" theme={"system"}
  const snapshotId = snapshot.snapshotId

  const newSandbox = await Sandbox.create(snapshotId)
  const result = await newSandbox.commands.run('cat /tmp/status.txt')
  console.log(result.stdout)
  ```
</CodeGroup>

El nuevo sandbox tiene su propio ID de sandbox y ciclo de vida. Eliminar el sandbox original no elimina la instantánea.

## Listar instantáneas

Puedes usar el método `listSnapshots` en JavaScript o el método `list_snapshots` en Python cuando necesites encontrar estados guardados de un sandbox o de tu cuenta.

<CodeGroup>
  ```python Python icon="python" theme={"system"}
  # List snapshots created from one sandbox.
  paginator = sandbox.list_snapshots(limit=20)

  while paginator.has_next:
      for snapshot in paginator.next_items():
          print(snapshot.snapshot_id)

  # Or list all snapshots.
  paginator = Sandbox.list_snapshots(limit=20)
  ```

  ```js JavaScript & TypeScript icon="js" theme={"system"}
  // List snapshots created from one sandbox.
  const paginator = sandbox.listSnapshots({ limit: 20 })

  while (paginator.hasNext) {
    const snapshots = await paginator.nextItems()
    for (const snapshot of snapshots) {
      console.log(snapshot.snapshotId)
    }
  }

  // Or list all snapshots.
  const allSnapshots = Sandbox.listSnapshots({ limit: 20 })
  ```
</CodeGroup>

Puedes filtrar por ID del sandbox de origen al listar todas las instantáneas.

<CodeGroup>
  ```python Python icon="python" theme={"system"}
  paginator = Sandbox.list_snapshots(sandbox_id=sandbox_id, limit=20)
  ```

  ```js JavaScript & TypeScript icon="js" theme={"system"}
  const paginator = Sandbox.listSnapshots({ sandboxId, limit: 20 })
  ```
</CodeGroup>

## Eliminar una instantánea

Puedes usar el método `deleteSnapshot` en JavaScript o el método `delete_snapshot` en Python para eliminar instantáneas que ya no necesites. Es posible que una instantánea no se pueda eliminar mientras sandboxes en ejecución aún la estén usando como origen, así que elimina esos sandboxes antes de eliminar la instantánea.

<CodeGroup>
  ```python Python icon="python" theme={"system"}
  new_sandbox.kill()
  Sandbox.delete_snapshot(snapshot_id)
  ```

  ```js JavaScript & TypeScript icon="js" theme={"system"}
  await newSandbox.kill()
  await Sandbox.deleteSnapshot(snapshotId)
  ```
</CodeGroup>

## Recomendaciones para instantáneas

* Crea una instantánea después de que los pasos de configuración finalicen correctamente.
* Conserva los IDs de instantánea en tu propia base de datos si los trabajos necesitan reutilizarlos más adelante.
* Usa metadatos en los sandboxes para rastrear de dónde provienen los estados guardados.
* Elimina las instantáneas no utilizadas para evitar conservar estados guardados obsoletos.
* Usa [Persistencia de sandbox](/docs/es/guides/sandbox-persistence) en su lugar si solo necesitas pausar y reanudar el mismo sandbox.