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.

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:
- Es lento: Google puede tardar días en indexar contenido JS-generated.
- No es perfecto: Algunos bots (Twitter, LinkedIn) no ejecutan JS.
- 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ónimages:completamente — Kaniko con--destinationya 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:
- Usuario visita / → Nginx sirve
index.htmlpre-renderizado (no-cache) - Browser carga main.js → 105 KB desde cache local (1y immutable)
- Usuario navega a /cv → React.lazy descarga chunk CV (76 KB, solo una vez)
- 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é:
- Migrar a Next.js 14+: SSR + App Router + RSC (React Server Components) para eliminación completa del waterfall JS.
- Service Worker: Offline support con Workbox para PWA.
- Image Optimization: Convertir JPGs a WebP + lazy loading nativo.
- Font Subsetting: Reducir tamaño de Montserrat/Lora cargando solo caracteres usados.
- Bundle Analyzer: Identificar paquetes pesados innecesarios con
webpack-bundle-analyzer.
Recursos
- React.lazy() Official Docs
- react-snap GitHub
- Kaniko Official Docs
- Nginx Caching Guide
- Web Vitals - LCP
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.