Explicación del Caché HTTP: Cache-Control, ETag, Imágenes y Configuración de Apache
Aprende cómo configurar el caché del navegador para HTML, CSS, JavaScript, imágenes y fuentes. Comprende ETag y las respuestas 304 con ejemplos prácticos, evita archivos obsoletos y utiliza una configuración completa de Apache .htaccess.
Caché HTTP explicado: Cache-Control, ETag, imágenes y configuración de Apache
Optimizas tus imágenes, minificas tu CSS y comprimes tu JavaScript. Tu sitio web carga más rápido. Pero cuando los visitantes regresan, sus navegadores pueden descargar los mismos archivos de nuevo.
Activas el caché. Todo se ve mejor — hasta que reemplazas una imagen y descubres que algunos visitantes todavía ven la anterior.
Este es el desafío del caché HTTP: reutilizar archivos que no han cambiado, pero recuperar versiones nuevas cuando lo hacen.
En esta guía, construiremos una estrategia de caché para un sitio web real usando Apache, PHP y herramientas de desarrollo del navegador.
1. El caché HTTP explicado con un ejemplo sencillo
Imagina un sitio web con cinco archivos:
index.html
assets/css/style.css
assets/js/app.js
assets/images/hero.webp
assets/fonts/site.woff2
Cuando alguien visita tu sitio web por primera vez, el navegador descarga estos archivos.
Ahora imagina que el visitante regresa diez minutos después.
Si el servidor le dijo anteriormente al navegador que el archivo CSS podía reutilizarse durante un día, el navegador no necesita descargarlo de nuevo.
El navegador ya tiene una copia.
Esa es la idea básica del caché.
Las instrucciones provienen de los encabezados HTTP enviados con la respuesta del servidor.
Por ejemplo:
Cache-Control: public, max-age=86400
Esto significa que la respuesta puede reutilizarse mientras esté fresca durante 86,400 segundos — un día.
Pero, ¿qué sucede si actualizas el CSS después de solo una hora?
El navegador puede continuar usando la versión antigua durante las 23 horas restantes.
Por eso, simplemente aumentar las duraciones de caché no es suficiente.
2. Cache-Control: las instrucciones enviadas al navegador
El encabezado Cache-Control le dice a los navegadores y otros cachés HTTP cómo manejar una respuesta.
Aquí están las directivas que usarás con más frecuencia.
| Directiva | Explicación sencilla |
|---|---|
max-age=3600 |
Reutilizar la respuesta durante hasta una hora |
public |
Los cachés compartidos, incluidas las CDN, pueden almacenar la respuesta |
private |
Almacenar solo en una caché privada, no en una caché compartida |
no-cache |
Almacenar si se permite, pero validar antes de reutilizar |
no-store |
No almacenar la respuesta |
immutable |
El recurso no se espera que cambie mientras esté fresco |
must-revalidate |
Una vez obsoleto, no reutilizar sin una validación exitosa |
Una directiva particularmente confusa es no-cache.
No significa nunca almacenar este archivo.
Significa «antes de usar una copia almacenada, pregunta al servidor si aún es válida».
Para respuestas que no deben almacenarse, usa no-store.
Esa distinción importa al configurar páginas HTML y contenido sensible.
3. ETag explicado: cómo el navegador pregunta si un archivo ha cambiado
Pongamos esto en concreto.
Imagina que tienes un archivo llamado logo.webp.
El navegador lo descarga el lunes.
El servidor también envía un identificador:
ETag: "logo-version-1"
Piensa en este identificador como una etiqueta adjunta a esa versión particular de la imagen.
El navegador conserva la imagen y recuerda la etiqueta.
El martes, la respuesta en caché necesita validación. En lugar de descargar inmediatamente toda la imagen de nuevo, el navegador pregunta:
«Hola servidor, ya tengo la imagen identificada por logo-version-1. ¿Sigue siendo la misma?»
Técnicamente, envía:
GET /images/logo.webp HTTP/1.1
Host: example.com
If-None-Match: "logo-version-1"
El servidor compara ese identificador con la versión actual.
Caso A: la imagen no ha cambiado
El servidor responde:
HTTP/1.1 304 Not Modified
ETag: "logo-version-1"
El navegador dice, en efecto: «Genial, seguiré usando mi imagen existente».
El servidor no envía el cuerpo de la imagen de nuevo.
Caso B: la imagen ha cambiado
Supón que reemplazas el logotipo con una versión nueva.
El servidor ahora lo identifica como logo-version-2.
El navegador todavía pregunta sobre logo-version-1, pero el servidor responde:
HTTP/1.1 200 OK
Content-Type: image/webp
ETag: "logo-version-2"
Esta vez, la respuesta incluye la nueva imagen.
El navegador reemplaza su copia en caché.
Eso es todo lo que hace ETag para el caché: ayuda al navegador a verificar si su copia sigue siendo actual.
El identificador no tiene por qué ser un hash ni un número de versión. Apache puede generarlo a partir de metadatos del archivo, y las aplicaciones pueden generar sus propios identificadores.
Prueba el ETag tú mismo
Primero, recupera los encabezados de la respuesta:
curl -I https://example.com/images/logo.webp
Encuentra el ETag:
ETag: "abc123"
Luego, envía una solicitud condicional:
curl -I \
-H 'If-None-Match: "abc123"' \
https://example.com/images/logo.webp
Si la representación no ha cambiado, un servidor correctamente configurado puede devolver 304 Not Modified.
Si cambió, espera 200 OK con la representación actualizada.
Una limitación importante: ETag no obliga al navegador a contactar al servidor mientras una respuesta en caché sigue siendo fresca. Si una imagen tiene un período de vigencia de un año, cambiar el archivo en el servidor no garantiza que el navegador verifique su ETag inmediatamente.
Ahí es donde el versionado de recursos se vuelve esencial.
4. Caché de imágenes: la parte que a menudo causa más problemas
Las imágenes son frecuentemente entre los recursos más grandes de un sitio web.
Una página principal puede contener una imagen principal, ilustraciones de categorías, miniaturas de artículos, logotipos, íconos y imágenes de productos.
Incluso cuando se comprimen en WebP o AVIF, descargarlas repetidamente desperdicia ancho de banda.
Examinemos tres situaciones reales.
Situación A: una imagen que nunca cambia
Tu sitio web tiene una imagen decorativa:
/images/background-v1.webp
Sabes que siempre que el diseño cambie, usarás un nombre de archivo nuevo.
Puedes configurar de forma segura:
Cache-Control: public, max-age=31536000, immutable
El navegador puede reutilizarla durante un año sin contactar al servidor mientras la respuesta esté fresca.
Situación B: una imagen reemplazada con el mismo nombre de archivo
Tu artículo contiene:
<img src="/images/article-hero.webp" alt="Article illustration">
Reemplazas article-hero.webp con una imagen nueva, pero mantienes la misma URL.
Si el navegador tiene una respuesta en caché fresca con una vida prolongada, puede seguir mostrando la imagen antigua.
La solución es cambiar la URL cuando el contenido cambie.
Por ejemplo:
<img src="/images/article-hero.webp?v=2" alt="Article illustration">
O, mejor aún, genera un nombre de archivo con versión:
<img src="/images/article-hero-a81c.webp" alt="Article illustration">
Ahora el navegador ve una URL de recurso diferente y solicita la nueva imagen.
La imagen antigua en caché es inofensiva porque el HTML ya no hace referencia a ella.
Situación C: miles de imágenes con nombres de archivo estables
Imagina un sitio web editorial con miles de artículos.
Renombrar cada imagen manualmente sería inconveniente.
En su lugar, puedes elegir una vida de caché moderada, como un día o una semana, y confiar en la revalidación después de la expiración.
Por ejemplo:
Cache-Control: public, max-age=86400
Ese es un compromiso razonable cuando el versionado automático de imágenes no está disponible.
Sin embargo, los visitantes aún pueden ver una imagen antigua durante el período de frescura.
Para imágenes que deben actualizarse de inmediato, una URL modificada o una invalidación de caché explícita es preferible.
¿Qué pasa con JPEG, PNG, SVG, WebP y AVIF?
El principio de caché es idéntico para todos ellos.
| Formato de imagen | Uso típico | Estrategia de caché |
|---|---|---|
| JPEG | Fotos | Caché prolongada si la URL está versionada |
| PNG | Gráficos, transparencia | Igual |
| WebP | Imágenes web optimizadas | Igual |
| AVIF | Imágenes altamente comprimidas | Igual |
| SVG | Íconos, logotipos, ilustraciones | Igual |
| GIF | Animaciones simples | Igual |
El formato afecta la compresión y la decodificación, pero no cambia fundamentalmente el comportamiento del caché HTTP.
También recuerda que las imágenes responsivas pueden generar varias entradas de caché independientes:
<picture>
<source
type="image/avif"
srcset="/images/hero-640.avif 640w,
/images/hero-1280.avif 1280w">
<source
type="image/webp"
srcset="/images/hero-640.webp 640w,
/images/hero-1280.webp 1280w">
<img
src="/images/hero-1280.jpg"
alt="Mountain landscape"
width="1280"
height="720">
</picture>
Cada URL seleccionada tiene su propio comportamiento de caché.
Si reemplazas la imagen, actualiza las URL de cada variante relevante.
5. Versione automáticamente CSS, JavaScript e imágenes con PHP
Para sitios web en PHP, puedes evitar actualizar números de versión manualmente usando el tiempo de modificación del archivo.
Aquí tienes una pequeña ayuda:
<?php
function assetUrl(string $path): string
{
$file = $_SERVER['DOCUMENT_ROOT'] . $path;
if(!is_file($file)) {
return $path;
}
return $path . '?v=' . filemtime($file);
}
Úsala así:
<link rel="stylesheet" href="<?= htmlspecialchars(assetUrl('/assets/css/site.css'), ENT_QUOTES, 'UTF-8') ?>">
<img
src="<?= htmlspecialchars(assetUrl('/assets/images/hero.webp'), ENT_QUOTES, 'UTF-8') ?>"
alt="Hero image">
Supón que la marca de tiempo de modificación del archivo es 1794800000.
El navegador recibe una URL como:
/assets/images/hero.webp?v=1794800000
Cuando actualizas el archivo y su tiempo de modificación cambia, la URL también cambia.
Esta es una estrategia sencilla de invalidación de caché.
Para canalizaciones de compilación en producción, los hashes de contenido son más robustos porque las marcas de tiempo pueden preservarse durante los despliegues o cambiar sin que el contenido cambie.
Importante: Si tu CDN está configurado para ignorar cadenas de consulta en su clave de caché, ?v= puede no producir un recurso en caché distinto. Verifica la configuración del CDN o usa nombres de archivo con versión en su lugar.
6. No confundas el caché del navegador, el caché del servidor y el caché de CDN
Un sitio web puede tener varias capas de caché.
El caché del navegador almacena respuestas en el dispositivo del visitante.
Un CDN almacena respuestas seleccionadas en servidores geográficamente más cerca de los visitantes.
Un caché de la aplicación puede almacenar HTML generado, resultados de consultas de base de datos u otros datos calculados.
Estas capas resuelven problemas diferentes.
Por ejemplo, un CDN puede servir una imagen desactualizada incluso después de borrar el caché del navegador.
De igual modo, borrar el caché de un CMS no necesariamente invalida una imagen ya almacenada por un navegador o CDN.
Al depurar, identifica qué capa está sirviendo el contenido antiguo antes de cambiar la configuración.
7. Rendimiento del hosting y caché HTTP
El caché HTTP puede reducir significativamente las descargas repetidas, pero no puede compensar todos los problemas de hosting.
Por ejemplo, si una página PHP sin caché tarda dos segundos en generarse debido a consultas lentas de base de datos, el caché del navegador de imágenes no solucionará el tiempo de respuesta del servidor subyacente.
Un entorno de hosting confiable debería proporcionar un rendimiento PHP adecuado, almacenamiento, compresión, TLS y soporte para encabezados de caché.
Para sitios web pequeños y medianos, un proveedor de hosting como PlanetHoster puede ser parte de una configuración práctica.
Para aplicaciones que requieren más control sobre los recursos del servidor, flujos de trabajo de despliegue o arquitectura de caché, Cloudways también puede valer la pena evaluarlo.
Antes de cambiar de proveedor, mide el cuello de botella real: tiempo de respuesta del servidor, peso de las imágenes, ejecución de PHP, consultas de base de datos o configuración de caché.
8. Cómo inspeccionar el caché en Firefox y Chrome
Abre las herramientas de desarrollo del navegador.
En Firefox, presiona F12, luego selecciona Network.
Vuelve a cargar tu sitio web y haz clic en una solicitud de imagen o hoja de estilos.
Revisa sus encabezados de respuesta.
Por ejemplo:
Cache-Control: public, max-age=86400
ETag: "abc123"
Last-Modified: Mon, 16 Nov 2026 09:00:00 GMT
Ahora repite la navegación sin deshabilitar el caché.
Según el navegador, la frescura del recurso y cómo se inició la navegación, puede cargarse desde el caché local, revalidarse con un 304, o descargarse de nuevo.
Para probar una imagen específica de forma independiente:
curl -sS -D - -o /dev/null \
https://example.com/assets/images/hero.webp
Revisa el estado, Cache-Control, ETag y Last-Modified.
Luego repite la solicitud con If-None-Match usando el ETag real devuelto por tu servidor.
Evita usar una recarga forzada como única prueba de caché: puede omitir deliberadamente o revalidar respuestas en caché.
9. Ejemplo completo de .htaccess de Apache para un sitio web real
Terminemos con una configuración práctica.
Este ejemplo está diseñado para un sitio web público que ejecuta Apache 2.4, con una combinación de archivos estáticos y HTML generado por PHP.
La estrategia es deliberadamente conservadora:
- HTML se revalida.
- CSS y JavaScript usan una caché de siete días.
- Imágenes usan una caché de siete días.
- Fuentes usan una caché más larga.
- Archivos de manifiesto usan una caché corta.
- ETag permanece disponible para la validación de archivos estáticos.
- Las respuestas PHP pueden establecer sus propias políticas.
Esta es una configuración de inicio, no un reemplazo universal listo para usar. Revisa las reglas existentes del proveedor de hosting, los módulos habilitados y los permisos de sobrescritura de Apache antes de implementarla.
# ============================================================
# HTTP CACHING — APACHE 2.4
# Example configuration for a public website
# ============================================================
# ------------------------------------------------------------
# 1. Static file expiration
# ------------------------------------------------------------
<IfModule mod_expires.c>
ExpiresActive On
# Default: validate immediately
ExpiresDefault "access plus 0 seconds"
# HTML: validate before reuse
ExpiresByType text/html "access plus 0 seconds"
# CSS and JavaScript: 7 days
ExpiresByType text/css "access plus 7 days"
ExpiresByType text/javascript "access plus 7 days"
ExpiresByType application/javascript "access plus 7 days"
# Images: 7 days
ExpiresByType image/jpeg "access plus 7 days"
ExpiresByType image/png "access plus 7 days"
ExpiresByType image/gif "access plus 7 days"
ExpiresByType image/webp "access plus 7 days"
ExpiresByType image/avif "access plus 7 days"
ExpiresByType image/svg+xml "access plus 7 days"
ExpiresByType image/x-icon "access plus 7 days"
ExpiresByType image/vnd.microsoft.icon "access plus 7 days"
# Fonts: 30 days
ExpiresByType font/woff "access plus 30 days"
ExpiresByType font/woff2 "access plus 30 days"
ExpiresByType font/ttf "access plus 30 days"
ExpiresByType font/otf "access plus 30 days"
# Documents: 1 day
ExpiresByType application/pdf "access plus 1 day"
# JSON and XML: validate immediately by default
ExpiresByType application/json "access plus 0 seconds"
ExpiresByType application/xml "access plus 0 seconds"
ExpiresByType text/xml "access plus 0 seconds"
# Web manifest: 1 hour
ExpiresByType application/manifest+json "access plus 1 hour"
</IfModule>
# ------------------------------------------------------------
# 2. Explicit Cache-Control for static resources
# ------------------------------------------------------------
<IfModule mod_headers.c>
# HTML: allow storage, require validation
<FilesMatch "\.html?$">
Header set Cache-Control "no-cache"
</FilesMatch>
# CSS and JavaScript
<FilesMatch "\.(css|js|mjs)$">
Header set Cache-Control "public, max-age=604800"
</FilesMatch>
# Images
<FilesMatch "\.(jpe?g|png|gif|webp|avif|svg|ico)$">
Header set Cache-Control "public, max-age=604800"
</FilesMatch>
# Fonts
<FilesMatch "\.(woff2?|ttf|otf)$">
Header set Cache-Control "public, max-age=2592000"
</FilesMatch>
# PDF documents
<FilesMatch "\.pdf$">
Header set Cache-Control "public, max-age=86400"
</FilesMatch>
# Data files: revalidate
<FilesMatch "\.(json|xml)$">
Header set Cache-Control "no-cache"
</FilesMatch>
# Manifest files
<FilesMatch "\.webmanifest$">
Header set Cache-Control "public, max-age=3600"
</FilesMatch>
</IfModule>
# ------------------------------------------------------------
# 3. ETag support for static files
# ------------------------------------------------------------
FileETag MTime Size
# ------------------------------------------------------------
# 4. Compression
# ------------------------------------------------------------
<IfModule mod_deflate.c>
AddOutputFilterByType DEFLATE text/html
AddOutputFilterByType DEFLATE text/plain
AddOutputFilterByType DEFLATE text/css
AddOutputFilterByType DEFLATE text/javascript
AddOutputFilterByType DEFLATE application/javascript
AddOutputFilterByType DEFLATE application/json
AddOutputFilterByType DEFLATE application/xml
AddOutputFilterByType DEFLATE image/svg+xml
</IfModule>
# ------------------------------------------------------------
# 5. Avoid caching sensitive PHP responses accidentally
# ------------------------------------------------------------
# Configure dynamic PHP responses in application code.
# Do not apply public caching globally to PHP endpoints.
Notas importantes sobre esta configuración
1. No dupliques una configuración de caché existente.
Si tu proveedor de hosting, CMS o complemento de caché ya establece estos encabezados, fusiona las políticas con cuidado.
El módulo mod_expires de Apache genera información de expiración y max-age, mientras que mod_headers puede establecer explícitamente Cache-Control. Según cómo se generen y almacenen internamente los encabezados, combinar ambos puede producir valores duplicados o conflictivos.
Inspecciona la respuesta HTTP real y simplifica la configuración si es necesario. Para una implementación en producción, es preferible elegir un mecanismo consistente para cada clase de recurso.
2. ETag no es obligatorio para cada respuesta.
La directiva FileETag MTime Size se aplica a los archivos servidos por Apache. No proporciona automáticamente validadores significativos para páginas PHP generadas dinámicamente.
En servidores distribuidos, los ETags basados en metadatos también pueden requerir consideración adicional.
3. La compresión no es optimización de imágenes.
Gzip es útil para recursos basados en texto como HTML, CSS, JavaScript, JSON y SVG.
JPEG, WebP, AVIF y PNG ya son formatos comprimidos. La compresión adicional con gzip generalmente proporciona poco beneficio.
Si tu servidor ya admite Brotli, evita agregar configuraciones de compresión compitiendo sin revisar la configuración existente.
4. Siete días es un compromiso.
Si todos tus recursos estáticos tienen URLs con versión confiables, puedes extender su vida de caché a un año y usar immutable.
Si reemplazas imágenes con frecuencia sin cambiar sus URLs, siete días puede seguir siendo demasiado largo.
Elige la política según cómo se implementa tu sitio web.
10. Prueba la configuración antes y después del despliegue
Usa esta lista de verificación.
| Prueba | Resultado esperado |
|---|---|
| Solicitar una imagen | Cache-Control refleja la política de imágenes |
| Solicitar una hoja de estilos | Política de caché CSS correcta |
| Solicitar HTML | Política de revalidación |
| Solicitar una página privada | Sin almacenamiento en caché compartido accidental |
Enviar If-None-Match |
304 si no ha cambiado y la compatibilidad con validación está disponible |
| Reemplazar una imagen con versión | Nueva URL carga la nueva imagen |
| Inspeccionar CSS comprimido | Codificación de contenido apropiada |
| Revisar el panel de red del navegador | Sin descargas completas repetidas inesperadas |
Por ejemplo:
curl -I https://example.com/assets/images/hero.webp
Luego:
curl -I https://example.com/assets/css/site.css
Y finalmente:
curl -I https://example.com/
Compara los encabezados de respuesta.
Si un archivo no tiene el encabezado de caché esperado, verifica si Apache realmente lo está sirviendo, si el módulo correspondiente está habilitado y si una capa de CDN o aplicación anula la respuesta.
Si el sitio devuelve un 500 Internal Server Error después de editar .htaccess, restaura la configuración anterior e inspecciona el registro de errores de Apache. Las directivas no admitidas o las sobrescrituras no permitidas son causas comunes.
11. Cuándo un CDN o un hosting gestionado se vuelve útil
Para sitios web con visitantes en diferentes países, un CDN puede reducir la distancia entre los usuarios y los recursos estáticos en caché.
Sin embargo, agregar un CDN no es automáticamente una mejora.
Primero, asegúrate de que las imágenes estén correctamente dimensionadas y comprimidas, que el caché del navegador funcione y que las URLs de recursos estáticos estén versionadas.
Luego, mide si el CDN mejora los tiempos de entrega reales.
Una plataforma de hosting con controles de caché adecuados puede simplificar esta configuración, pero aún debes entender qué capa de caché es responsable de cada respuesta.
PlanetHoster y Cloudways son dos opciones de hosting que vale la pena evaluar según los requisitos de la aplicación, las necesidades operativas y los controles del servidor disponibles.
La pregunta importante no es qué proveedor anuncia más funciones de caché. Es si puedes configurar, medir e invalidar el contenido en caché de forma confiable.
Conclusión
El caché HTTP se vuelve mucho más fácil de manejar una vez que separas tres preguntas:
¿Puede almacenarse esta respuesta? ¿Cuánto tiempo puede reutilizarse sin verificar? ¿Cómo sabe el navegador si ha cambiado?
Cache-Control responde las dos primeras preguntas.
ETag y las solicitudes condicionales ayudan a responder la tercera.
Para recursos estáticos como imágenes, CSS y JavaScript, las URLs con versión suelen ser la forma más fiable de combinar vidas de caché largas con actualizaciones inmediatas.
Para HTML y contenido que cambia con frecuencia, la revalidación suele ser más apropiada.
Comienza con una configuración conservadora, pruébala con solicitudes HTTP reales y solo aumenta las vidas de caché cuando entiendas cómo el sitio web maneja las actualizaciones.