Enlace de Dados

Quadro Ethernet:

+-----------+----------+------+---------+---------+-----+
| Preambulo | SFD      | Dest | Source  | Type    | ... |
| 7 bytes   | 1 byte   | MAC  | MAC     | 2 bytes |     |
|           |          |6 bytes|6 bytes |         |     |
+-----------+----------+------+---------+---------+-----+
                                                    |
+---------------------------------------------------+---+----+
|              Payload (46-1500 bytes)                   | FCS|
|              (pacote IP encapsulado)                   |4 B |
+--------------------------------------------------------+----+

MAC address: 48 bits, notacao hexadecimal
  Exemplo: AA:BB:CC:DD:EE:FF
  Primeiros 3 octetos: OUI (fabricante)
  Ultimos 3 octetos: ID unico do dispositivo

FCS (Frame Check Sequence): CRC-32 para deteccao de erros

import uuid
import subprocess

# Obter MAC address do host
mac = ':'.join([f'{(uuid.getnode() >> i) & 0xff:02x}'
               for i in range(0, 48, 8)][::-1])
print(f"MAC address: {mac}")

# Ver tabela ARP (mapeamento IP -> MAC)
result = subprocess.run(["arp", "-a"], capture_output=True, text=True)
print(result.stdout)

Hub (camada 1 - fisica):
  Recebe quadro em uma porta -> replica para TODAS as outras portas
  Nao olha MAC addresses. Colisoes frequentes. Obsoleto.

  A --[frame]--> [HUB] --[frame]--> B
                   |---[frame]--> C  (C recebe mesmo sem ser destino)
                   |---[frame]--> D  (D tambem recebe)

Switch (camada 2 - enlace):
  Mantém tabela MAC (MAC -> porta). Encaminha apenas para a porta correta.
  Sem colisoes. Performance muito melhor.

  A --[frame]--> [SWITCH] --[frame]--> B  (apenas B recebe)
                   |
              Tabela MAC:
              AA:BB:CC:11 -> porta 1 (A)
              AA:BB:CC:22 -> porta 2 (B)
              AA:BB:CC:33 -> porta 3 (C)

Host A quer enviar para 192.168.1.5, mas so sabe o IP. Precisa do MAC.

1. A envia ARP Request (broadcast):
   "Quem tem o IP 192.168.1.5? Me diga seu MAC."
   Destino: FF:FF:FF:FF:FF:FF (broadcast - todos recebem)

2. Host B (192.168.1.5) responde com ARP Reply:
   "Eu sou 192.168.1.5. Meu MAC e AA:BB:CC:DD:EE:55"

3. A guarda na ARP cache: 192.168.1.5 -> AA:BB:CC:DD:EE:55

4. A encapsula o pacote IP em um frame Ethernet com:
   MAC destino: AA:BB:CC:DD:EE:55
   MAC origem:  (MAC do A)
   Tipo: 0x0800 (IPv4)
   Payload: pacote IP

Sem VLAN:                        Com VLANs:
  Todos no mesmo dominio         VLAN 10 (Eng): A, B
  de broadcast                   VLAN 20 (RH):  C, D

  A, B, C, D <-> broadcast       A <-> B (VLAN 10)
  (todos veem tudo)               C <-> D (VLAN 20)
                                  A -/-> C (bloqueado, VLANs diferentes)

  802.1Q: adiciona tag de 4 bytes ao frame Ethernet
  indicando a qual VLAN o frame pertence

Trace completo: MCP server -> Neon Postgres

Camada 7 (Aplicacao): MCP tool call (JSON-RPC)
Camada 7 (Aplicacao): PostgreSQL wire protocol (query SQL)
Camada 4 (Transporte): TCP segmento (porta 5432)
Camada 3 (Rede):       IP pacote (IP do Fly.io -> IP do Neon)
Camada 2 (Enlace):     Ethernet frame (MAC do gateway Fly.io)
Camada 1 (Fisica):     Sinais eletricos/opticos no datacenter

Quando "a conexao com o banco falha", o problema pode estar
em QUALQUER uma dessas camadas:
  - DNS nao resolve (camada 7)
  - Firewall bloqueia porta 5432 (camada 3/4)
  - Rede do datacenter com falha (camada 2/1)
  - TLS certificate expired (entre camada 4 e 7)

Entender todas as camadas = debugar qualquer problema de rede.