Home / Sistemas / Del navegador al servidor: el viaje completo de una petición web
Del navegador al servidor: el viaje completo de una petición web

Del navegador al servidor: el viaje completo de una petición web

18 November 2026 · 25 min de lectura ··

Introducción: lo que ocurre antes de ver una página

Escribes una dirección en la barra del navegador, pulsas Enter y en uno o dos segundos aparece una página completa con texto, imágenes y botones que responden. Detrás de ese gesto cotidiano hay una cadena de al menos media docena de protocolos y decenas de máquinas colaborando sin que nadie las coordine de forma central. Entender esa cadena no es un lujo académico: es lo que te permite diagnosticar por qué una página tarda, por qué un certificado falla, por qué un cambio de DNS no se ve todavía o por qué una API devuelve un error que parece imposible.

Este tutorial recorre el viaje completo de una petición web, desde que el navegador interpreta la dirección hasta que pinta los píxeles. No nos quedaremos en la teoría: en cada etapa usaremos herramientas de línea de comandos como dig, curl, openssl y traceroute para ver con tus propios ojos qué sucede. Así podrás repetir los experimentos en tu máquina y comprobar que la web no es magia, sino una secuencia de acuerdos bien definidos.

Al terminar sabrás qué es un cliente y un servidor, cómo se estructura una URL, cómo se traduce un nombre en una dirección IP, cómo se abre una conexión fiable, cómo se negocia el cifrado, cómo se pide y se recibe un recurso, cómo los datos se parten en paquetes y cómo el navegador convierte HTML, CSS y JavaScript en una interfaz. También veremos los errores más habituales, consejos de rendimiento y una pequeña lista de comprobación para depurar problemas de red.

No necesitas experiencia previa en redes. Si tienes una terminal en Linux o macOS (o WSL en Windows) y curiosidad, tienes suficiente. Los ejemplos usan un dominio ficticio de pruebas para no depender de ningún servicio concreto, y puedes sustituirlo por cualquier sitio que administres.

El reparto de papeles: clientes, servidores y direcciones

La web funciona sobre un modelo sencillo: alguien pide y alguien responde. Quien pide se llama cliente; quien responde, servidor. El cliente casi siempre es un navegador, pero también puede ser una aplicación móvil, un script en Python, un comando curl o incluso otro servidor que consulta una API. Un servidor, por su parte, es simplemente un programa que escucha peticiones en una dirección y un puerto, normalmente alojado en una máquina que está encendida de forma permanente y conectada a Internet.

Para que dos máquinas se encuentren necesitan identificarse. Cada dispositivo conectado a una red lleva una dirección IP, un número que actúa como domicilio. Existen dos familias: IPv4, con cuatro grupos de números como 203.0.113.25, e IPv6, con direcciones más largas escritas en hexadecimal como 2001:db8::25. IPv4 ofrece un espacio limitado de direcciones, y por eso IPv6 se ha ido desplegando de manera progresiva; hoy es normal que un mismo servidor responda por ambas.

Tu proveedor de acceso a Internet (ISP) te asigna una IP pública, o te agrupa detrás de una compartida, y se encarga de conectar tu red doméstica con el resto del mundo. Los servidores, en cambio, suelen vivir en centros de datos o en plataformas en la nube, donde su dirección permanece estable durante largos periodos.

La dirección IP identifica la máquina, pero no el programa concreto con el que quieres hablar. Una misma máquina puede ejecutar un servidor web, un servidor de correo y una base de datos a la vez. Para distinguirlos se usan los puertos, números entre 0 y 65535 que funcionan como puertas numeradas de un edificio. Por convención, el tráfico web sin cifrar usa el puerto 80 y el cifrado usa el 443. Cuando escribes una dirección sin indicar puerto, el navegador elige el que corresponde al esquema.

Puedes ver qué está escuchando en tu propia máquina con una herramienta como ss:

$ ss -tlnp | head -n 5
State   Recv-Q  Send-Q  Local Address:Port  Peer Address:Port  Process
LISTEN  0       511     0.0.0.0:80          0.0.0.0:*          users:(("nginx",pid=812,fd=6))
LISTEN  0       511     0.0.0.0:443         0.0.0.0:*          users:(("nginx",pid=812,fd=7))
LISTEN  0       128     127.0.0.1:5432      0.0.0.0:*          users:(("postgres",pid=640,fd=5))

La salida muestra un servidor web atendiendo en los puertos 80 y 443, y una base de datos que solo acepta conexiones locales en el 5432. Esa diferencia entre 0.0.0.0 (todas las interfaces) y 127.0.0.1 (solo la propia máquina) es una de las primeras decisiones de seguridad que conviene entender.

Anatomía de una URL

Antes de que ocurra nada en la red, el navegador debe interpretar lo que escribiste. Una URL (localizador uniforme de recursos) es una dirección estructurada que dice qué protocolo usar, a quién hablar y qué se está pidiendo. Veamos una completa, escrita dentro de un bloque porque contiene un ejemplo literal:

https://blog.ejemplo.test:443/guias/redes?pagina=2&orden=reciente#conclusiones
\___/   \_______________/ \_/ \__________/ \_______________________/ \_________/
esquema      host        puerto   ruta            consulta            fragmento

Cada parte tiene un papel distinto:

  • El esquema (https) indica el protocolo de aplicación y, de forma implícita, si habrá cifrado.
  • El host (blog.ejemplo.test) es el nombre de la máquina o servicio al que se dirige la petición.
  • El puerto es opcional; si se omite, se usa el predeterminado del esquema.
  • La ruta (/guias/redes) identifica el recurso dentro del servidor.
  • La consulta (?pagina=2&orden=reciente) aporta parámetros en forma de pares clave y valor.
  • El fragmento (#conclusiones) no viaja al servidor: lo usa solo el navegador para desplazarse a una sección.

Este último detalle suele sorprender. Si inspeccionas el tráfico, nunca verás el fragmento en la petición, porque se resuelve en local. Es útil para anclas en documentos y para aplicaciones de una sola página que guardan estado de navegación sin recargar.

Dentro del host también hay estructura. En blog.ejemplo.test, test es el dominio de nivel superior, ejemplo es el dominio registrado y blog es un subdominio. Esa jerarquía, leída de derecha a izquierda, es exactamente la que sigue el sistema de nombres cuando traduce el nombre en una dirección, como veremos a continuación.

De nombre a dirección: cómo funciona DNS

Los humanos recordamos nombres; las redes necesitan números. El sistema de nombres de dominio (DNS) es la agenda distribuida que traduce uno en otro. No existe un único servidor con todos los nombres: es una jerarquía de servidores que se delegan responsabilidad unos a otros.

Cuando el navegador necesita la IP de un host, el proceso suele pasar por estas capas:

  1. La caché del propio navegador, que guarda respuestas recientes durante un tiempo limitado.
  2. La caché del sistema operativo y el archivo local de nombres.
  3. El resolvedor recursivo, normalmente el de tu ISP o uno público que hayas configurado. Es quien hace el trabajo pesado.
  4. Los servidores raíz, que no conocen el nombre pero saben quién gestiona cada dominio de nivel superior.
  5. Los servidores del dominio de nivel superior, que indican qué servidores son autoritativos para el dominio.
  6. El servidor autoritativo, que guarda el dato definitivo y lo entrega.

La respuesta vuelve por el mismo camino y cada capa la guarda en caché durante el tiempo que indica el valor TTL del registro. Gracias a esas cachés, la mayoría de las consultas se resuelven en milisegundos sin llegar nunca a la raíz.

Puedes observar la cadena completa con dig:

$ dig +trace blog.ejemplo.test A

.                    518400 IN NS a.root-servers.net.
test.                172800 IN NS ns1.registro-test.net.
ejemplo.test.        86400  IN NS ns1.proveedor-dns.net.
blog.ejemplo.test.   300    IN A  203.0.113.25

Cada línea muestra un salto: la raíz apunta al dominio de nivel superior, este apunta a los servidores del dominio y estos entregan la dirección final con un TTL de 300 segundos. El tipo de registro A devuelve una dirección IPv4; el AAAA, una IPv6. Otros tipos habituales son CNAME (alias hacia otro nombre), MX (correo) y TXT (texto libre, usado para verificaciones).

Los alias tienen una limitación con la que casi todos tropiezan alguna vez: la raíz de un dominio no admite registro CNAME por cómo está definido el protocolo. Si te has encontrado con ese problema al apuntar un dominio desnudo a un servicio externo, la explicación y las alternativas están en por qué la raíz de un dominio no puede ser un CNAME y qué usar.

Una consulta más corta, sin el recorrido, sirve para comprobar el resultado que ve tu resolvedor:

$ dig +short blog.ejemplo.test
203.0.113.25

Por qué un cambio de DNS tarda en notarse

Una confusión muy común es creer que, al cambiar un registro, todo el mundo lo ve de inmediato. En realidad cada resolvedor conserva la respuesta antigua hasta que expira su TTL. Si tu registro tenía un TTL de 86400 segundos, algunos usuarios seguirán viendo la IP anterior hasta un día después. La buena práctica antes de una migración es bajar el TTL a unos minutos con antelación, hacer el cambio y volver a subirlo cuando todo esté estable.

Abrir el canal: TCP y el saludo en tres pasos

Con la IP en la mano, el navegador debe establecer una conexión. La mayoría del tráfico web clásico viaja sobre TCP, un protocolo que garantiza que los datos llegan completos y en orden. Para lograrlo, antes de enviar nada, ambos extremos realizan un intercambio de tres mensajes conocido como saludo en tres pasos:

  1. El cliente envía un segmento SYN que dice: quiero hablar contigo.
  2. El servidor responde con SYN-ACK: te escucho, y yo también quiero hablar.
  3. El cliente confirma con un ACK, y la conexión queda abierta.

Cada una de esas idas y vueltas cuesta el tiempo de ida y vuelta (RTT) entre ambos puntos. Si el servidor está en otro continente, un RTT de 150 ms significa que solo abrir la conexión ya consume ese tiempo antes de pedir un solo byte. Por eso la distancia física importa y por eso existen las redes de distribución de contenido, que acercan copias de los recursos al usuario.

Puedes comprobar que un puerto acepta conexiones sin enviar ninguna petición HTTP:

$ nc -zv blog.ejemplo.test 443
Connection to blog.ejemplo.test (203.0.113.25) 443 port [tcp/https] succeeded!

Si el resultado fuera Connection timed out, sabrías que algo bloquea el camino, quizá un cortafuegos o un servicio caído. Si fuera Connection refused, la máquina responde pero no hay ningún programa escuchando en ese puerto. Distinguir ambos mensajes ahorra mucho tiempo de depuración.

Cifrar la conversación con TLS

Cuando la dirección empieza por https, tras abrir la conexión TCP ocurre otro intercambio: el saludo TLS. Su objetivo es doble. Primero, que el cliente verifique que habla de verdad con el servidor que dice ser. Segundo, que ambos acuerden claves para cifrar el resto de la conversación, de modo que nadie en el camino pueda leerla ni alterarla.

La versión estable y recomendada hoy es TLS 1.3, que simplificó el proceso respecto a las anteriores: reduce los viajes de ida y vuelta necesarios y elimina algoritmos considerados débiles. Las versiones antiguas, como TLS 1.0 y 1.1, están obsoletas y los navegadores modernos ya no las aceptan; si administras un servidor, lo sensato es ofrecer TLS 1.3 y, como mucho, mantener TLS 1.2 por compatibilidad.

El servidor presenta un certificado digital firmado por una autoridad de certificación en la que el navegador confía. Ese certificado enlaza un nombre de dominio con una clave pública. El navegador comprueba la firma, la fecha de validez y que el nombre coincide con el host solicitado. Con openssl puedes inspeccionar ese saludo:

$ openssl s_client -connect blog.ejemplo.test:443 -servername blog.ejemplo.test </dev/null 2>/dev/null | openssl x509 -noout -subject -issuer -dates
subject=CN = blog.ejemplo.test
issuer=C = US, O = Autoridad Ejemplo, CN = CA Intermedia Ejemplo
notBefore=Oct  1 00:00:00 2026 GMT
notAfter=Dec 30 23:59:59 2026 GMT

La opción -servername activa SNI, una extensión que permite al cliente indicar a qué host se dirige para que un servidor con muchos sitios en la misma IP entregue el certificado correcto. Los errores de certificado más frecuentes son tres: caducado, emitido para otro nombre y cadena de certificados intermedia incompleta. Con la salida anterior detectas los dos primeros en segundos.

Si quieres profundizar en lo que aporta el cifrado, las diferencias entre ambos esquemas y las prácticas recomendadas, te resultará útil HTTP frente a HTTPS: diferencias, seguridad y buenas prácticas, donde se desarrolla ese terreno con más detalle.

Pedir el recurso: el protocolo HTTP

Con el canal abierto y, si procede, cifrado, el navegador por fin habla el idioma de la web: HTTP. Es un protocolo de petición y respuesta basado en texto en sus versiones clásicas. El cliente envía una línea inicial con el método, la ruta y la versión, seguida de cabeceras con metadatos, y el servidor contesta con una línea de estado, sus propias cabeceras y, normalmente, un cuerpo.

Vamos a hacer a mano lo que hace el navegador, usando curl en modo detallado:

$ curl -v https://blog.ejemplo.test/guias/redes
> GET /guias/redes HTTP/2
> Host: blog.ejemplo.test
> User-Agent: curl/8.10.1
> Accept: */*
>
< HTTP/2 200
< content-type: text/html; charset=utf-8
< content-length: 18452
< cache-control: public, max-age=600
< server: nginx
<
<!doctype html>
<html lang="es">
...

Las líneas con > son lo que envía el cliente y las que llevan < son la respuesta. Observa varios elementos clave:

  • El método GET pide un recurso sin modificarlo. Otros métodos habituales son POST (crear o enviar datos), PUT y PATCH (actualizar), DELETE (borrar) y HEAD (pedir solo las cabeceras).
  • La cabecera Host permite que un mismo servidor aloje muchos sitios.
  • Accept informa de los formatos que el cliente puede procesar.
  • content-type dice cómo interpretar el cuerpo.
  • cache-control indica cuánto tiempo se puede reutilizar la respuesta sin volver a pedirla.

Los códigos de estado más importantes

La primera cifra del código de estado agrupa el significado de la respuesta. Memorizar las familias es suficiente para orientarte:

  • Los 1xx son informativos y poco frecuentes en el día a día.
  • Los 2xx indican éxito; 200 significa que todo fue bien y 201 que se creó un recurso.
  • Los 3xx indican redirección; 301 es un traslado permanente y 304 dice que lo que tienes en caché sigue siendo válido.
  • Los 4xx señalan un error del cliente; 400 es petición mal formada, 401 falta autenticación, 403 no hay permiso y 404 el recurso no existe.
  • Los 5xx indican un fallo del servidor; 500 es un error interno, 502 una puerta de enlace que recibió una respuesta inválida y 503 un servicio no disponible.

Un truco útil para depurar es pedir solo las cabeceras y observar si hay redirecciones:

$ curl -sI http://blog.ejemplo.test/guias/redes
HTTP/1.1 301 Moved Permanently
location: https://blog.ejemplo.test/guias/redes

Aquí el servidor ordena pasar de HTTP a HTTPS con un 301. Es el comportamiento recomendado para evitar que alguien use la versión sin cifrar.

Las versiones de HTTP

HTTP ha evolucionado para reducir la latencia. HTTP/1.1 abre conexiones que se reutilizan pero procesa las peticiones de forma secuencial en cada una. HTTP/2 multiplexa varias peticiones en una sola conexión TCP y comprime las cabeceras. HTTP/3, especificado en el RFC 9114, cambia el transporte: usa QUIC sobre UDP en lugar de TCP, integra TLS 1.3 en el propio protocolo de transporte y evita que la pérdida de un paquete bloquee todos los flujos a la vez. Puedes preguntar qué versión negocia un servidor con curl:

$ curl -sI --http3 https://blog.ejemplo.test | head -n 1
HTTP/3 200

Si tu compilación de curl no incluye soporte para HTTP/3, el comando fallará; no es un problema del servidor. Para un repaso más amplio del protocolo, sus mensajes y cómo ha evolucionado con las redes modernas, puedes consultar la guía completa del protocolo HTTP y redes web modernas.

Cómo viajan los datos: paquetes, IP y enrutamiento

Hasta aquí hemos hablado de mensajes como si cruzaran Internet de una pieza. No es así. Los datos se trocean en paquetes de tamaño limitado, y cada uno viaja de forma independiente, a menudo por caminos distintos, para recomponerse en el destino. Esta técnica, la conmutación de paquetes, es lo que hace robusta a Internet: si un enlace falla, los paquetes buscan otra ruta.

Dos capas se reparten el trabajo. El protocolo IP se ocupa del direccionamiento y del encaminamiento: cada paquete lleva la IP de origen y de destino, y los routers intermedios deciden a qué vecino reenviarlo. TCP se ocupa de la fiabilidad: numera los segmentos, confirma su recepción, retransmite los perdidos y los reordena al llegar. Por eso se habla de la pila TCP/IP.

Puedes ver los saltos que atraviesa un paquete con traceroute:

$ traceroute -n blog.ejemplo.test
 1  192.168.1.1    1.2 ms
 2  10.20.0.1      8.4 ms
 3  198.51.100.9   12.9 ms
 4  198.51.100.77  24.1 ms
 5  203.0.113.25   31.6 ms

Cada línea es un router y el tiempo es el que tarda en responder. Si de repente un salto añade cientos de milisegundos o la lista deja de avanzar, tienes una pista de dónde está el problema. Ten en cuenta que algunos routers no responden a esta sonda, de modo que ciertos asteriscos no implican fallo.

Hay una consecuencia práctica importante: los paquetes tienen un tamaño máximo llamado MTU, y cuando una respuesta es grande se fragmenta en muchos segmentos. De ahí que reducir el tamaño de lo que transmites, con compresión por ejemplo, acelere la carga de forma directa. Comprobémoslo:

$ curl -s -o /dev/null -w "sin compresion: %{size_download} bytes\n" https://blog.ejemplo.test/guias/redes
sin compresion: 18452 bytes

$ curl -s -o /dev/null -H "Accept-Encoding: gzip" -w "con gzip: %{size_download} bytes\n" https://blog.ejemplo.test/guias/redes
con gzip: 5120 bytes

La diferencia, de unos 18 KB a 5 KB, supone menos segmentos, menos retransmisiones potenciales y una carga más rápida, sobre todo en redes móviles inestables.

Del HTML a los píxeles: cómo renderiza el navegador

Recibir el documento HTML es solo el comienzo. El navegador lo lee de arriba abajo y, a medida que lo analiza, construye el modelo de objetos del documento (DOM), un árbol en el que cada etiqueta se convierte en un nodo. Al mismo tiempo, descubre que necesita otros recursos: hojas de estilo, scripts, imágenes y tipografías. Por cada uno lanza una petición adicional, reutilizando conexiones ya abiertas cuando puede.

Imagina esta página mínima:

<!doctype html>
<html lang="es">
<head>
  <meta charset="utf-8">
  <title>Panel de pedidos</title>
  <link rel="stylesheet" href="/estilos/panel.css">
  <script src="/js/panel.js" defer></script>
</head>
<body>
  <h1>Pedidos de hoy</h1>
  <ul id="lista"></ul>
  <img src="/img/logo.webp" alt="Logotipo" width="120" height="40">
</body>
</html>

Con solo este documento, el navegador deberá hacer al menos tres peticiones más: la hoja de estilo, el script y la imagen. Los pasos internos de renderizado son aproximadamente estos:

  1. Analiza el HTML y construye el DOM.
  2. Analiza el CSS y construye el modelo de estilos (CSSOM).
  3. Combina ambos en el árbol de renderizado, que contiene solo lo visible.
  4. Calcula la geometría de cada elemento (layout): tamaños y posiciones.
  5. Pinta los píxeles y los compone en capas para mostrarlos en pantalla.

Dos detalles afectan al rendimiento percibido. El CSS bloquea el renderizado: el navegador no pinta hasta tener los estilos, para evitar mostrar una página sin formato. El JavaScript, por defecto, bloquea el análisis del HTML mientras se descarga y se ejecuta; por eso el atributo defer del ejemplo es una buena práctica, ya que el script se descarga en paralelo y se ejecuta cuando el documento está analizado. Indicar width y height en las imágenes también evita saltos visuales cuando terminan de cargarse.

JavaScript y las peticiones posteriores

Una vez cargada, la página no tiene por qué quedarse quieta. El JavaScript puede pedir datos adicionales al servidor sin recargar, normalmente a una API que responde en JSON, y modificar el DOM con ellos. Es el mecanismo detrás de las aplicaciones modernas:

async function cargarPedidos() {
  const respuesta = await fetch("/api/pedidos?estado=pendiente");
  if (!respuesta.ok) {
    throw new Error(`Fallo ${respuesta.status}`);
  }
  const pedidos = await respuesta.json();
  const lista = document.querySelector("#lista");
  for (const pedido of pedidos) {
    const item = document.createElement("li");
    item.textContent = `${pedido.cliente}: ${pedido.total} EUR`;
    lista.append(item);
  }
}

cargarPedidos().catch(console.error);

Cada llamada a fetch repite el ciclo que hemos visto, aunque con muchos pasos acelerados: el DNS ya está en caché, la conexión TCP y la sesión TLS suelen reutilizarse y solo queda el viaje de petición y respuesta. Comprender esto explica por qué la primera visita a un sitio es siempre más lenta que las siguientes.

Reuniendo todo: el cronograma de una carga real

Podemos medir cuánto dura cada etapa con curl y su formato de salida, que expone los tiempos acumulados:

$ curl -s -o /dev/null -w "dns: %{time_namelookup}\ntcp: %{time_connect}\ntls: %{time_appconnect}\nprimer byte: %{time_starttransfer}\ntotal: %{time_total}\n" https://blog.ejemplo.test/guias/redes
dns: 0.021
tcp: 0.054
tls: 0.118
primer byte: 0.176
total: 0.203

Los valores son acumulados, así que restando obtenemos cada fase: unos 21 ms de DNS, 33 ms de conexión TCP, 64 ms de negociación TLS, 58 ms hasta recibir el primer byte (donde se incluye el tiempo de proceso del servidor) y 27 ms de descarga del cuerpo. Esta tabla mental es muy valiosa: si el DNS tarda demasiado, mira tu resolvedor; si el TLS es lento, revisa la distancia y la versión del protocolo; si el primer byte se retrasa, el problema es la aplicación o la base de datos y no la red.

El orden completo, de principio a fin, queda así:

  1. El navegador analiza la URL y comprueba cachés y reglas de seguridad como HSTS.
  2. Resuelve el nombre mediante DNS.
  3. Abre una conexión TCP, o QUIC si se usa HTTP/3.
  4. Negocia TLS y verifica el certificado.
  5. Envía la petición HTTP y recibe la respuesta.
  6. Analiza el HTML y pide los recursos adicionales.
  7. Construye DOM y CSSOM, calcula el diseño y pinta.
  8. Ejecuta JavaScript, que puede lanzar nuevas peticiones.

Cuando conoces esta secuencia, un síntoma vago como la página va lenta se transforma en una pregunta concreta: ¿en cuál de estos ocho pasos se pierde el tiempo?

Errores frecuentes y cómo diagnosticarlos

Muchos problemas web se repiten una y otra vez. Conocer su firma te permite ir directo a la causa.

El nombre no se resuelve

Síntoma: el navegador muestra que no puede encontrar el servidor. Comprueba con dig si el registro existe y si lo devuelven los servidores autoritativos. Si en tu equipo falla pero en otro resolvedor funciona, puede ser una caché local o un archivo de nombres con una entrada antigua.

$ dig +short blog.ejemplo.test @1.1.1.1
203.0.113.25
$ dig +short blog.ejemplo.test @192.168.1.1

Una respuesta vacía en un resolvedor y correcta en otro apunta a una caché desactualizada o a un filtrado local.

El certificado no es de confianza

Si el navegador advierte de que la conexión no es privada, revisa fechas, nombre y cadena con la orden de openssl mostrada antes. Un caso especialmente traicionero es el servidor que entrega el certificado correcto pero omite el intermedio: algunos clientes lo completan por su cuenta y otros fallan, lo que da la falsa impresión de un problema intermitente.

Contenido mixto

Una página servida con https que pide imágenes o scripts por http genera advertencias y los navegadores suelen bloquear los recursos activos. La solución es usar rutas relativas o esquema seguro en todos los recursos. En el código del servidor conviene además enviar la cabecera de seguridad de transporte estricta para forzar el uso de HTTPS:

server {
    listen 443 ssl;
    server_name blog.ejemplo.test;

    add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;
    add_header Content-Security-Policy "upgrade-insecure-requests" always;

    location / {
        root /var/www/blog;
        try_files $uri $uri/ =404;
    }
}

Errores 502 y 503 tras un proxy

Cuando un balanceador o un proxy inverso responde con 502, significa que él funciona pero el servicio que hay detrás no respondió bien. Revisa los registros de la aplicación, comprueba que el puerto de destino es el correcto y verifica con curl directamente a la aplicación, saltándote el proxy:

$ curl -sI http://127.0.0.1:3000/salud
HTTP/1.1 200 OK

Si la aplicación responde bien en directo pero falla a través del proxy, el problema está en la configuración intermedia: tiempos de espera, nombres de host o cabeceras.

CORS en llamadas desde el navegador

Una petición fetch hacia otro origen puede ser bloqueada por el navegador aunque el servidor responda con éxito. No es un error de red: es una política de seguridad que exige que el servidor autorice explícitamente al origen mediante cabeceras. Para comprobarlo, observa si la respuesta incluye la cabecera adecuada:

$ curl -sI -H "Origin: https://app.ejemplo.test" https://api.ejemplo.test/pedidos | grep -i access-control
access-control-allow-origin: https://app.ejemplo.test

Si la cabecera no aparece, el servidor no ha concedido permiso a ese origen y es el servidor el que debe ajustarse, no el cliente.

Rendimiento: dónde se gana el tiempo

Una vez que ves el recorrido, las optimizaciones dejan de parecer trucos sueltos y se ordenan por la etapa que mejoran.

Para reducir el coste de DNS, usa pocos dominios distintos en una misma página, porque cada uno añade una resolución. Las pistas de precarga del navegador pueden adelantar el trabajo para dominios que sí necesitas:

<link rel="dns-prefetch" href="//cdn.ejemplo.test">
<link rel="preconnect" href="https://cdn.ejemplo.test" crossorigin>
<link rel="preload" href="/fuentes/base.woff2" as="font" type="font/woff2" crossorigin>

Para reducir el coste de conexión y TLS, mantén las conexiones abiertas y reutilízalas, habilita HTTP/2 o HTTP/3 y utiliza reanudación de sesiones TLS. Acercar el contenido al usuario con una red de distribución disminuye el RTT, que como vimos multiplica cada paso del saludo.

Para reducir el volumen transferido, activa la compresión y sirve imágenes en formatos modernos y con las dimensiones adecuadas. Una imagen de varios megabytes mostrada a 300 píxeles de ancho es una de las causas más comunes de páginas pesadas.

Para evitar peticiones, aprovecha la caché. Una política bien pensada distingue entre recursos que casi nunca cambian y el documento principal:

location ~* \.(css|js|woff2|webp)$ {
    add_header Cache-Control "public, max-age=31536000, immutable";
}

location = /index.html {
    add_header Cache-Control "no-cache";
}

Los archivos estáticos con huella en el nombre (por ejemplo, con un hash) pueden cachearse un año, mientras que el HTML se revalida siempre con el servidor mediante validadores como ETag, que devuelve un 304 si nada cambió y ahorra transferir el cuerpo completo.

Para el renderizado, carga los scripts con defer o async, extrae el CSS crítico de la parte visible inicial y evita bloquear el hilo principal con tareas largas. Medir antes de optimizar es esencial: las herramientas de desarrollo del navegador, en su pestaña de red, muestran el mismo desglose por fases que obtuvimos con curl, pero para cada recurso de la página.

Seguridad básica en el recorrido

Cada etapa del viaje tiene también su riesgo, y conocerlos ayuda a diseñar con cabeza.

En DNS, un atacante puede intentar envenenar cachés para redirigir al usuario a un servidor falso. Las extensiones de firma de zonas y el uso de resolvedores que validan respuestas mitigan este riesgo. En el transporte, el tráfico sin cifrar puede ser leído y modificado por cualquiera en el camino, desde una red wifi pública hasta un intermediario malicioso; el cifrado con TLS y el uso estricto de HTTPS lo evitan. En la aplicación, cabeceras como Content-Security-Policy limitan qué scripts puede ejecutar la página, reduciendo el impacto de inyecciones de código.

Un conjunto mínimo de cabeceras de respuesta recomendable para cualquier sitio nuevo sería este:

$ curl -sI https://blog.ejemplo.test | grep -iE "strict|content-security|x-content|referrer"
strict-transport-security: max-age=31536000; includeSubDomains
content-security-policy: default-src 'self'
x-content-type-options: nosniff
referrer-policy: strict-origin-when-cross-origin

No son una solución definitiva, pero forman una primera línea de defensa casi gratuita. Recuerda también que las cookies de sesión deben marcarse como seguras y no accesibles desde JavaScript, y que nunca debes enviar credenciales en la propia URL, porque queda registrada en historiales y registros de servidor.

Práctica guiada: construye y observa tu propio servidor

Nada fija mejor estos conceptos que ver el ciclo completo en una máquina que controlas. Vamos a levantar un servidor mínimo en Node.js que registre cada petición y que podrás consultar con curl. Necesitas una versión de Node.js con soporte de largo plazo instalada.

Crea la siguiente estructura de proyecto:

laboratorio-web/
├── servidor.js
└── publico/
    ├── index.html
    └── estilos.css

El servidor devuelve archivos estáticos y registra método, ruta y duración:

import http from "node:http";
import { readFile } from "node:fs/promises";
import { extname, join, normalize } from "node:path";

const RAIZ = new URL("./publico/", import.meta.url).pathname;
const TIPOS = {
  ".html": "text/html; charset=utf-8",
  ".css": "text/css; charset=utf-8",
};

const servidor = http.createServer(async (req, res) => {
  const inicio = performance.now();
  const ruta = req.url === "/" ? "/index.html" : req.url.split("?")[0];
  const segura = normalize(ruta).replace(/^(\.\.[/\\])+/, "");

  try {
    const cuerpo = await readFile(join(RAIZ, segura));
    res.writeHead(200, {
      "Content-Type": TIPOS[extname(segura)] ?? "application/octet-stream",
      "Content-Length": cuerpo.length,
    });
    res.end(cuerpo);
  } catch {
    res.writeHead(404, { "Content-Type": "text/plain; charset=utf-8" });
    res.end("No encontrado");
  }

  const ms = (performance.now() - inicio).toFixed(1);
  console.log(`${req.method} ${req.url} -> ${res.statusCode} (${ms} ms)`);
});

servidor.listen(8080, "127.0.0.1", () => {
  console.log("Escuchando en el puerto 8080");
});

Arráncalo y haz peticiones desde otra terminal:

$ node servidor.js
Escuchando en el puerto 8080
GET / -> 200 (1.8 ms)
GET /estilos.css -> 200 (0.6 ms)
GET /no-existe -> 404 (0.4 ms)

Mientras tanto, desde el cliente:

$ curl -i http://127.0.0.1:8080/no-existe
HTTP/1.1 404 Not Found
Content-Type: text/plain; charset=utf-8
Content-Length: 13

No encontrado

Después abre la página en el navegador, ve a la pestaña de red de las herramientas de desarrollo y recarga. Verás una petición para el documento y otra para la hoja de estilo, tal como predice el modelo: el HTML llega primero y el navegador descubre el resto de recursos al analizarlo. Prueba a introducir un retraso artificial en el servidor y observa cómo el tiempo hasta el primer byte crece sin que cambien el DNS ni la conexión.

Algunas ideas para ampliar el ejercicio:

  • Añade una ruta /api/hora que devuelva JSON y consúmela con fetch desde la página.
  • Envía la cabecera Cache-Control y comprueba en la pestaña de red cuándo el navegador reutiliza el recurso.
  • Cambia el servidor para que escuche en 0.0.0.0 y accede desde otro dispositivo de tu red, comprendiendo antes el riesgo de exponerlo.
  • Simula un error 500 y observa cómo lo muestra el cliente.

Este laboratorio es deliberadamente pequeño, pero contiene todos los ingredientes: un cliente que pide, un servidor que escucha en un puerto, una respuesta con código de estado y cabeceras, y un navegador que encadena peticiones al interpretar el HTML.

Lista de comprobación para depurar una página que no carga

Cuando algo falla, avanza siguiendo el orden natural del viaje y no saltes etapas. Esta secuencia resuelve la inmensa mayoría de los casos:

  1. Verifica la URL: esquema, ortografía del host y puerto. Un error tipográfico es más común de lo que parece.
  2. Resuelve el nombre con dig contra más de un resolvedor y compara resultados.
  3. Prueba la conexión al puerto con nc para separar problemas de red de problemas de aplicación.
  4. Inspecciona el certificado con openssl si usas HTTPS.
  5. Lanza una petición con curl -v y lee el código de estado y las cabeceras.
  6. Si hay un proxy intermedio, consulta directamente a la aplicación para aislar el fallo.
  7. Revisa los registros del servidor en el instante de la petición.
  8. Abre las herramientas de desarrollo del navegador y busca recursos fallidos, bloqueos de CORS o contenido mixto.

Anota siempre el resultado de cada paso. Muchas veces el hallazgo importante no es qué falla, sino qué descartas: si la conexión TCP funciona y el certificado es válido, ya sabes que el problema está más arriba en la pila.

Conclusiones

La carga de una página web es una coreografía de varias capas con responsabilidades separadas. DNS convierte nombres en direcciones, TCP o QUIC establecen un canal fiable, TLS lo protege y verifica la identidad del servidor, HTTP define el lenguaje de petición y respuesta, y el navegador transforma el resultado en una interfaz visible. Cada capa puede medirse, inspeccionarse y depurarse por separado, y eso es precisamente lo que convierte un problema difuso en uno acotado.

Si te llevas una idea, que sea esta: ante cualquier fallo, pregunta en qué etapa ocurre. Herramientas tan modestas como dig, nc, openssl y curl bastan para contestar casi siempre. Con ese hábito, y con un modelo mental claro del recorrido completo, estarás mejor preparado para construir aplicaciones más rápidas, más seguras y más fáciles de mantener, sin depender de que el framework de turno te oculte lo que sucede debajo.

El siguiente paso natural es practicar: monta el laboratorio, mide los tiempos de tus propios sitios, activa la compresión y las cabeceras de seguridad, y experimenta con HTTP/2 y HTTP/3. Cada experimento reforzará la intuición sobre cómo viaja realmente la información por Internet.