O que sao Redes de Computadores

O que e uma rede de computadores?

Uma rede de computadores e um conjunto de dispositivos autonomos interconectados que podem trocar dados entre si. "Autonomos" significa que cada dispositivo opera de forma independente — nao existe uma relacao mestre/escravo obrigatoria. "Interconectados" significa que existe um caminho (fisico ou logico) pelo qual dados podem fluir de um dispositivo a outro.

A definicao e intencionalmente ampla. Uma rede pode ser dois laptops conectados por um cabo Ethernet, ou pode ser a Internet — bilhoes de dispositivos interconectados por uma hierarquia complexa de provedores.

A Internet: uma rede de redes

A Internet nao e uma unica rede — e uma rede de redes. Ela conecta milhoes de redes privadas, academicas, governamentais e comerciais atraves de um conjunto padronizado de protocolos.

                        +------------------+
                        |   ISP Tier 1     |
                        | (backbone global)|
                        +--------+---------+
                                 |
                    +------------+------------+
                    |                         |
             +------+------+          +------+------+
             | ISP Tier 2  |          | ISP Tier 2  |
             | (regional)  |          | (regional)  |
             +------+------+          +------+------+
                    |                         |
              +-----+-----+            +-----+-----+
              |           |            |           |
         +----+----+ +----+----+  +----+----+ +----+----+
         |ISP local| |ISP local|  |Empresa  | |Universi.|
         +---------+ +---------+  +---------+ +---------+
              |           |            |           |
           [casas]     [casas]    [servidores]  [labs]

A hierarquia de ISPs (Internet Service Providers) funciona assim:

• Tier 1: provedores globais (ex: Lumen, NTT, GTT) que formam o backbone da Internet. Eles fazem peering entre si sem pagar — sao mutuamente dependentes.
• Tier 2: provedores regionais que compram transito de Tier 1 e vendem para ISPs locais.
• Tier 3: ISPs locais que conectam usuarios finais (residencias, empresas).

Borda vs. Nucleo da rede

Podemos dividir a Internet em duas partes conceituais:

• Borda (edge): os dispositivos finais — computadores, smartphones, servidores, dispositivos IoT. Sao os hosts que rodam aplicacoes.
• Nucleo (core): a malha de roteadores e switches que transportam dados entre os hosts da borda. O nucleo nao executa aplicacoes — ele apenas encaminha pacotes.

Comutacao de circuitos vs. comutacao de pacotes

Existem duas abordagens fundamentais para transmitir dados em uma rede:

Comutacao de circuitos (circuit switching)

Um circuito dedicado e estabelecido entre origem e destino antes da comunicacao comecar. Os recursos (largura de banda, buffers) ficam reservados durante toda a chamada. Exemplo classico: a rede telefonica tradicional (PSTN).

Comutacao de Circuitos:

  A =====[circuito dedicado]=====> B
  (recursos reservados end-to-end)

  Vantagens: latencia previsivel, sem perda
  Desvantagens: desperdicio quando nao ha dados,
                nao escala para milhoes de usuarios

Comutacao de pacotes (packet switching)

Os dados sao divididos em pacotes que sao enviados independentemente. Cada pacote carrega seu endereco de destino e pode seguir caminhos diferentes. Os recursos sao compartilhados entre todos os usuarios — multiplexacao estatistica.

Comutacao de Pacotes:

  A --[pkt1]--> R1 --[pkt1]--> R3 --[pkt1]--> B
  A --[pkt2]--> R1 --[pkt2]--> R2 --[pkt2]--> B
  A --[pkt3]--> R2 --[pkt3]--> R3 --[pkt3]--> B

  (pacotes compartilham links, sem reserva)

  Vantagens: eficiente, escala bem, tolerante a falhas
  Desvantagens: atrasos variaveis, possivel perda de pacotes

A Internet usa comutacao de pacotes. Essa escolha foi uma decisao de design fundamental que permite que bilhoes de dispositivos compartilhem a mesma infraestrutura de forma eficiente.

Protocolos

Um protocolo define o formato e a ordem das mensagens trocadas entre duas ou mais entidades comunicantes, bem como as acoes tomadas na transmissao e/ou recepcao dessas mensagens.

Protocolos sao para redes o que APIs sao para software: um contrato que define como duas partes se comunicam. Sem protocolos padronizados, cada fabricante implementaria sua propria forma de comunicacao, e nada seria interoperavel.

Protocolo humano:          Protocolo de rede:

"Oi!"                      SYN
        "Oi, tudo bem?"            SYN-ACK
"Tudo! Posso perguntar..."  ACK
        "Claro!"                   HTTP GET /
"Qual o horario?"
        "Sao 14:30"               HTTP 200 OK
"Obrigado, tchau!"          FIN
        "Tchau!"                   FIN-ACK

Modelos cliente-servidor e peer-to-peer

Cliente-servidor

No modelo cliente-servidor, existe uma separacao clara de papeis: o servidor esta sempre ligado, tem um endereco fixo, e espera requisicoes. O cliente inicia a comunicacao quando precisa de algo.

import requests

# Cliente HTTP fazendo uma requisicao a um servidor
response = requests.get("https://api.github.com/users/octocat")
print(response.status_code)  # 200
print(response.json()["login"])  # octocat

Peer-to-peer (P2P)

No modelo P2P, nao existe servidor dedicado. Cada no (peer) pode ser simultaneamente cliente e servidor. Exemplos: BitTorrent, Bitcoin, IPFS.

A maioria dos sistemas reais usa uma combinacao dos dois modelos. Por exemplo, BitTorrent usa um servidor central (tracker) para descobrir peers, mas a transferencia de dados e peer-to-peer.

No harness.os

O mesh do harness.os e uma rede de computadores em miniatura. Veja os paralelos:

Rede de computadores          harness.os mesh
─────────────────────         ──────────────────────
Hosts (end systems)     =     Harness instances (marco.ai, build.ai, cortex.ai)
Pacotes                 =     MCP tool calls (request/response)
Roteadores              =     Orchestrator (roteia requests para o agente certo)
Protocolos              =     MCP protocol (stdio, HTTP/SSE)
Enderecos IP            =     Project slugs / UUIDs
DNS                     =     Slug resolution (build-ai -> UUID -> Neon connection)
ISP                     =     Neon (provedor de conectividade ao banco)

Quando o orchestrator do harness.os spawna agentes e roteia requests para instancias especificas baseado em project slugs, ele esta fazendo exatamente o que um roteador faz: examinar o "endereco" (slug) e encaminhar o "pacote" (tool call) para o destino correto.

Resumo

• Uma rede de computadores conecta dispositivos autonomos para troca de dados
• A Internet e uma rede de redes, organizada em hierarquia de ISPs
• Borda (hosts que rodam aplicacoes) vs. nucleo (roteadores que encaminham pacotes)
• Comutacao de pacotes: dados divididos em pacotes, recursos compartilhados
• Protocolos definem regras de comunicacao — sem eles, nao ha interoperabilidade
• Cliente-servidor vs. P2P — a maioria dos sistemas usa uma combinacao

Exercicio pratico

Desenhe a topologia de rede do mesh harness.os atual. Identifique:

1. Quais sao os nos (hosts) da rede? (marco.ai, build.ai, cortex.ai)
2. Quais sao os links de comunicacao? (MCP stdio, MCP HTTP/SSE, Neon Postgres)
3. Qual e o modelo: cliente-servidor, P2P, ou hibrido?
4. Onde esta a "borda" e onde esta o "nucleo"?
5. Se um no cair, o que acontece com os outros? Ha tolerancia a falhas?