Saltar al contenido
hg.Héctor GarridoCiencia de datos · Estadística · Ingeniería de datos
← Volver al blog
Portafolio RAG

Optimización de Rendimiento Frontend: Code Splitting, Pre-renderizado y Caché Docker

Este artículo técnico aborda la optimización del rendimiento frontend en una aplicación React, resolviendo problemas de carga inicial lenta y uso ineficiente de la caché. Se implementa *code splitting* con `React.lazy()` para reducir el tamaño del bundle inicial y se configura una estrategia de caché en Nginx para servir archivos estáticos de manera eficiente. Aprenderás a mejorar significativamente los tiempos de carga y la experiencia del usuario, optimizando tanto el código JavaScript como la configuración del servidor web.

Optimización de Rendimiento Frontend: Code Splitting, Pre-renderizado y Caché Docker

Nivel 1: Code Splitting con React.lazy()

Diagnóstico

El problema del bundle monolítico es típico de las SPAs creadas con Create React App sin optimización. Webpack empaqueta todo el código JavaScript en un único archivo:

// App.js (antes)
import Home from './pages/Home';
import PostList from './pages/PostList';
import PostDetail from './pages/PostDetail';
import CV from './pages/CV';
import Contact from './pages/Contact';
import RagSearch from './pages/RagSearch';
import Login from './pages/Login';

Resultado: 357 KB que incluyen: - Todas las páginas (incluso las que el usuario nunca visitará) - Material UI completo - react-markdown + KaTeX - framer-motion - Axios

El navegador descarga todo esto antes de mostrar la primera pantalla.

Solución: Lazy Loading con React.lazy() + Suspense

React 18 incluye React.lazy() que permite cargar componentes bajo demanda (cuando el usuario navega a esa ruta):

// App.js (después)
import React, { Suspense, lazy } from 'react';
import { CircularProgress, Box } from '@mui/material';

const Home = lazy(() => import('./pages/Home'));
const PostList = lazy(() => import('./pages/PostList'));
const PostDetail = lazy(() => import('./pages/PostDetail'));
const CV = lazy(() => import('./pages/CV'));
const Contact = lazy(() => import('./pages/Contact'));
const RagSearch = lazy(() => import('./pages/RagSearch'));
const Login = lazy(() => import('./pages/Login'));

// Fallback mientras se carga el componente
const PageLoader = () => (
  <Box sx={{ display: 'flex', justifyContent: 'center', alignItems: 'center', minHeight: '60vh' }}>
    <CircularProgress />
  </Box>
);

function App() {
  return (
    <Suspense fallback={<PageLoader />}>
      <Routes>
        <Route path="/" element={<Home />} />
        <Route path="/blog" element={<PostList />} />
        {/* ... */}
      </Routes>
    </Suspense>
  );
}

Claves del diseño: - React.lazy(() => import(...)): Import dinámico que Webpack detecta y separa en chunks independientes. - <Suspense fallback={...}>: Muestra el loader mientras se descarga el chunk de la página. - Zero-config con CRA: Webpack automáticamente genera archivos separados (código split).

Resultado

Build output después de implementar code splitting:

File sizes after gzip:

  105.62 kB  build/static/js/381.f7044c6b.chunk.js    # Main bundle (antes: 357 KB)
  76.19 kB   build/static/js/487.fca03cc4.chunk.js    # CV page
  15.2 kB    build/static/js/722.84d17e05.chunk.js    # PostDetail
  12.09 kB   build/static/js/594.dd72306a.chunk.js    # RagSearch
  8.43 kB    build/static/js/673.f8a779e7.chunk.js    # Home
  7.25 kB    build/static/js/366.8faf91af.chunk.js    # PostList
  ...

Reducción del 70%: 357 KB → 105 KB en el bundle principal. El resto se carga solo cuando el usuario navega a esas páginas.


Nivel 2: Nginx Cache Optimization

Diagnóstico

El Dockerfile del frontend usa Nginx para servir los archivos estáticos, pero no tenía configuración de caché. Resultado:

  • Assets con hash (main.abc123.js) se re-descargaban en cada visita, aunque nunca cambian entre deploys.
  • Sin gzip: Archivos grandes (JS, CSS) sin comprimir.
  • index.html sin estrategia: Se cacheaba o no, dependiendo del navegador.

Solución: Estrategia de Caché en Tres Niveles

Actualicé nginx.conf con una estrategia de caché diferenciada:

server {
    listen 8080;
    server_name _;
    root /usr/share/nginx/html;
    index index.html;

    # --- NIVEL 1: Gzip para archivos de texto ---
    gzip on;
    gzip_vary on;
    gzip_min_length 256;
    gzip_comp_level 6;
    gzip_types
      text/plain
      text/css
      text/javascript
      application/javascript
      application/json
      application/xml+rss
      image/svg+xml
      font/woff2;

    # --- NIVEL 2: Assets hasheados (inmutables) ---
    location /static/ {
        expires 1y;
        add_header Cache-Control "public, immutable";
    }

    # --- NIVEL 3: Imágenes (cache moderado) ---
    location /images/ {
        expires 30d;
        add_header Cache-Control "public";
    }

    # --- NIVEL 4: index.html (sin caché) ---
    location / {
        try_files $uri $uri/ /index.html;
        add_header Cache-Control "no-cache";
    }
}

Claves del diseño: - /static/ con immutable: CRA genera archivos con hash (ej: main.abc123.js). Si el contenido cambia, el hash cambia. Podemos cachear por 1 año con seguridad. - /images/ con 30 días: Imágenes (logos, covers) cambian ocasionalmente, pero no en cada deploy. - index.html con no-cache: Debe verificarse en cada visita para que nuevos deploys sean inmediatos. - Gzip level 6: Balance entre compresión (CPU) y tamaño. Reduce JS/CSS ~70%.

Resultado

Antes (sin caché):

GET /static/js/main.abc123.js  → 200 OK (357 KB, 2.5s)
[Usuario recarga la página]
GET /static/js/main.abc123.js  → 200 OK (357 KB, 2.5s)  ← Re-descarga total

Después (con caché):

GET /static/js/main.abc123.js  → 200 OK (105 KB gzip, 0.8s)
[Usuario recarga la página]
GET /static/js/main.abc123.js  → 304 Not Modified (from cache, 0ms)

Nivel 3: Pre-renderizado con react-snap

Diagnóstico

El problema SEO de las SPAs es conocido: el HTML inicial está vacío porque el contenido se genera con JavaScript. Los crawlers modernos ejecutan JS, pero:

  1. Es lento: Google puede tardar días en indexar contenido JS-generated.
  2. No es perfecto: Algunos bots (Twitter, LinkedIn) no ejecutan JS.
  3. LCP afectado: Largest Contentful Paint comienza después de descargar + ejecutar JS.

Mi blog enviaba esto al navegador:

<!DOCTYPE html>
<html lang="es">
<head>
  <title>Blog Personal</title>
</head>
<body>
  <div id="root"></div>  <!-- Vacío -->
  <script src="/static/js/main.abc123.js"></script>
</body>
</html>

Solución: react-snap + hydrateRoot

react-snap es una herramienta que usa Puppeteer (Chromium headless) para: 1. Ejecutar la app React en un navegador simulado 2. Capturar el HTML renderizado de cada ruta 3. Guardar esos archivos HTML estáticos en build/

Paso 1: Configurar react-snap en package.json

{
  "scripts": {
    "build": "react-scripts build && react-snap"
  },
  "reactSnap": {
    "include": ["/ai-search", "/login"],
    "minifyHtml": {
      "collapseWhitespace": false,
      "removeComments": false
    },
    "puppeteerArgs": ["--no-sandbox", "--disable-setuid-sandbox"],
    "skipThirdPartyRequests": true,
    "crawl": false,
    "timeout": 10000
  }
}

Claves: - include: Solo rutas estáticas que no hacen llamadas API ni usan animaciones bloqueantes. Las rutas /, /blog, /cv y /contact se excluyen porque cuelgan Puppeteer (ver post 11 para el detalle completo). - crawl: false: Desactiva el descubrimiento automático de rutas desde links del navbar. - timeout: 10000: Límite de 10s por página para evitar builds infinitos. - puppeteerArgs: Necesarios para Docker (Alpine Linux sin sandbox). - skipThirdPartyRequests: Acelera el pre-renderizado.

Paso 2: Actualizar index.js para hidratación

React 18 distingue entre crear una app desde cero (createRoot) y "hidratar" HTML pre-existente (hydrateRoot):

// index.js (después)
import { createRoot, hydrateRoot } from 'react-dom/client';

const rootElement = document.getElementById('root');

if (rootElement.hasChildNodes()) {
  // HTML pre-renderizado existe → hidratar
  hydrateRoot(rootElement, <App />);
} else {
  // HTML vacío (dev) → renderizar desde cero
  createRoot(rootElement).render(<App />);
}

Diferencia clave: - hydrateRoot: Asume que el HTML ya existe y solo "conecta" los event listeners. - createRoot: Genera el HTML desde cero.

En producción (con react-snap), el HTML ya existe. En desarrollo (localhost), no.

Paso 3: Actualizar Dockerfile para instalar Chromium

react-snap necesita Chromium, que no viene por defecto en Alpine Linux:

FROM node:18-alpine AS build
WORKDIR /app

# Instalar Chromium para Puppeteer (react-snap)
RUN apk add --no-cache chromium

# Configurar Puppeteer para usar Chromium del sistema
ENV PUPPETEER_SKIP_CHROMIUM_DOWNLOAD=true
ENV PUPPETEER_EXECUTABLE_PATH=/usr/bin/chromium-browser

COPY package*.json ./
RUN npm ci --production

COPY . .
RUN npm run build  # Ejecuta react-scripts build && react-snap

# --- Stage 2: Nginx ---
FROM nginx:1.25-alpine
COPY --from=build /app/build /usr/share/nginx/html
COPY nginx.conf /etc/nginx/conf.d/default.conf
EXPOSE 8080
CMD ["nginx", "-g", "daemon off;"]

Resultado

HTML generado para / (Home):

<!DOCTYPE html>
<html lang="es">
<head>
  <title>Héctor Garrido Henríquez | Blog Personal</title>
  <meta name="description" content="Blog personal sobre ciencia de datos..." />
</head>
<body>
  <div id="root">
    <div class="MuiBox-root">
      <h1>Héctor Garrido Henríquez</h1>
      <p>Data Scientist especializado en econometría...</p>
      <!-- ¡Contenido completo pre-renderizado! -->
    </div>
  </div>
  <script src="/static/js/main.abc123.js"></script>
</body>
</html>

Beneficios: - SEO inmediato: Crawlers leen el contenido sin ejecutar JS. - LCP mejorado: El navegador muestra contenido mientras descarga JS. - Social media: Twitter/LinkedIn generan previews correctas.

Nota (Feb 18, 2026): Después de 7 builds fallidos intentando hacer funcionar react-snap con diferentes configuraciones (6→5→4→3→2 rutas), react-snap fue finalmente removido. Material UI + framer-motion + hooks personalizados causaban que Puppeteer nunca detectara "network idle". La arquitectura final conserva code splitting + nginx cache (90% del beneficio) sin la fragilidad de pre-rendering. Ver Post 11 para el análisis completo del debugging.


Nivel 4: Kaniko Docker Cache para CI/CD

Diagnóstico

Después de implementar react-snap, los builds de CI/CD explotaron en tiempo:

Before: ~6 minutos
After:  ~1-2 HORAS 🔥

El culpable: Chromium tiene 170 dependencias en Alpine Linux, y Cloud Build las reinstalaba desde cero en cada deploy. Los logs mostraban:

Step 3/15 : RUN apk add --no-cache chromium
(1/170) Installing libexpat (2.7.4-r0)
(2/170) Installing brotli-libs (1.1.0-r2)
...
(170/170) Installing chromium (xxx)

Instalar 170 paquetes toma 40-50 minutos.

Solución: Kaniko + Cache de Docker Layers

Kaniko es un builder de Docker que: 1. Construye imágenes sin necesitar el daemon de Docker 2. Soporta caché de layers en Google Container Registry 3. Es más eficiente que docker build en Cloud Build

Paso 1: Crear cloudbuild.yaml

Nota (Feb 18, 2026): La configuración original incluía una sección images: para verificación, pero esto causa un race condition con Kaniko. La imagen se pushea exitosamente pero Cloud Build falla al verificarla. Solución: Remover la sección images: completamente — Kaniko con --destination ya hace el push. Ver Post 11, Build 8 para detalles.

# blog_frontend/cloudbuild.yaml
steps:
  - name: 'gcr.io/kaniko-project/executor:latest'
    args:
      - --destination=gcr.io/$PROJECT_ID/blog-frontend:latest
      - --cache=true
      - --cache-ttl=720h  # 30 días de caché
      - --snapshot-mode=redo

images:
  - 'gcr.io/$PROJECT_ID/blog-frontend:latest'

options:
  machineType: 'E2_HIGHCPU_8'  # Máquina más potente
  logging: CLOUD_LOGGING_ONLY

Claves: - --cache=true: Habilita caché de layers en GCR. - --cache-ttl=720h: Cachea layers por 30 días. - E2_HIGHCPU_8: Máquina con 8 vCPUs acelera el build.

Paso 2: Actualizar deploy.yml

# .github/workflows/deploy.yml
- name: Build Frontend Image
  run: |
    echo "REACT_APP_API_URL=https://blog-backend-..." > ./blog_frontend/.env

    # Build con caché usando cloudbuild.yaml
    gcloud builds submit --config ./blog_frontend/cloudbuild.yaml ./blog_frontend

    rm ./blog_frontend/.env

- name: Deploy Frontend
  uses: google-github-actions/deploy-cloudrun@v2
  with:
    service: blog-frontend
    image: gcr.io/${{ env.PROJECT_ID }}/blog-frontend:latest
    region: ${{ env.REGION }}

Resultado

Primer build (cache miss):

Step 3/15 : RUN apk add --no-cache chromium
(1/170) Installing libexpat...
...
(170/170) Installing chromium
✅ Build time: ~15-20 minutos

Segundo build (cache hit):

Step 3/15 : RUN apk add --no-cache chromium
[CACHED] Using cached layer
✅ Build time: ~3-5 minutos

El layer de Chromium se reutiliza porque el hash del comando RUN apk add chromium no cambió.


Impacto Medido: Antes vs Después

Métricas de Rendimiento

Métrica Antes Después Mejora
Bundle principal 357 KB (gzip) 105 KB (gzip) -70%
Chunks totales 1 (monolito) 13 (lazy-loaded) +1200%
LCP (estimado) ~3.5s ~1.2s -66%
HTML inicial 2 KB vacío 45 KB con contenido +2150%
Cache hit rate 0% ~85% (visits) +∞

Métricas de CI/CD

Métrica Antes Después (sin cache) Después (con cache)
Build time ~6 min ~15-20 min 3-5 min
Docker layers cached 0 0 8-10 (Chromium, deps)
Cloud Build cost $0.10/build $0.25/build $0.08/build

Métricas de Usuario

  • Time to Interactive (estimado): 4.2s → 1.8s
  • First Contentful Paint: 2.1s → 0.9s
  • Cumulative Layout Shift: 0.05 → 0.02 (mejor con HTML pre-renderizado)

Arquitectura Final

┌─────────────────────────────────────────────────────────────┐
│                    GitHub Actions Workflow                   │
│  On push to main: Build Backend + Frontend, Deploy to Cloud │
└────────────────────────┬────────────────────────────────────┘
                         │
                         ▼
        ┌────────────────────────────────┐
        │   Cloud Build (Kaniko)         │
        │  - Check cache layers (GCR)    │
        │  - Build multi-stage Docker    │
        │  - Cache Chromium layer (30d)  │
        └────────────┬───────────────────┘
                     │
                     ├─────────────┐
                     ▼             ▼
           ┌─────────────┐   ┌──────────────┐
           │   Stage 1   │   │   Stage 2    │
           │ node:18-all │   │ nginx:alpine │
           │             │   │              │
           │ - Chromium  │   │ - Gzip on    │
           │ - npm build │   │ - Cache 3lvl │
           │ - react-snap│   │ - Pre-render │
           └─────────────┘   └──────────────┘

Flujo de optimización:

  1. Usuario visita / → Nginx sirve index.html pre-renderizado (no-cache)
  2. Browser carga main.js → 105 KB desde cache local (1y immutable)
  3. Usuario navega a /cv → React.lazy descarga chunk CV (76 KB, solo una vez)
  4. Imágenes/logos → Nginx sirve desde cache (30d)

Lecciones Aprendidas

1. Code Splitting es Zero-Risk

Implementar React.lazy() con CRA es seguro y automático. Webpack maneja todo el código splitting. Solo necesitas: - Cambiar import → lazy(() => import(...)) - Envolver rutas en <Suspense>

No hay configuración de Webpack, no hay riesgo de romper el bundle.

2. react-snap es Legacy y Frágil

react-snap lleva años sin actualizarse (última versión 2019) y funciona para SSG simple, pero tiene limitaciones severas en CI/CD: - Puppeteer espera "network idle" — si tu página hace API calls o usa requestAnimationFrame, nunca llega a idle. - El crawling automático (activado por defecto) descubre rutas desde el navbar y las pre-renderiza sin pedir permiso. - En Docker/Cloud Build, el timeout por defecto es insuficiente.

De 6 rutas originales, solo 2 sobrevivieron el debugging. El post 11 documenta toda la saga. Alternativas modernas: - Next.js: Si quieres SSR + ISR avanzado - react-snapshot: Fork mantenido de react-snap - prerender-spa-plugin: Para Webpack manual

3. Kaniko Ahorra Dinero (y Tiempo)

La inversión inicial de configurar Kaniko se paga en 2-3 builds: - Sin cache: $0.25/build × 30 builds/mes = $7.50/mes - Con cache: $0.08/build × 30 builds/mes = $2.40/mes

Ahorro anual: $61 + el valor de tu tiempo (15 min → 5 min).

4. Caché Nginx Requiere Estrategia

No puedes simplemente poner expires 1y en todo: - Assets hasheados: 1 año + immutable ✅ - Assets sin hash (imágenes): 30 días ✅ - index.html: NO CACHEAR ❌

Un error común es cachear index.html, lo que previene que los usuarios vean nuevos deploys.

5. Pre-rendering Mejora UX Perceptible

Aunque React hidrata en ~200ms, el HTML pre-renderizado da una sensación de carga instantánea. El usuario ve contenido mientras React se inicializa en background.


Próximos Pasos

Optimizaciones futuras que consideraré:

  1. Migrar a Next.js 14+: SSR + App Router + RSC (React Server Components) para eliminación completa del waterfall JS.
  2. Service Worker: Offline support con Workbox para PWA.
  3. Image Optimization: Convertir JPGs a WebP + lazy loading nativo.
  4. Font Subsetting: Reducir tamaño de Montserrat/Lora cargando solo caracteres usados.
  5. Bundle Analyzer: Identificar paquetes pesados innecesarios con webpack-bundle-analyzer.

Recursos


Anterior: Mejoras al Motor RAG: Restricción de Contenido, Resiliencia y LaTeX
Siguiente: Debugging react-snap en CI/CD: Cuando Puppeteer Se Niega a Terminar

Este artículo es parte de la serie "Construyendo un Blog con IA". El código fuente completo está en GitHub.