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

Ein Snapshot ist ein wiederverwendbarer gespeicherter Zustand einer Sandbox. Er erfasst das Dateisystem und den Speicherzustand der Sandbox, sodass du später neue Sandboxes von diesem Punkt aus starten kannst.

Novita beschreibt dieses Konzept auch als Committen einer Sandbox in einen Snapshot. Verwende Snapshots, wenn du Folgendes tun möchtest:

* Abhängigkeiten einmal vorbereiten und in späteren Sandboxes wiederverwenden.
* Einen bekanntermaßen funktionierenden Zustand speichern, bevor riskante oder teure Arbeiten ausgeführt werden.
* Mehrere Sandboxes aus derselben erfassten Umgebung starten.
* Einen wiederverwendbaren Zustand behalten, nachdem die ursprüngliche Sandbox nicht mehr benötigt wird.

Um dieselbe Sandbox später fortzusetzen, verwende [Sandbox Persistence](/docs/de/guides/sandbox-persistence). Um neue Sandboxes von einem gespeicherten Punkt aus zu erstellen, verwende Snapshots.

## Terminologie

* **Origin Sandbox**: Die Sandbox-Instanz, die zum Erstellen des Snapshots verwendet wird.
* **Snapshot**: Der gespeicherte Zustand, der zum Erstellen neuer Sandboxes verwendet werden kann.
* **New Sandbox**: Eine aus dem Snapshot erstellte Sandbox.

## Einen Snapshot erstellen

Du kannst die Methode `createSnapshot` in JavaScript oder die Methode `create_snapshot` in Python verwenden, um einen Snapshot aus einer laufenden Sandbox zu erstellen. Die Sandbox wird pausiert, während der Snapshot erstellt wird, und kann nach Abschluss des Vorgangs weiterlaufen.

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

Du kannst einen Snapshot auch anhand der Sandbox-ID erstellen.

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

Speichere die zurückgegebene Snapshot-ID. Anschließend kannst du sie als Vorlage verwenden, wenn du eine neue Sandbox erstellst.

## Eine Sandbox aus einem Snapshot erstellen

Du kannst die Snapshot-ID an `create` übergeben, um eine neue Sandbox aus dem erfassten Zustand zu starten.

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

Die neue Sandbox hat ihre eigene Sandbox-ID und ihren eigenen Lebenszyklus. Das Beenden der ursprünglichen Sandbox löscht den Snapshot nicht.

## Snapshots auflisten

Du kannst die Methode `listSnapshots` in JavaScript oder die Methode `list_snapshots` in Python verwenden, wenn du gespeicherte Zustände für eine Sandbox oder für dein Konto finden musst.

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

Du kannst beim Auflisten aller Snapshots nach der Quell-Sandbox-ID filtern.

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

## Einen Snapshot löschen

Du kannst die Methode `deleteSnapshot` in JavaScript oder die Methode `delete_snapshot` in Python verwenden, um Snapshots zu löschen, die du nicht mehr benötigst. Ein Snapshot kann möglicherweise nicht gelöscht werden, solange laufende Sandboxes ihn noch als Quelle verwenden. Beende diese Sandboxes daher, bevor du den Snapshot löschst.

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

## Empfehlungen für Snapshots

* Erstelle einen Snapshot, nachdem Setup-Schritte erfolgreich abgeschlossen wurden.
* Speichere Snapshot-IDs in deiner eigenen Datenbank, wenn Jobs sie später wiederverwenden müssen.
* Verwende Metadaten auf Sandboxes, um nachzuverfolgen, woher gespeicherte Zustände stammen.
* Lösche nicht verwendete Snapshots, um veraltete gespeicherte Zustände zu vermeiden.
* Verwende stattdessen [Sandbox Persistence](/docs/de/guides/sandbox-persistence), wenn du nur dieselbe Sandbox pausieren und fortsetzen musst.