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

# Sandbox-snapshot

Een snapshot is een herbruikbare opgeslagen staat van een sandbox. Deze legt het bestandssysteem en de geheugenstatus van de sandbox vast, zodat je later vanaf dat punt nieuwe sandboxes kunt starten.

Novita beschrijft dit concept ook als het committen van een sandbox naar een snapshot. Gebruik snapshots wanneer je het volgende wilt doen:

* Dependencies één keer voorbereiden en ze opnieuw gebruiken in latere sandboxes.
* Een bekende, werkende staat opslaan voordat je riskant of duur werk uitvoert.
* Meerdere sandboxes starten vanuit dezelfde vastgelegde omgeving.
* Een herbruikbare staat behouden nadat de oorspronkelijke sandbox niet langer nodig is.

Gebruik [Sandboxpersistentie](/docs/nl/guides/sandbox-persistence) om dezelfde sandbox later voort te zetten. Gebruik snapshots om nieuwe sandboxes te maken vanaf een opgeslagen punt.

## Terminologie

* **Oorspronkelijke sandbox**: De sandboxinstantie die wordt gebruikt om de snapshot te maken.
* **Snapshot**: De opgeslagen staat die kan worden gebruikt om nieuwe sandboxes te maken.
* **Nieuwe sandbox**: Een sandbox die vanuit de snapshot is gemaakt.

## Een snapshot maken

Je kunt de methode `createSnapshot` in JavaScript of de methode `create_snapshot` in Python gebruiken om een snapshot te maken van een draaiende sandbox. De sandbox wordt gepauzeerd terwijl de snapshot wordt gemaakt en kan daarna verder draaien wanneer de bewerking is voltooid.

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

Je kunt ook een snapshot maken op basis van een sandbox-ID.

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

Sla de geretourneerde snapshot-ID op. Daarna kun je deze als sjabloon gebruiken bij het maken van een nieuwe sandbox.

## Een sandbox maken vanuit een snapshot

Je kunt de snapshot-ID doorgeven aan `create` om een nieuwe sandbox te starten vanuit de vastgelegde staat.

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

De nieuwe sandbox heeft een eigen sandbox-ID en levenscyclus. Het beëindigen van de oorspronkelijke sandbox verwijdert de snapshot niet.

## Snapshots weergeven

Je kunt de methode `listSnapshots` in JavaScript of de methode `list_snapshots` in Python gebruiken wanneer je opgeslagen staten voor een sandbox of voor je account moet vinden.

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

Je kunt filteren op bron-sandbox-ID wanneer je alle snapshots weergeeft.

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

## Een snapshot verwijderen

Je kunt de methode `deleteSnapshot` in JavaScript of de methode `delete_snapshot` in Python gebruiken om snapshots te verwijderen die je niet langer nodig hebt. Een snapshot kan mogelijk niet worden verwijderd terwijl draaiende sandboxes deze nog steeds als bron gebruiken, dus beëindig die sandboxes voordat je de snapshot verwijdert.

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

## Aanbevelingen voor snapshots

* Maak een snapshot nadat installatiestappen succesvol zijn voltooid.
* Bewaar snapshot-ID's in je eigen database als taken ze later opnieuw moeten gebruiken.
* Gebruik metadata op sandboxes om bij te houden waar opgeslagen staten vandaan kwamen.
* Verwijder ongebruikte snapshots om te voorkomen dat verouderde opgeslagen staten bewaard blijven.
* Gebruik in plaats daarvan [Sandboxpersistentie](/docs/nl/guides/sandbox-persistence) als je alleen dezelfde sandbox hoeft te pauzeren en te hervatten.