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

# Automatisch pauzeren en hervatten

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

Deze functies bouwen voort op [Sandbox-persistentie](/docs/nl/guides/sandbox-persistence). Automatisch pauzeren behoudt de sandboxstatus wanneer de maximale levensduur verloopt. Automatisch hervatten wekt een gepauzeerde sandbox wanneer er nieuwe activiteit binnenkomt.

<SandboxConfigHint />

## Configureren

Wanneer je een sandbox maakt, geef je een `lifecycle`-configuratie mee. Hiermee bepaal je het time-outgedrag en of een gepauzeerde sandbox automatisch kan ontwaken.

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

### Levenscyclusopties

De instelling `lifecycle` ondersteunt deze velden:

| Instelling                                 | Optie     | Betekenis                                                                                                                          |
| ------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------- |
| `onTimeout` (JS) / `on_timeout` (Python)   | `"kill"`  | Standaardgedrag. De sandbox wordt verwijderd na de time-out.                                                                       |
| `onTimeout` (JS) / `on_timeout` (Python)   | `"pause"` | De sandbox wordt na de time-out gepauzeerd in plaats van verwijderd.                                                               |
| `autoResume` (JS) / `auto_resume` (Python) | `false`   | Standaardgedrag. Gepauzeerde sandboxes blijven gepauzeerd totdat ze handmatig worden hervat.                                       |
| `autoResume` (JS) / `auto_resume` (Python) | `true`    | Gepauzeerde sandboxes starten opnieuw wanneer ondersteunde activiteit binnenkomt. Hiervoor moet het time-outgedrag `"pause"` zijn. |

Als automatisch hervatten is uitgeschakeld of weggelaten, kan een gepauzeerde sandbox nog steeds handmatig worden hervat met `Sandbox.connect()`.

## Automatisch pauzeren

Standaard wordt een sandbox beëindigd wanneer de time-out verloopt. Stel `onTimeout` in JavaScript of `on_timeout` in Python in om de status in plaats daarvan te behouden door te pauzeren bij een time-out.

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

## Automatisch hervatten

Automatisch hervatten kan een gepauzeerde sandbox wekken wanneer ondersteunde activiteit binnenkomt. Dit werkt alleen wanneer de sandbox is geconfigureerd om bij een time-out te pauzeren.

### Time-out na automatisch hervatten

Na een automatische hervatting krijgt de sandbox een time-out van minimaal vijf minuten. Als de oorspronkelijke time-out langer was dan vijf minuten, wordt de langere oorspronkelijke waarde opnieuw gebruikt.

De time-outtimer start wanneer de sandbox wordt hervat, niet wanneer deze oorspronkelijk is gemaakt.

Voorbeeld met een time-out van twee minuten:

1. De sandbox draait twee minuten en pauzeert daarna.
2. Nieuwe activiteit bereikt de sandbox, waardoor deze wordt hervat.
3. De hervatte sandbox krijgt een time-out van vijf minuten, omdat dat het minimum is.
4. Als niets de timer reset, pauzeert de sandbox opnieuw na vijf minuten.

Voorbeeld met een time-out van één uur:

* De sandbox wordt hervat met een time-out van één uur, omdat de oorspronkelijke time-out langer is dan het minimum van vijf minuten.

Dit gedrag blijft van toepassing tijdens toekomstige pauze- en hervatcycli, omdat de levenscyclusinstellingen aan de sandbox gekoppeld blijven.

<Note>
  Je kunt de time-out na het hervatten bijwerken met `setTimeout()` in JavaScript of `set_timeout()` in Python.
</Note>

### Wat als activiteit telt

Automatisch hervatten kan worden geactiveerd door SDK-acties en HTTP-verkeer.

Ondersteunde voorbeelden zijn onder andere:

* `sandbox.commands.run(...)`
* `sandbox.files.read(...)`
* `sandbox.files.write(...)`
* Een getunnelde applicatie-URL bezoeken
* Verzoeken sturen naar een service die binnen de sandbox draait

Wanneer een sandbox is gepauzeerd en automatisch hervatten is ingeschakeld, hervat de volgende ondersteunde actie deze automatisch. Je hoeft `Sandbox.connect()` niet eerst aan te roepen.

### SDK-voorbeeld: pauzeren en daarna een bestand lezen

Dit voorbeeld maakt een sandbox, schrijft een bestand, pauzeert de sandbox en leest daarna het bestand. De leesbewerking zorgt ervoor dat de sandbox wordt hervat.

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

### Voorbeeld: webserver met automatisch hervatten

Automatisch hervatten werkt goed voor preview-omgevingen en webservers. Nadat de sandbox pauzeert, kan een binnenkomend HTTP-verzoek naar de blootgestelde service deze wekken.

Het onderstaande voorbeeld start een eenvoudige Python-HTTP-server en drukt een openbare preview-URL af. Je kunt `getHost()` in JavaScript of `get_host()` in Python gebruiken om de openbare hostnaam voor een poort op te halen.

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

## Opschonen

Automatisch hervatten blijft ingeschakeld tijdens herhaalde hervat- en pauzecycli. Elke hervatting start een nieuwe time-outperiode, met minimaal vijf minuten of de langere oorspronkelijke time-out.

Nadat de sandbox is hervat, moeten clients opnieuw verbinding maken met alle services die ze gebruikten. Bestaande HTTP-, WebSocket-, database- en terminalverbindingen blijven niet open terwijl de sandbox is gepauzeerd.

Je kunt `.kill()` aanroepen om de sandbox permanent te verwijderen. Daarna kan deze niet meer worden hervat.