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

# Snapshot de Sandbox

Um snapshot é um estado salvo reutilizável de um sandbox. Ele captura o sistema de arquivos e o estado da memória do sandbox para que você possa iniciar novos sandboxes a partir desse ponto posteriormente.

A Novita também descreve esse conceito como fazer commit de um sandbox em um snapshot. Use snapshots quando quiser:

* Preparar dependências uma vez e reutilizá-las em sandboxes posteriores.
* Salvar um estado conhecido como bom antes de executar trabalhos arriscados ou caros.
* Iniciar vários sandboxes a partir do mesmo ambiente capturado.
* Manter um estado reutilizável depois que o sandbox original não for mais necessário.

Para continuar o mesmo sandbox mais tarde, use [Persistência de Sandbox](/docs/pt-BR/guides/sandbox-persistence). Para criar novos sandboxes a partir de um ponto salvo, use snapshots.

## Terminologia

* **Sandbox de origem**: A instância de sandbox usada para criar o snapshot.
* **Snapshot**: O estado salvo que pode ser usado para criar novos sandboxes.
* **Novo sandbox**: Um sandbox criado a partir do snapshot.

## Criar um snapshot

Você pode usar o método `createSnapshot` em JavaScript ou o método `create_snapshot` em Python para criar um snapshot a partir de um sandbox em execução. O sandbox é pausado enquanto o snapshot está sendo criado e, depois, pode continuar em execução após a conclusão da operação.

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

Você também pode criar um snapshot pelo ID do 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>

Armazene o ID do snapshot retornado. Em seguida, você poderá usá-lo como template ao criar um novo sandbox.

## Criar um sandbox a partir de um snapshot

Você pode passar o ID do snapshot para `create` para iniciar um novo sandbox a partir do 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>

O novo sandbox tem seu próprio ID de sandbox e ciclo de vida. Encerrar o sandbox original não exclui o snapshot.

## Listar snapshots

Você pode usar o método `listSnapshots` em JavaScript ou o método `list_snapshots` em Python quando precisar encontrar estados salvos para um sandbox ou para sua conta.

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

Você pode filtrar pelo ID do sandbox de origem ao listar todos os snapshots.

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

## Excluir um snapshot

Você pode usar o método `deleteSnapshot` em JavaScript ou o método `delete_snapshot` em Python para excluir snapshots que não são mais necessários. Um snapshot pode não ser excluível enquanto sandboxes em execução ainda o estiverem usando como origem, então encerre esses sandboxes antes de excluir o snapshot.

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

## Recomendações para snapshots

* Crie snapshots depois que as etapas de configuração forem concluídas com sucesso.
* Mantenha os IDs de snapshot no seu próprio banco de dados se os jobs precisarem reutilizá-los mais tarde.
* Use metadados nos sandboxes para rastrear de onde vieram os estados salvos.
* Exclua snapshots não utilizados para evitar manter estados salvos obsoletos.
* Use [Persistência de Sandbox](/docs/pt-BR/guides/sandbox-persistence) se você só precisar pausar e retomar o mesmo sandbox.