Modelos y capas
"Un buen sistema en capas es como una cebolla: pelás una capa y debajo hay otra capa, todas haciendo su parte sin pisarse."
Qué vas a aprender en este capítulo
Antes de meter la mano en cables, IPs o HTTP, necesitás entender el truco arquitectónico que hace posible Internet: la estratificación en capas. Vas a aprender el modelo OSI (siete capas, teórico), el modelo TCP/IP (cuatro capas, real), por qué las capas existen, cómo se comunican, y qué pasa byte a byte cuando un dato sube y baja por la pila.
1.1 La idea: dividir para conquistar
💡 Intuición
Imaginate que vas a mandar una carta a un amigo en Argentina. ¿Qué pasos hay?
- Vos escribís el contenido en español.
- Metés la carta en un sobre con dirección.
- El cartero local la lleva a un centro de distribución.
- El centro de distribución la pone en un avión.
- El avión la lleva a Argentina.
- Otro centro de distribución la entrega a otro cartero.
- Otro cartero la lleva al destinatario.
- Tu amigo abre el sobre y lee.
Cada paso no necesita saber lo que hacen los otros. Vos no sabés qué avión se usó. El piloto no sabe qué dice la carta. El cartero no sabe en qué idioma está escrita.
Las redes funcionan idénticamente. Cada capa hace una cosa, esconde sus detalles a las otras, y le pasa el dato a la capa siguiente.
Esa separación permite que:
- Cambiés WiFi por cable sin romper Internet (la capa física cambia, las superiores ni se enteran).
- Inventes un protocolo nuevo (IPv6) sin reescribir todos los programas.
- Una placa Ethernet de 10 GB de hoy hable con un router de hace 20 años.
Sin las capas, internet sería imposible.
📜 Historia
A finales de los 60, ARPANET (la primera red de paquetes, financiada por el ejército de EE.UU.) conectó cuatro universidades. Sus creadores (Vint Cerf, Bob Kahn, otros) descubrieron rápidamente que conectar redes distintas (no solo computadoras) iba a ser difícil sin un estándar.
En 1974, Cerf y Kahn publicaron el paper "A Protocol for Packet Network Intercommunication" — el origen de TCP/IP. La idea revolucionaria: una interconexión de redes ("inter-net") con un protocolo común que todas pudieran adoptar.
En paralelo, la ISO (International Organization for Standardization) trabajaba en un modelo más teórico: OSI, con siete capas. Era más limpio académicamente, pero TCP/IP ganó la batalla del mercado en los 80 — fue simple, gratis y libre.
Hoy, OSI se enseña porque su división es pedagógica; TCP/IP es lo que realmente corre. Y DARPA (la agencia que financió ARPANET) nunca patentó nada — eso permitió que TCP/IP se usara en todo el mundo sin pagar nada.
1.2 El modelo OSI (7 capas)
📐 Fundamento
+--------------------------+
| 7. Aplicación | ← HTTP, FTP, SMTP, DNS
+--------------------------+
| 6. Presentación | ← formato de datos, cifrado, compresión
+--------------------------+
| 5. Sesión | ← establecer/mantener "sesiones"
+--------------------------+
| 4. Transporte | ← TCP, UDP — extremo a extremo confiable o no
+--------------------------+
| 3. Red | ← IP — direccionamiento global
+--------------------------+
| 2. Enlace de datos | ← Ethernet, WiFi — un salto físico
+--------------------------+
| 1. Física | ← bits eléctricos / ópticos / radio
+--------------------------+
Truco para memorizar (en inglés): "Please Do Not Throw Sausage Pizza Away".
(En español: "Para Encantarle Recibimos Tu Sándwich Para Aplaudir" o cualquier mnemónico que funcione.)
Cada capa
Capa 1 — Física. El medio (cobre, fibra, radio). Define voltajes, frecuencias, conectores. No sabe qué transmite — solo bits. Ejemplos: 100BASE-T, fibra óptica monomodo, 802.11ac.
Capa 2 — Enlace. Frames con direcciones MAC, dentro de un mismo segmento de red. Salta de una máquina a la siguiente. Ejemplos: Ethernet, WiFi (802.11), PPP.
Capa 3 — Red. Direccionamiento global y ruteo entre redes. Llega de una red a otra. Ejemplos: IP (v4 y v6), ICMP.
Capa 4 — Transporte. Comunicación extremo a extremo. Confiabilidad, control de flujo, control de congestión. Ejemplos: TCP, UDP.
Capa 5 — Sesión. Establece, gestiona y cierra sesiones entre aplicaciones. En la práctica de Internet, muchas veces no aparece explícita — TCP cubre parte.
Capa 6 — Presentación. Formato (ASCII, JSON, XML), compresión, cifrado (TLS técnicamente vive acá-ish). En la práctica, casi nunca se la trata como capa separada.
Capa 7 — Aplicación. Lo que tu programa "ve". HTTP, SMTP, FTP, DNS, SSH.
Crítica: OSI tiene 7 capas más por simetría que por necesidad práctica. Las capas 5 y 6 están medio vacías en la realidad.
1.3 El modelo TCP/IP (4 capas)
📐 Fundamento
El modelo "real" de Internet:
+--------------------+
| 4. Aplicación | ← HTTP, DNS, SSH, FTP, SMTP — y todo lo demás
+--------------------+
| 3. Transporte | ← TCP, UDP
+--------------------+
| 2. Internet | ← IP, ICMP
+--------------------+
| 1. Acceso a red | ← Ethernet, WiFi, físico — todo junto
+--------------------+
Mapeo TCP/IP ↔ OSI:
| TCP/IP | OSI |
|---|---|
| Aplicación | 5, 6, 7 (sesión + presentación + aplicación) |
| Transporte | 4 |
| Internet | 3 |
| Acceso a red | 1, 2 |
Por qué TCP/IP ganó:
- Más simple — 4 capas en lugar de 7.
- Acompañado de implementaciones gratuitas desde el inicio (BSD, Linux).
- Pragmático — no insiste en separación rígida cuando no agrega valor.
En este libro mezclamos ambos: la pedagogía de OSI (entender capas individualmente) con la realidad de TCP/IP (cuatro capas que sí existen).
1.4 Encapsulamiento — cómo bajan los datos
📐 Fundamento
Cuando enviás un mensaje, cada capa agrega su propia "envoltura" (header), como meter una carta en sobres anidados:
Aplicación: "Hola Juan"
↓ + cabecera HTTP
Transporte: [HTTP-hdr][Hola Juan]
↓ + cabecera TCP
Internet: [TCP-hdr][HTTP-hdr][Hola Juan]
↓ + cabecera IP
Enlace: [IP-hdr][TCP-hdr][HTTP-hdr][Hola Juan]
↓ + cabecera Ethernet (+trailer)
Físico: [Eth-hdr][IP-hdr][TCP-hdr][HTTP-hdr][Hola Juan][Eth-trail]
↓ convertido a bits
0101010110001110...
Cada capa agrega lo suyo al bajar. Cuando llega al destinatario, el proceso se invierte: cada capa desnuda su envoltura y pasa los datos a la capa de arriba.
Nombres de los datos por capa:
| Capa | Nombre |
|---|---|
| Aplicación | Mensaje |
| Transporte | Segmento (TCP) o Datagrama (UDP) |
| Red | Paquete |
| Enlace | Frame (trama) |
| Física | Bits |
Estos términos no son intercambiables — usalos correctamente en exámenes.
Lo que cada cabecera contiene (esquemático)
Cabecera Ethernet (capa 2):
| MAC destino | MAC origen | Tipo | datos | CRC |
| 6 bytes | 6 bytes | 2 B | ... | 4 B |
Cabecera IP (capa 3):
| Versión | TTL | Protocolo | IP origen | IP destino | datos |
Cabecera TCP (capa 4):
| Puerto origen | Puerto destino | Seq | Ack | Flags | Window | Checksum | datos |
Cabecera HTTP (capa 7):
GET /index.html HTTP/1.1
Host: example.com
User-Agent: Mozilla/5.0
Cuando hacés curl https://google.com, toda esta cebolla se construye y se envía. Y google.com hace exactamente lo mismo en sentido inverso para responderte.
1.5 Salto físico vs salto lógico
📐 Fundamento
Una distinción crucial que confunde a todos al principio:
- Capa 2 (enlace) trabaja un salto físico a la vez. Si tu paquete pasa por 10 routers, hay 10 frames Ethernet distintos — uno por cada salto. Las direcciones MAC cambian en cada salto.
- Capa 3 (red) trabaja fin a fin lógicamente. La dirección IP origen y destino NO cambian durante todo el viaje.
Visualización:
Tu PC (192.168.1.10) → Router casa (203.0.113.1) → ... → Google (142.250.x.x)
│ │
MAC cambia cada salto MAC del siguiente router
IP origen: 192.168.1.10 (siempre tu PC, durante todo el camino, hasta NAT)
IP destino: 142.250.x.x (siempre Google, durante todo el camino)
(Hay una excepción: NAT cambia tu IP local 192.168.1.10 a la IP pública del router. Lo veremos en cap 3.)
Esta distinción es la base para entender:
- Por qué los routers tienen tablas de ruteo (IP).
- Por qué los switches tienen tablas MAC (Ethernet).
- Por qué
traceroutete muestra cada salto.
1.6 Protocolos comunes por capa
📐 Fundamento
Capa de aplicación:
| Protocolo | Para qué | Puerto típico |
|---|---|---|
| HTTP / HTTPS | Web | 80 / 443 |
| DNS | Resolver nombres → IPs | 53 |
| SSH | Acceso remoto seguro | 22 |
| FTP | Transferencia de archivos | 21 |
| SMTP | Envío de email | 25 / 587 |
| POP3 / IMAP | Recibir email | 110 / 143 |
| Telnet | Acceso remoto sin cifrar (no usar en serio) | 23 |
| DHCP | Asignar IPs automáticamente | 67/68 |
| NTP | Sincronizar reloj | 123 |
Capa de transporte:
- TCP (orientado a conexión, confiable): web, email, SSH.
- UDP (sin conexión, sin garantías): DNS, video streaming, juegos en tiempo real.
Capa de red:
- IPv4 (dominante por décadas): direcciones 32 bits, escasas.
- IPv6 (futuro): direcciones 128 bits, abundantes.
- ICMP (diagnóstico):
ping,traceroute.
Capa de enlace:
- Ethernet (cable): 100M / 1G / 10G.
- WiFi (802.11): 11n, 11ac, 11ax (WiFi 6).
- PPP (módems, ya en desuso).
Capa física:
- Cobre (RJ-45): hasta ~100 m, hasta 10 Gbps con Cat6a.
- Fibra óptica: hasta cientos de km, hasta cientos de Gbps.
- Radio (WiFi, 4G/5G).
1.7 Ejemplo completo: cargar una página web
🛠️ En la práctica
Lo que pasa cuando escribís https://www.google.com en el navegador y presionás Enter (versión simplificada):
1. DNS — resolver el nombre.
Tu PC → router casa → ISP → DNS server
"¿Qué IP es google.com?"
DNS responde: "142.250.x.x"
(Eso ya es una mini-conversación de red usando UDP.)
2. TLS handshake.
Tu PC abre conexión TCP con google.com:443
TCP three-way handshake (SYN, SYN-ACK, ACK)
TLS handshake (intercambio de claves, certificados)
3. HTTP request.
GET / HTTP/1.1
Host: www.google.com
User-Agent: Mozilla/5.0...
Eso baja por: Aplicación → TLS → TCP → IP → Ethernet/WiFi → bits.
4. El paquete viaja.
Pasa por tu router → módem → ISP → backbone → datacenter de Google → servidor concreto.
Cada salto: el frame Ethernet se reconstruye (MAC nueva), pero el paquete IP queda intacto.
5. Servidor responde.
HTTP/1.1 200 OK
Content-Type: text/html
...
<!doctype html>...
6. Tu PC recibe.
Frames → reconstruir paquetes IP → reensamblar segmentos TCP en orden → descifrar TLS → entregar HTML al navegador.
7. Navegador renderiza.
Mientras renderiza, hace muchas más request HTTP por imágenes, JS, CSS, fonts, ads, analytics... Una página típica son 80-100 conexiones.
Todo en aproximadamente 1 segundo. Es ridículamente impresionante.
1.8 Herramientas para ver las capas
🛠️ En la práctica
ping — capa 3 (ICMP).
$ ping google.com
PING google.com (142.250.10.139) 56(84) bytes of data.
64 bytes from ...: icmp_seq=1 ttl=109 time=20.4 ms
64 bytes from ...: icmp_seq=2 ttl=109 time=21.1 ms
Te dice si llegás al host y cuánto tarda el round-trip.
traceroute — capa 3 (ICMP / UDP).
$ traceroute google.com
1 router.casa (192.168.1.1) 1.2 ms
2 10.42.0.1 8.5 ms
3 isp-gw.tigo.com.sv 12.3 ms
...
10 google.com 20.4 ms
Cada salto es un router en el camino. Increíble para visualizar.
dig o nslookup — capa 7 (DNS).
$ dig google.com
;; ANSWER SECTION:
google.com. 300 IN A 142.250.10.139
netstat -tulpn — capa 4 (qué puertos están abiertos).
$ ss -tulpn # versión moderna
Netid State Local Address:Port Process
tcp LISTEN 0.0.0.0:22 sshd
tcp LISTEN 127.0.0.1:5432 postgres
tcpdump — capa 2 al 7 (captura de paquetes).
$ sudo tcpdump -i any port 80
14:33:21 IP cliente.50000 > server.80: Flags [S], seq 1234, ...
14:33:21 IP server.80 > cliente.50000: Flags [S.], seq 5678, ack 1235, ...
Wireshark — versión gráfica de tcpdump. Imprescindible para diagnóstico.
1.9 Resumen visual
| Capa | Modelo OSI | Modelo TCP/IP | Datos | Ejemplo |
|---|---|---|---|---|
| 7 | Aplicación | Aplicación | Mensaje | HTTP, DNS |
| 6 | Presentación | Aplicación | Mensaje | TLS, JSON |
| 5 | Sesión | Aplicación | Mensaje | (varía) |
| 4 | Transporte | Transporte | Segmento | TCP, UDP |
| 3 | Red | Internet | Paquete | IP, ICMP |
| 2 | Enlace | Acceso | Frame | Ethernet, WiFi |
| 1 | Física | Acceso | Bits | Cobre, fibra, radio |
| Idea clave | |
|---|---|
| Capas | Cada una hace una cosa, oculta detalles |
| Encapsulamiento | Cada capa agrega su header al bajar |
| MAC vs IP | MAC cambia cada salto, IP no |
| TCP vs UDP | Confiable vs no-confiable |
1.10 Ejercicios
✏️ Ejercicio 1.1 — Identificar la capa
Para cada protocolo, decí en qué capa de TCP/IP vive:
a. HTTP b. Ethernet c. IP d. UDP e. DNS f. WiFi (802.11)
Solución
a. Aplicación (HTTP construye sobre TCP). b. Acceso a red (es capa 2 OSI, capa 1 TCP/IP). c. Internet. d. Transporte. e. Aplicación (corre sobre UDP normalmente). f. Acceso a red.
✏️ Ejercicio 1.2 — Capas en la práctica
Ejecutá ping google.com, traceroute google.com, y dig google.com (en Linux/Mac). En cada uno:
a. ¿Qué capa de la pila están usando? b. ¿Qué te dicen sobre la red?
Solución
-
ping: usa ICMP (capa de Internet/red). Te dice si el destino responde y cuánto tarda. No usa TCP ni UDP. -
traceroute: usa ICMP/UDP (capa Internet, manipulando TTL). Te muestra cada salto del camino. Cada router es una IP, una empresa, posiblemente un país distinto. -
dig: usa DNS sobre UDP (capa aplicación + transporte). Te dice cómo se traducen nombres a IPs.
✏️ Ejercicio 1.3 — Diseñar un protocolo
Imaginate que tenés que diseñar un protocolo nuevo "MIRPC" para llamadas remotas a procedimientos. Decidí:
a. ¿Sobre qué capa de transporte lo construirías (TCP o UDP) y por qué? b. ¿Qué información mínima necesita la cabecera del protocolo? c. ¿Cómo manejarías un servidor que recibe muchas llamadas simultáneas?
Solución
a. Depende. Si las llamadas requieren respuesta confiable y orden (transferir un archivo, autenticar) → TCP. Si son consultas chicas, idempotentes, donde la pérdida ocasional no es problema (consultar un caché remoto) → UDP.
b. Mínimo:
- ID de llamada (para correlacionar pedido con respuesta).
- Nombre del procedimiento (qué función llamar).
- Argumentos (codificados en JSON, protobuf, etc.).
- Versión del protocolo.
- Status en la respuesta (OK / error).
c. Múltiples opciones:
- Threads — un thread por cliente.
- Pool de threads + cola de tareas.
- Async I/O (event loop, como Node.js, Python
asyncio). - Procesos separados — más caro pero aislados.
Esa decisión depende de la carga esperada y los recursos.
1.11 Para profundizar
- Tanenbaum & Wetherall, Computer Networks. Texto clásico, exhaustivo.
- Kurose & Ross, Computer Networking: A Top-Down Approach. El más accesible — empieza por aplicación.
- RFCs — los documentos originales: RFC 791 (IP), RFC 793 (TCP), RFC 7230 (HTTP/1.1). Difíciles pero la fuente de verdad.
- Próximo capítulo: Capa física y de enlace — cobre, fibra, radio, Ethernet, MAC, switches.
Definiciones nuevas: protocolo, capa, modelo OSI, modelo TCP/IP, encapsulamiento, header, frame, paquete, segmento, datagrama, salto físico, salto lógico, MAC vs IP, RFC.