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

# Accès à Internet

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

La connectivité Internet est disponible dans chaque sandbox, et l’accès externe est fourni via une URL publique.

<SandboxConfigHint />

## Activer ou désactiver l’accès à Internet

Lors de la création d’une sandbox, vous pouvez utiliser le paramètre `allowInternetAccess` / `allow_internet_access` pour configurer la connectivité Internet. L’accès à Internet est activé par défaut, mais il peut être désactivé pour les charges de travail ayant des exigences de sécurité plus strictes.

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

  // Create sandbox with internet access enabled (default)
  const sandbox = await Sandbox.create({ allowInternetAccess: true })

  // Create sandbox without internet access
  const isolatedSandbox = await Sandbox.create({ allowInternetAccess: false })
  ```

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

  # Create sandbox with internet access enabled (default)
  sandbox = Sandbox.create(allow_internet_access=True)

  # Create sandbox without internet access
  isolated_sandbox = Sandbox.create(allow_internet_access=False)
  ```
</CodeGroup>

Si l’accès à Internet est désactivé, la sandbox ne peut pas initier de requêtes réseau sortantes. Cela permet d’ajouter une couche de protection supplémentaire lors de l’exécution de code sensible.

<Note>
  Transmettre une valeur falsy à `allowInternetAccess` / `allow_internet_access` a le même effet que l’ajout de `['0.0.0.0/0']` à `network.denyOut` / `network.deny_out`, ce qui bloque toutes les destinations.
</Note>

## Contrôle réseau granulaire

La configuration réseau offre un contrôle plus granulaire du trafic sortant en vous permettant de définir des listes d’autorisation et de refus.

### Listes d’autorisation et de refus

Les adresses IP, les blocs CIDR ou les noms de domaine auxquels la sandbox est autorisée à accéder peuvent être spécifiés.

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

  // Deny all traffic except specific IPs
  const sandbox = await Sandbox.create({
    network: {
      denyOut: ['0.0.0.0/0'],
      allowOut: ['1.1.1.1', '8.8.8.0/24']
    }
  })

  // Deny specific IPs only
  const restrictedSandbox = await Sandbox.create({
    network: {
      denyOut: ['8.8.8.8']
    }
  })
  ```

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

  # Deny all traffic except specific IPs
  sandbox = Sandbox.create(
      network={
          "deny_out": ["0.0.0.0/0"],
          "allow_out": ["1.1.1.1", "8.8.8.0/24"]
      }
  )

  # Deny specific IPs only
  restricted_sandbox = Sandbox.create(
      network={
          "deny_out": ["8.8.8.8"]
      }
  )
  ```
</CodeGroup>

<Note>
  Le CIDR `'0.0.0.0/0'` / `"0.0.0.0/0"` est un raccourci pour « toutes les destinations ». Une constante `ALL_TRAFFIC` exportée se résout à la même valeur `0.0.0.0/0` si vous préférez une alternative nommée au littéral.
</Note>

### Filtrage basé sur le domaine

Vous pouvez spécifier des noms d’hôte dans `allowOut` / `allow_out` afin d’autoriser le trafic sortant vers des domaines sélectionnés. Lorsque le filtrage basé sur le domaine est activé, tout le trafic restant doit être bloqué via `denyOut` / `deny_out`. Les entrées de domaine sont uniquement prises en charge dans les listes d’autorisation et ne peuvent pas être utilisées dans les listes de refus.

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

  // Allow only traffic to google.com
  const sandbox = await Sandbox.create({
    network: {
      allowOut: ['google.com'],
      denyOut: ['0.0.0.0/0']
    }
  })
  ```

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

  # Allow only traffic to google.com
  sandbox = Sandbox.create(
      network={
          "allow_out": ["google.com"],
          "deny_out": ["0.0.0.0/0"]
      }
  )
  ```
</CodeGroup>

<Note>
  Chaque fois qu’un domaine apparaît dans la configuration, le serveur de noms par défaut `8.8.8.8` est autorisé automatiquement afin que la résolution DNS continue de fonctionner.
</Note>

Vous pouvez également faire correspondre chaque sous-domaine d’un domaine avec un caractère générique :

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

  // Allow traffic to any subdomain of mydomain.com
  const sandbox = await Sandbox.create({
    network: {
      allowOut: ['*.mydomain.com'],
      denyOut: ['0.0.0.0/0']
    }
  })
  ```

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

  # Allow traffic to any subdomain of mydomain.com
  sandbox = Sandbox.create(
      network={
          "allow_out": ["*.mydomain.com"],
          "deny_out": ["0.0.0.0/0"]
      }
  )
  ```
</CodeGroup>

Les domaines, les adresses IP et les plages CIDR peuvent tous être mélangés dans la même liste :

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

  // Allow traffic to specific domains and IPs
  const sandbox = await Sandbox.create({
    network: {
      allowOut: ['api.example.com', '*.github.com', '8.8.8.8'],
      denyOut: ['0.0.0.0/0']
    }
  })
  ```

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

  # Allow traffic to specific domains and IPs
  sandbox = Sandbox.create(
      network={
          "allow_out": ["api.example.com", "*.github.com", "8.8.8.8"],
          "deny_out": ["0.0.0.0/0"]
      }
  )
  ```
</CodeGroup>

<Note>
  Le filtrage par domaine s’applique uniquement à HTTP sur le port 80 (inspecté via l’en-tête Host) et à TLS sur le port 443 (inspecté via SNI). Tout autre port revient à une correspondance basée sur CIDR, et les protocoles UDP tels que QUIC/HTTP3 ne peuvent pas être filtrés par domaine.
</Note>

### Comportement des connexions TCP bloquées

En raison de l’architecture du pare-feu, une connexion sortante bloquée peut tout de même sembler réussir depuis l’intérieur de la sandbox.

Le pare-feu doit d’abord accepter la connexion TCP avant de pouvoir évaluer si la destination cible est autorisée. Par conséquent, le code exécuté dans la sandbox peut voir la connexion réussir et le socket s’ouvrir, même si la destination est bloquée. Dans ce cas, aucun trafic n’est réellement transmis au point de terminaison distant.

Pour confirmer que la destination est accessible, validez une réponse au niveau applicatif au lieu de vous fier uniquement à la réussite de la connexion TCP. Par exemple, vérifiez un code d’état HTTP, une négociation TLS terminée ou les octets de réponse attendus du protocole.

Ce comportement est une limitation actuelle de la manière dont le trafic sortant de la sandbox est routé via notre pare-feu et pourra être mis à jour à l’avenir.

### Règles de priorité

Si des règles d’autorisation et de refus sont toutes deux configurées, **les règles d’autorisation sont prioritaires**. Par conséquent, toute adresse IP qui apparaît dans les deux listes sera tout de même autorisée.

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

  // Even though all traffic is denied, 1.1.1.1 and 8.8.8.8 are explicitly allowed
  const sandbox = await Sandbox.create({
    network: {
      denyOut: ['0.0.0.0/0'],
      allowOut: ['1.1.1.1', '8.8.8.8']
    }
  })
  ```

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

  # Even though all traffic is denied, 1.1.1.1 and 8.8.8.8 are explicitly allowed
  sandbox = Sandbox.create(
      network={
          "deny_out": ["0.0.0.0/0"],
          "allow_out": ["1.1.1.1", "8.8.8.8"]
      }
  )
  ```
</CodeGroup>

Les paramètres `network` ne prennent effet que lorsque la sandbox est créée — fournissez-les à `Sandbox.create`. Une fois que la sandbox existe, ils sont fixes et ne peuvent pas être modifiés.

## URL publique de la sandbox

Les services dans une sandbox sont accessibles en utilisant l’URL publique de la sandbox.

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

  const sandbox = await Sandbox.create()

  // You need to always pass a port number to get the host
  const host = sandbox.getHost(3000)
  console.log(`https://${host}`)
  ```

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

  sandbox = Sandbox.create()

  # You need to always pass a port number to get the host
  host = sandbox.get_host(3000)
  print(f'https://{host}')
  ```
</CodeGroup>

La sortie ressemblera à ceci :

<CodeGroup>
  ```bash JavaScript & TypeScript icon="terminal" theme={"system"}
  https://3000-i62mff4ahtrdfdkyn2esc.sandbox.novita.ai
  ```

  ```bash Python icon="terminal" theme={"system"}
  https://3000-i62mff4ahtrdfdkyn2esc.sandbox.novita.ai
  ```
</CodeGroup>

Le segment le plus à gauche du nom d’hôte correspond exactement au numéro de port que vous avez transmis à la méthode.

## Connexion à un serveur exécuté dans la sandbox

Vous pouvez vous connecter à un serveur exécuté dans la sandbox à l’aide de la méthode décrite précédemment ; par exemple, démarrez un serveur HTTP léger sur le port 3000 pour servir des fichiers depuis son répertoire de lancement.

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

  const sandbox = await Sandbox.create()

  // Start a simple HTTP server inside the sandbox.
  const process = await sandbox.commands.run('python -m http.server 3000', { background: true })
  const host = sandbox.getHost(3000)
  const url = `https://${host}`
  console.log('Server started at:', url)

  // Fetch data from the server inside the sandbox.
  const response = await fetch(url);
  const data = await response.text();
  console.log('Response from server inside sandbox:', data);

  // Kill the server process inside the sandbox.
  await process.kill()
  ```

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

  sandbox = Sandbox.create()

  # Start a simple HTTP server inside the sandbox.
  process = sandbox.commands.run("python -m http.server 3000", background=True)
  host = sandbox.get_host(3000)
  url = f"https://{host}"
  print('Server started at:', url)

  # Fetch data from the server inside the sandbox.
  response = requests.get(url)
  data = response.text
  print('Response from server inside sandbox:', data)

  # Kill the server process inside the sandbox.
  process.kill()
  ```
</CodeGroup>

Cette sortie sera la suivante :

<CodeGroup>
  ```bash JavaScript & TypeScript icon="terminal" theme={"system"}
  Server started at: https://3000-ip3nfrvajtqu5ktoxugc7.sandbox.novita.ai
  Response from server inside sandbox: <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
  <html>
  <head>
  <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
  <title>Directory listing for /</title>
  </head>
  <body>
  <h1>Directory listing for /</h1>
  <hr>
  <ul>
  <li><a href=".bash_logout">.bash_logout</a></li>
  <li><a href=".bashrc">.bashrc</a></li>
  <li><a href=".profile">.profile</a></li>
  </ul>
  <hr>
  </body>
  </html>
  ```

  ```bash Python icon="terminal" theme={"system"}
  Server started at: https://3000-ip3nfrvajtqu5ktoxugc7.sandbox.novita.ai
  Response from server inside sandbox: <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
  <html>
  <head>
  <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
  <title>Directory listing for /</title>
  </head>
  <body>
  <h1>Directory listing for /</h1>
  <hr>
  <ul>
  <li><a href=".bash_logout">.bash_logout</a></li>
  <li><a href=".bashrc">.bashrc</a></li>
  <li><a href=".profile">.profile</a></li>
  </ul>
  <hr>
  </body>
  </html>
  ```
</CodeGroup>

## Masquage des en-têtes Host des requêtes

Vous pouvez utiliser l’option `maskRequestHost` / `mask_request_host` pour personnaliser l’en-tête Host envoyé aux services exécutés dans la sandbox. C’est utile lorsque votre application s’attend à ce que les requêtes suivent un format d’hôte spécifique.

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

  // Create sandbox with custom host masking
  const sandbox = await Sandbox.create({
    network: {
      maskRequestHost: 'localhost:${PORT}'
    }
  })

  // The ${PORT} variable will be replaced with the actual port number
  // Requests to the sandbox will have Host header set to for example: localhost:8080
  ```

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

  # Create sandbox with custom host masking
  sandbox = Sandbox.create(
      network={
          "mask_request_host": "localhost:${PORT}"
      }
  )

  # The ${PORT} variable will be replaced with the actual port number
  # Requests to the sandbox will have Host header set to for example: localhost:8080
  ```
</CodeGroup>

Au moment de la requête, `${PORT}` dans le masque est remplacé par le numéro de port réel du service adressé.