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

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

La conectividad a internet está disponible en cada sandbox, y el acceso externo se proporciona mediante una URL pública.

<SandboxConfigHint />

## Activar o desactivar el acceso a internet

Al crear una sandbox, puedes usar el parámetro `allowInternetAccess` / `allow_internet_access` para configurar la conectividad a internet. El acceso a internet está activado de forma predeterminada, pero puede desactivarse para cargas de trabajo con requisitos de seguridad más estrictos.

<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 el acceso a internet está desactivado, se impide que la sandbox inicie solicitudes de red salientes. Esto ayuda a añadir una capa adicional de protección al ejecutar código sensible.

<Note>
  Pasar un valor falsy a `allowInternetAccess` / `allow_internet_access` tiene el mismo efecto que añadir `['0.0.0.0/0']` a `network.denyOut` / `network.deny_out`, lo que bloquea todos los destinos.
</Note>

## Control de red detallado

La configuración de red proporciona un control más detallado sobre el tráfico saliente al permitirte definir listas de permitidos y listas de bloqueados.

### Listas de permitidos y bloqueados

Se pueden especificar direcciones IP, bloques CIDR o nombres de dominio a los que la sandbox tiene permitido acceder.

<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>
  El CIDR `'0.0.0.0/0'` / `"0.0.0.0/0"` es una abreviatura de "todos los destinos". Una constante exportada `ALL_TRAFFIC` se resuelve al mismo valor `0.0.0.0/0` si prefieres una alternativa con nombre en lugar del literal.
</Note>

### Filtrado basado en dominio

Puedes especificar nombres de host en `allowOut` / `allow_out` para permitir tráfico saliente a dominios seleccionados. Cuando el filtrado basado en dominio está activado, todo el tráfico restante debe bloquearse mediante `denyOut` / `deny_out`. Las entradas de dominio solo se admiten en listas de permitidos y no pueden usarse en listas de bloqueados.

<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>
  Siempre que aparezca un dominio en la configuración, el servidor de nombres predeterminado `8.8.8.8` se permite automáticamente para que la resolución DNS siga funcionando.
</Note>

También puedes coincidir con todos los subdominios de un dominio usando un comodín:

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

Los dominios, las direcciones IP y los rangos CIDR pueden combinarse en la misma lista:

<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>
  El filtrado por dominio se aplica solo a HTTP sobre el puerto 80 (inspeccionado mediante el encabezado Host) y TLS sobre el puerto 443 (inspeccionado mediante SNI). Cualquier otro puerto recurre a la coincidencia basada en CIDR, y los protocolos UDP como QUIC/HTTP3 no pueden filtrarse por dominio.
</Note>

### Cómo se comportan las conexiones TCP bloqueadas

Debido a la arquitectura del firewall, una conexión saliente bloqueada puede seguir pareciendo exitosa desde dentro de la sandbox.

El firewall primero debe aceptar la conexión TCP antes de poder evaluar si el destino de destino está permitido. Como resultado, el código que se ejecuta dentro de la sandbox puede ver que la conexión se realiza correctamente y que el socket se abre, incluso si el destino está bloqueado. En ese caso, no se entrega realmente ningún tráfico al endpoint remoto.

Para confirmar que el destino es alcanzable, valida una respuesta a nivel de aplicación en lugar de depender únicamente del éxito de la conexión TCP. Por ejemplo, comprueba un código de estado HTTP, un handshake TLS completado o los bytes de respuesta esperados del protocolo.

Este comportamiento es una limitación actual de cómo se enruta el tráfico saliente de la sandbox a través de nuestro firewall y puede actualizarse en el futuro.

### Reglas de prioridad

Si se configuran reglas de permitir y bloquear, **las reglas de permitir tienen prioridad**. Por lo tanto, cualquier dirección IP que aparezca en ambas listas seguirá estando permitida.

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

La configuración de `network` solo surte efecto cuando se crea la sandbox: proporciónala a `Sandbox.create`. Una vez que la sandbox existe, queda fija y no puede modificarse.

## URL pública de la sandbox

Se puede acceder a los servicios de una sandbox usando la URL pública 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 salida será similar a esta:

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

El segmento más a la izquierda del nombre de host es exactamente el número de puerto que pasaste al método.

## Conectarse a un servidor que se ejecuta dentro de la sandbox

Puedes conectarte a un servidor que se ejecuta dentro de la sandbox usando el método descrito anteriormente; por ejemplo, inicia un servidor HTTP ligero en el puerto 3000 para servir archivos desde su directorio de inicio.

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

Esta salida será la siguiente:

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

## Enmascarar encabezados Host de solicitudes

Puedes usar la opción `maskRequestHost` / `mask_request_host` para personalizar el encabezado Host enviado a los servicios que se ejecutan dentro de la sandbox. Esto es útil cuando tu aplicación espera que las solicitudes sigan un formato de host específico.

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

En el momento de la solicitud, `${PORT}` en la máscara se sustituye por el número de puerto real del servicio al que se está dirigiendo.