# renderizado del lado del servidor

## Qué es

El renderizado del lado del servidor, normalmente abreviado como SSR, consiste en producir el HTML de una página en el servidor en el momento en que alguien la solicita. El navegador recibe un documento completo, con el contenido ya colocado, y puede mostrarlo antes de que se haya ejecutado ningún script. En un framework de JavaScript, los mismos componentes se ejecutan después una segunda vez en el navegador, que toma el control del HTML recibido y lo hace interactivo.

El término responde a una pregunta sobre el momento y el lugar: ¿cuándo y dónde se crea el HTML? Hay tres respuestas habituales. Un generador de sitios estáticos lo crea una vez, durante la construcción, y sirve el mismo archivo a todo el mundo. El renderizado del lado del servidor lo crea en el servidor para cada solicitud, por lo que la página puede depender de quién la pide y de lo que digan los datos en ese momento. El renderizado del lado del cliente, a menudo llamado CSR, envía un documento casi vacío y un paquete de JavaScript que construye la página en el navegador. Las aplicaciones reales suelen combinar las tres modalidades, ruta por ruta.

Next.js lo explica de la misma manera. Su documentación utiliza renderizado dinámico como otro nombre para SSR y dice que el HTML de la página se genera en cada solicitud. En el Pages Router, una página lo activa exportando una función asíncrona llamada `getServerSideProps`, que el servidor llama en cada solicitud. Su función hermana, `getStaticProps`, hace ese trabajo una sola vez, durante la construcción. React aporta la maquinaria subyacente. Sus API `react-dom/server` convierten un árbol de componentes en HTML en el servidor, ya sea como flujo, con `renderToPipeableStream` para Node.js y `renderToReadableStream` para Web Streams, o en una sola pieza con la antigua `renderToString`, que React clasifica como una API heredada de funcionalidad limitada.

La segunda mitad ocurre en el navegador y se llama hidratación. Next.js describe así la primera carga: el HTML ofrece una vista previa rápida y no interactiva, y después JavaScript hidrata los componentes. Define esa hidratación como la conexión que hace React entre los manejadores de eventos y el DOM existente para que la página responda a las entradas del usuario. La referencia de React sobre `hydrateRoot` expone la contrapartida con franqueza. La instantánea HTML hace que la aplicación parezca cargar antes, y la página parece lista un momento antes de estarlo.

## Por qué importa

El contenido está en la primera respuesta. Una persona con una conexión lenta ve texto e imágenes mientras JavaScript aún está en camino, y un rastreador que no ejecuta JavaScript ve la misma página que una persona, en lugar de una estructura vacía. El navegador no tiene que ejecutar un script y después obtener datos antes de poder mostrar contenido real.

La página también puede depender de la solicitud, lo que la distingue de una construcción estática. Next.js recomienda `getServerSideProps` para datos específicos del usuario o que solo se conocen al recibir la solicitud, como una cabecera de autorización o la ubicación del visitante, y orienta todo lo demás hacia la generación durante la construcción. Los datos se obtienen cerca de donde residen. El código de esa función solo se ejecuta en el servidor, sus importaciones no se incluyen en el paquete del cliente y puede consultar directamente una base de datos o un sistema de gestión de contenidos. Una ida y vuelta al servidor puede sustituir a las solicitudes que, de otro modo, el navegador haría una tras otra después de cargar sus scripts.

Los costes son la contrapartida de los ahorros de un sitio estático. Tiene que haber un servidor en ejecución, que vuelve a renderizar con cada solicitud. La respuesta solo puede empezar cuando están disponibles los datos: sin transmisión progresiva, la consulta más lenta marca el ritmo de toda la página. Y el renderizado en el servidor no elimina JavaScript. El navegador sigue descargando todos los componentes que debe hidratar y, hasta que termina la hidratación, un botón puede aparecer en pantalla y no hacer nada.

Por eso la elección corresponde a cada página, no a todo el proyecto. Una página idéntica para todos sus lectores gana poco si se vuelve a renderizar en cada solicitud. SSR justifica su servidor cuando la página cambia según el lector o según datos que varían de un minuto a otro. Este sitio está en el extremo estático. Su conjunto de tecnologías prioriza lo estático cuando encaja, para que esas páginas no requieran ejecutar una aplicación al atender una solicitud, y Hugo construye el sitio.

## Cómo se aplica en la práctica

La página siguiente, escrita para este artículo, utiliza el Pages Router. Enumera los pedidos de un cliente que ha iniciado sesión, envía a quien no tenga sesión a la página de acceso e indica a todas las cachés que no guarden el resultado. `readSession` y `db` representan los mecanismos que la aplicación utilice para las sesiones y los datos.

```jsx
// pages/orders.js
export async function getServerSideProps({ req, res }) {
  const session = await readSession(req.cookies.session);
  if (!session) {
    return { redirect: { destination: "/sign-in", permanent: false } };
  }

  const rows = await db.orders.listFor(session.userId);
  res.setHeader("Cache-Control", "no-store");

  return {
    props: {
      orders: rows.map((o) => ({
        id: o.id,
        number: o.number,
        status: o.status,
      })),
    },
  };
}

export default function Orders({ orders }) {
  return (
    <ul>
      {orders.map((o) => (
        <li key={o.id}>
          {o.number}: {o.status}
        </li>
      ))}
    </ul>
  );
}
```

Next.js ejecuta la función en cada solicitud a `/orders`. `req.cookies` es la cabecera de cookies de la solicitud, ya analizada. Un `redirect` con `permanent: false` es una redirección temporal, no permanente. Todo lo devuelto bajo `props` tiene que poder serializarse con `JSON.stringify` y también llega al navegador como parte del HTML inicial, para que React hidrate la lista con los mismos datos que utilizó el servidor. Por eso la función reduce cada fila a los tres campos que muestra la página, en lugar de devolver directamente las filas de la base de datos. Cuando más adelante una persona llega mediante un enlace `next/link`, Next.js pide al servidor que vuelva a ejecutar la función y recibe las propiedades como JSON, sin cargar de nuevo la página completa.

En el trabajo actual de la fundadora en NextMariner, el frontend en Next.js 16 muestra el problema que esto resuelve. Su entrada del portfolio parte de un panel con autenticación que debía resultar ágil y mantenerse interactivo. Obtenerlo todo en el navegador ralentiza la primera carga e introduce el patrón N+1: cada componente se activa y envía su propia solicitud, de modo que una sola página se convierte en una cascada de idas y vueltas. En ese panel y en los grandes listados del directorio, una factoría llamada `createPrefetchedServerPage` obtiene ahora los datos de la página en el servidor y los entrega al cliente ya cargados. Los componentes arrancan con sus datos, en lugar de salir cada uno a pedirlos. Las páginas trasladadas a la factoría aparecen con una sola ida y vuelta, en lugar de una avalancha de ellas. La misma entrada conserva las otras dos modalidades donde encajan: las páginas públicas se generan estáticamente porque no cambian entre usuarios, y las partes realmente interactivas siguen renderizándose en el cliente. También documenta una estrategia de invalidación de caché para cada solicitud de datos, de modo que los datos se mantengan actualizados sin volver a obtener lo que la aplicación ya tiene.

## Dónde surgen los problemas

El servidor y el navegador no coinciden. La hidratación espera que el primer renderizado del navegador produzca el mismo resultado que el del servidor. Un componente que comprueba `typeof window`, llama a `window.matchMedia` durante el renderizado o imprime la hora actual produce una cosa en el servidor y otra en el navegador. La lista de causas de React también incluye datos distintos en ambos lados y espacios en blanco sobrantes dentro del elemento raíz. En el mejor de los casos, la discrepancia ralentiza la hidratación; en el peor, los manejadores de eventos quedan conectados a elementos equivocados. Por eso, la referencia de `hydrateRoot` dice con claridad: «Debe tratar las discrepancias como errores y corregirlas». Renderice lo mismo en ambos lados. Cuando el navegador deba mostrar realmente algo distinto, renderice primero la versión del servidor y cámbiela en un efecto después de la hidratación, lo que cuesta un segundo renderizado. Reserve `suppressHydrationWarning` para diferencias inevitables, como una marca de tiempo, y recuerde que solo funciona a un nivel de profundidad.

Los secretos viajan en las propiedades. Todo lo que se devuelve como propiedades se escribe en el HTML inicial para que el navegador pueda hidratar, y la documentación de Next.js advierte de que no se debe enviar así información sensible. Una función que devuelve un registro de usuario completo entrega su hash de contraseña y sus indicadores internos a cualquiera que abra el código fuente de la página. Devuelva únicamente los campos que muestra la página, como hace el ejemplo anterior.

Una caché compartida sirve la página de un lector al siguiente. La documentación de Next.js ilustra el almacenamiento en caché de páginas renderizadas en el servidor con `Cache-Control: public, s-maxage=10, stale-while-revalidate=59`. Copiada en una página personalizada, esa cabecera permite que una red de distribución de contenido o un proxy situado delante del servidor conserve la respuesta y la entregue a quien la pida después. La RFC 9111 define `public` como permiso para que una caché guarde una respuesta que de otro modo rechazaría, y `s-maxage` como un tiempo de vigencia destinado a cachés compartidas. Cualquiera de las dos directivas también levanta la prohibición de que una caché compartida reutilice una respuesta a una solicitud que incluía una cabecera `Authorization`. Una página construida a partir de cookies o credenciales necesita `private`, que prohíbe a las cachés compartidas guardarla, o `no-store`, que lo prohíbe a todas las cachés.

La consulta más lenta retiene la página. Si se renderiza en una sola pieza, la página no envía nada hasta que han terminado todas las consultas que necesita. Una sola consulta lenta retrasa así la cabecera, la navegación y todo lo demás. El renderizador progresivo de React divide la página por los límites de `<Suspense>`. Envía la estructura base, todo lo que queda fuera de cualquier límite, en cuanto está lista y con contenido provisional en su lugar. Después transmite cada parte restante con un pequeño script en línea que sustituye el contenido provisional por ella. Enviar pronto tiene una consecuencia: una vez iniciada la transmisión, ya no puede cambiar el código de estado. Por tanto, un registro inexistente o una comprobación fallida deben resolverse antes de enviar la estructura base, y `onShellError` es donde se establece un estado de error.

## Lecturas adicionales
* Renderizado del lado del servidor (SSR) — Next.js sobre el HTML generado en cada solicitud y la diferencia entre `getServerSideProps` y `getStaticProps`.
* getServerSideProps — cuándo utilizarlo, qué llega al cliente en el HTML inicial y el almacenamiento en caché con `Cache-Control`.
* API de React DOM para servidores — las API de transmisión progresiva y heredadas que ofrece React para renderizar componentes como HTML en el servidor.
* hydrateRoot — cómo React toma el control del HTML renderizado en el servidor y las causas habituales de discrepancias de hidratación.
* renderToPipeableStream — la estructura base, los límites de `<Suspense>` y la limitación del código de estado al transmitir progresivamente.
* RFC 9111: almacenamiento en caché HTTP — las directivas `public`, `private`, `s-maxage` y `no-store`, y las reglas para cachés compartidas.

=> /es/tech-stack/ conjunto de tecnologías
=> /es/portfolio/built-the-next-js-16-frontend-ssr-ssg-and-csr/ Su entrada del portfolio
=> https://nextjs.org/docs/pages/building-your-application/rendering/server-side-rendering Renderizado del lado del servidor (SSR)
=> https://nextjs.org/docs/pages/building-your-application/data-fetching/get-server-side-props getServerSideProps
=> https://react.dev/reference/react-dom/server API de React DOM para servidores
=> https://react.dev/reference/react-dom/client/hydrateRoot hydrateRoot
=> https://react.dev/reference/react-dom/server/renderToPipeableStream renderToPipeableStream
=> https://www.rfc-editor.org/rfc/rfc9111.html RFC 9111: almacenamiento en caché HTTP

=> https://engineer.company/es/glossary/server-side-rendering/ Esta página en la web
