← volver

Critical CSS inline con Playwright y caché en Nginx

Por · · [Tutoriales] · lectura estimada: ~5 min

El problema del CSS que bloquea el renderizado

Cuando un navegador encuentra una etiqueta <link rel="stylesheet"> en el <head>, detiene el renderizado hasta descargar e interpretar ese archivo. Si tu hoja de estilos principal pesa 150 KB, el usuario verá una pantalla en blanco durante cientos de milisegundos, especialmente en redes móviles lentas. Esta es la causa principal de un mal Lighthouse Performance y de un LCP (Largest Contentful Paint) deficiente.

La solución clásica es inline del CSS crítico: incrustar únicamente los estilos necesarios para renderizar el contenido visible (above-the-fold) directamente en el HTML. El resto del CSS se carga de forma diferida. El problema es que mantener ese CSS crítico a mano es insostenible. Cualquier cambio en tu diseño requiere regenerarlo manualmente. Aquí entra Playwright, no como herramienta de testing, sino como motor de renderizado para extraer el CSS usado.

Arquitectura de la solución

El flujo que vamos a implementar consta de tres fases:

  1. Generación dinámica: Un script Node.js con Playwright abre tu página en un viewport de 1350x900 (el más común), intercepta todas las reglas CSS aplicadas y las extrae.
  2. Inyección en HTML: El script inserta el CSS extraído dentro de una etiqueta <style> en el <head> y añade la carga diferida del CSS completo.
  3. Caché inteligente en Nginx: Como el CSS crítico depende del HTML (no es un archivo estático), no podemos usar cabeceras de caché normales. Usaremos sub_filter para inyectar el CSS en tiempo real o serviremos el HTML pre-procesado con validación por hash.

Paso 1: El generador con Playwright

Primero, instala las dependencias en tu proyecto:

npm init -y
npm install playwright @playwright/test
npx playwright install chromium

Ahora crea critical-css.mjs. La clave está en usar page.evaluate() para recorrer todas las hojas de estilo y recopilar las reglas que aplican a elementos visibles. Playwright ya ha renderizado el DOM, así que podemos preguntar al navegador qué estilos se usan realmente.

import { chromium } from 'playwright';
import fs from 'fs/promises';

const URL = ‘https://tu-sitio.com’; const VIEWPORT = { width: 1350, height: 900 };

const browser = await chromium.launch(); const page = await browser.newPage({ viewport: VIEWPORT });

// Bloquea recursos pesados para acelerar await page.route(’**/*.{png,jpg,jpeg,gif,svg,woff2}’, route => route.abort());

await page.goto(URL, { waitUntil: ‘networkidle’ });

const criticalCSS = await page.evaluate(() => { let cssText = ”; const walker = document.createTreeWalker(document.body, NodeFilter.SHOW_ELEMENT); const usedSelectors = new Set();

// Recorre todos los elementos visibles while (walker.nextNode()) { const el = walker.currentNode; const rect = el.getBoundingClientRect(); if (rect.top < window.innerHeight && rect.bottom > 0) { // Busca en todas las hojas de estilo for (const sheet of document.styleSheets) { try { const rules = sheet.cssRules; for (const rule of rules) { if (rule.selectorText && el.matches(rule.selectorText)) { usedSelectors.add(rule.cssText); } } } catch (e) { /* CSS cross-origin ignorado */ } } } } return Array.from(usedSelectors).join(‘\n’); });

await browser.close();

// Guardar el CSS crítico await fs.writeFile(‘critical.css’, criticalCSS); console.log(CSS crítico generado: ${criticalCSS.length} bytes);

Este script tiene una limitación: solo captura el CSS de los elementos visibles en el viewport inicial. Para páginas con scroll infinito o pestañas dinámicas, deberás hacer scroll manual con page.mouse.wheel() en varios pasos. Amplía el bucle con desplazamientos de 500px hasta el final de la página.

Paso 2: Inyección y carga diferida del resto

Una vez tienes critical.css, necesitas un script que transforme tu HTML final. Puedes integrarlo en tu build de Node, o si usas un CMS, en un hook de publicación. La idea es:

import fs from 'fs/promises';

const html = await fs.readFile(‘dist/index.html’, ‘utf-8’); const critical = await fs.readFile(‘critical.css’, ‘utf-8’);

// 1. Inserta el CSS crítico en el head const withInline = html.replace( ’</head>’, &lt;style id="critical-css"&gt;${critical}&lt;/style&gt;&lt;/head&gt; );

// 2. Modifica el link original para que cargue de forma diferida const finalHtml = withInline.replace( ‘<link rel=“stylesheet” href=“/css/app.css”>’, &lt;link rel="preload" href="/css/app.css" as="style" onload="this.onload=null;this.rel='stylesheet'"&gt; &lt;noscript&gt;&lt;link rel="stylesheet" href="/css/app.css"&gt;&lt;/noscript&gt; );

await fs.writeFile(‘dist/index.html’, finalHtml);

El truco de preload con onload es un patrón clásico para cargar CSS sin bloquear. El navegador descarga el archivo en paralelo y lo aplica cuando termina, pero no detiene el primer render. El noscript asegura que los usuarios sin JavaScript tengan los estilos completos.

Paso 3: Almacenamiento en caché en Nginx

Ahora llega la parte delicada. Si generas el HTML estático con el CSS inline, puedes cachearlo como cualquier archivo. Pero si tu sitio es dinámico (PHP, Node, etc.), no quieres ejecutar el generador en cada petición. La solución es un caché por URL con invalidación por tiempo.

Configura Nginx para que sirva el HTML procesado desde un directorio temporal, y solo ejecute el generador si el archivo no existe o es antiguo. Este es un patrón con try_files y un script externo:

server {
    listen 80;
    server_name tudominio.com;
# Ruta donde guardamos los HTML con CSS inline
location / {
    root /var/www/critical-cache;
    try_files $uri @generate-critical;
}

# Genera el HTML con CSS crítico si no existe o tiene más de 1 hora
location @generate-critical {
    # Ejecuta el script de Playwright (Node.js)
    content_by_lua_block {
        local handle = io.popen("node /opt/scripts/generate-critical.mjs " .. ngx.var.request_uri)
        local result = handle:read("*a")
        handle:close()
        ngx.print(result)
    }
    # Guarda en caché por 1 hora
    expires 1h;
    add_header Cache-Control "public, must-revalidate";
}

# El CSS completo se sirve con caché larga (inmutable)
location ~* \.(css|js)$ {
    root /var/www/site;
    expires 1y;
    add_header Cache-Control "public, immutable";
}

}

Este ejemplo usa content_by_lua_block (requiere OpenResty o ngx_http_lua_module). Si no lo tienes, puedes usar un script CGI o PHP que llame a Node. La lógica es simple: primera petición genera el HTML y lo guarda en /var/www/critical-cache/; las siguientes peticiones lo sirven directo desde disco, sin ejecutar Playwright.

Paso 4: Cabeceras de caché para el CSS crítico

El CSS inline no es un archivo separado, por lo que no tiene cabeceras HTTP propias. Pero el HTML que lo contiene sí las tiene. Aquí hay una decisión clave:

  • HTML con Cache-Control: no-cache: Siempre revalida en el servidor. Si el CSS crítico cambió (por un rediseño), el navegador recibe el HTML nuevo. Es lo más seguro.
  • HTML con Cache-Control: max-age=3600: El navegador no pedirá el HTML durante 1 hora. Útil si tu CSS cambia poco, pero puedes dejar a usuarios con CSS antiguo durante ese tiempo.

Te recomiendo la primera opción combinada con ETag. El CSS crítico es pequeño (normalmente 10-30 KB), así que revalidar el HTML no supone una gran carga. Nginx lo hace automáticamente si dejas el etag on; por defecto.

Paso 5: Automatización y monitorización

No quieres ejecutar el script manualmente cada vez que cambies un color. Integra la generación en tu pipeline de CI/CD. Por ejemplo, en GitHub Actions:

name: Generate Critical CSS
on:
  push:
    branches: [main]
jobs

comentarios(0)

$ dejar comentario

סHola! Soy SylonBot. Si te pierdes en el artículo, pregúntame 👋
☕ invítame a un café Si el contenido te fue útil · via PayPal