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

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

A conectividade com a internet está disponível em todos os sandboxes, e o acesso externo é fornecido por meio de uma URL pública.

<SandboxConfigHint />

## Alternando o acesso à internet

Ao criar um sandbox, você pode usar o parâmetro `allowInternetAccess` / `allow_internet_access` para configurar a conectividade com a internet. O acesso à internet é ativado por padrão, mas pode ser desativado para cargas de trabalho com requisitos de segurança mais rigorosos.

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

Se o acesso à internet estiver desativado, o sandbox será impedido de iniciar solicitações de rede de saída. Isso ajuda a adicionar uma camada extra de proteção ao executar código sensível.

<Note>
  Passar um valor falsy para `allowInternetAccess` / `allow_internet_access` tem o mesmo efeito que adicionar `['0.0.0.0/0']` a `network.denyOut` / `network.deny_out`, o que bloqueia todos os destinos.
</Note>

## Controle de rede refinado

A configuração de rede fornece controle mais refinado sobre o tráfego de saída, permitindo que você defina listas de permissão e listas de bloqueio.

### Listas de permissão e bloqueio

Endereços IP, blocos CIDR ou nomes de domínio que o sandbox tem permissão para acessar podem ser especificados.

<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>
  O CIDR `'0.0.0.0/0'` / `"0.0.0.0/0"` é uma forma abreviada para "todos os destinos". Uma constante `ALL_TRAFFIC` exportada resolve para o mesmo valor `0.0.0.0/0` se você preferir uma alternativa nomeada ao literal.
</Note>

### Filtragem baseada em domínio

Você pode especificar hostnames em `allowOut` / `allow_out` para permitir tráfego de saída para domínios selecionados. Quando a filtragem baseada em domínio está ativada, todo o tráfego restante deve ser bloqueado por meio de `denyOut` / `deny_out`. Entradas de domínio só são compatíveis com listas de permissão e não podem ser usadas em listas de bloqueio.

<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>
  Sempre que um domínio aparece na configuração, o servidor de nomes padrão `8.8.8.8` é permitido automaticamente para que a resolução DNS continue funcionando.
</Note>

Você também pode corresponder a todos os subdomínios de um domínio com um curinga:

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

Domínios, endereços IP e intervalos CIDR podem ser todos combinados na mesma 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>
  A filtragem por domínio se aplica apenas a HTTP pela porta 80 (inspecionado por meio do cabeçalho Host) e TLS pela porta 443 (inspecionado por meio de SNI). Qualquer outra porta volta para a correspondência baseada em CIDR, e protocolos UDP, como QUIC/HTTP3, não podem ser filtrados por domínio.
</Note>

### Como conexões TCP bloqueadas se comportam

Devido à arquitetura do firewall, uma conexão de saída bloqueada ainda pode parecer bem-sucedida a partir de dentro do sandbox.

O firewall precisa primeiro aceitar a conexão TCP antes de poder avaliar se o destino de destino é permitido. Como resultado, o código em execução dentro do sandbox pode ver a conexão ser bem-sucedida e o socket abrir, mesmo que o destino esteja bloqueado. Nesse caso, nenhum tráfego é realmente entregue ao endpoint remoto.

Para confirmar que o destino está acessível, valide uma resposta em nível de aplicação em vez de confiar apenas no sucesso da conexão TCP. Por exemplo, verifique um código de status HTTP, um handshake TLS concluído ou os bytes de resposta esperados do protocolo.

Esse comportamento é uma limitação atual de como o tráfego de saída do sandbox é roteado pelo nosso firewall e pode ser atualizado no futuro.

### Regras de prioridade

Se regras de permissão e bloqueio estiverem configuradas, **as regras de permissão têm prioridade**. Portanto, qualquer endereço IP que apareça em ambas as listas ainda será permitido.

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

As configurações de `network` entram em vigor somente quando o sandbox é criado — forneça-as a `Sandbox.create`. Depois que o sandbox existe, elas ficam fixas e não podem ser modificadas.

## URL pública do sandbox

Serviços em um sandbox podem ser acessados usando a URL pública do 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>

A saída será assim:

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

O segmento mais à esquerda do hostname é exatamente o número da porta que você passou para o método.

## Conectando-se a um servidor em execução dentro do sandbox

Você pode se conectar a um servidor em execução dentro do sandbox usando o método descrito anteriormente; por exemplo, inicie um servidor HTTP leve na porta 3000 para servir arquivos a partir do diretório de inicialização dele.

<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 saída será a seguinte:

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

## Mascarando cabeçalhos Host de solicitações

Você pode usar a opção `maskRequestHost` / `mask_request_host` para personalizar o cabeçalho Host enviado aos serviços em execução dentro do sandbox. Isso é útil quando sua aplicação espera que as solicitações sigam um 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>

No momento da solicitação, `${PORT}` na máscara é substituído pelo número real da porta do serviço que está sendo endereçado.