HTTP-caching uitgelegd: Cache-Control, ETag, afbeeldingen en Apache-configuratie
Leer hoe je browsercaching configureert voor HTML, CSS, JavaScript, afbeeldingen en lettertypen. Begrijp ETag en 304-responsen met praktische voorbeelden, voorkom verouderde bestanden en gebruik een volledige Apache .htaccess-configuratie.
HTTP Caching Verklaard: Cache-Control, ETag, Afbeeldingen en Apache-configuratie
Je optimaliseert je afbeeldingen, minificeert je CSS en compresseert je JavaScript. Je website laadt sneller. Maar wanneer bezoekers terugkomen, kunnen hun browsers dezelfde bestanden opnieuw downloaden.
Je schakelt caching in. Alles ziet er beter uit — tot je een afbeelding vervangt en ontdekt dat sommige bezoekers nog steeds de oude versie zien.
Dit is de uitdaging van HTTP caching: hergebruik bestanden die niet zijn gewijzigd, maar nieuwe versies ophalen wanneer ze dat zijn.
In deze gids bouwen we een cachingstrategie voor een echte website met Apache, PHP en browsertools.
1. HTTP caching uitgelegd met een eenvoudig voorbeeld
Stel je een website voor met vijf bestanden:
index.html
assets/css/style.css
assets/js/app.js
assets/images/hero.webp
assets/fonts/site.woff2
Wanneer iemand je website voor de eerste keer bezoekt, downloadt de browser deze bestanden.
Stel je nu voor dat de bezoeker tien minuten later terugkomt.
Als de server de browser eerder vertelde dat het CSS-bestand een dag mocht worden hergebruikt, hoeft de browser het niet opnieuw te downloaden.
De browser heeft al een kopie.
Dat is het basisidee van caching.
De instructies komen van HTTP-headers die zijn meegestuurd met het antwoord van de server.
Bijvoorbeeld:
Cache-Control: public, max-age=86400
Dit betekent dat het antwoord opgenomen mag worden terwijl het vers is voor 86,400 seconden — één dag.
Maar wat gebeurt er als je de CSS bijvoorbeeld na één uur bijwerkt?
De browser mag de oude versie blijven gebruiken voor de overige 23 uur.
Dit is de reden dat het alleen verhogen van cacheduur niet genoeg is.
2. Cache-Control: de instructies die naar de browser worden gestuurd
De Cache-Control-header vertelt browsers en andere HTTP-caches hoe ze een antwoord moeten afhandelen.
Hier zijn de directives die je het meest vaak zult gebruiken.
| Directive | Eenvoudige uitleg |
|---|---|
max-age=3600 |
Hergebruik het antwoord tot één uur |
public |
Gedeelde caches, inclusief CDNs, mogen het antwoord opslaan |
private |
Alleen in een privé-cache opslaan, niet in een gedeelde cache |
no-cache |
Opslaan indien toegestaan, maar valideren voordat je het hergebruikt |
no-store |
Niet opslaan van het antwoord |
immutable |
De bron wordt niet verwacht te veranderen terwijl het vers is |
must-revalidate |
Eens verouderd, hergebruik zonder succesvolle validatie niet |
Een bijzondere verwarrende directive is no-cache.
Het betekent niet "bewaar dit bestand nooit".
Het betekent "vóór het gebruik van een opgeslagen kopie, vraag de server of deze nog geldig is".
Voor antwoorden die niet opgeslagen mogen worden, gebruik je no-store.
Dat onderscheid is belangrijk bij het configureren van HTML-pagina's en gevoelige inhoud.
3. ETag uitgelegd: hoe de browser vraagt of een bestand is gewijzigd
Laten we dit concreet maken.
Stel je een bestand voor dat logo.webp heet.
De browser downloadt het op maandag.
De server stuurt ook een identifier:
ETag: "logo-version-1"
Denk aan deze identifier als een label dat aan die specifieke versie van de afbeelding is gekoppeld.
De browser houdt de afbeelding vast en onthoudt het label.
Op dinsdag heeft het gecachte antwoord validatie nodig. In plaats van onmiddellijk het hele afbeelding te downloaden, vraagt de browser:
"Hallo server, ik heb al de afbeelding met id logo-version-1. Is deze nog hetzelfde?"
Technisch stuurt het het volgende:
GET /images/logo.webp HTTP/1.1
Host: example.com
If-None-Match: "logo-version-1"
De server vergelijkt die identifier met de huidige versie.
Geval A: de afbeelding is niet gewijzigd
De server reageert:
HTTP/1.1 304 Not Modified
ETag: "logo-version-1"
De browser zegt effectief: "Goed, ik blijf mijn bestaande afbeelding gebruiken."
De server stuurt de afbeeldingbody niet opnieuw.
Geval B: de afbeelding is gewijzigd
Stel je voor dat je het logo vervangt door een nieuwe versie.
De server identificeert het nu als logo-version-2.
De browser vraagt nog steeds naar logo-version-1, maar de server reageert:
HTTP/1.1 200 OK
Content-Type: image/webp
ETag: "logo-version-2"
Deze keer bevat het antwoord de nieuwe afbeelding.
De browser vervangt zijn gecachte kopie.
Dat is alles wat ETag doet voor caching: het helpt de browser te controleren of zijn kopie nog actueel is.
De identifier hoeft geen hash of versienummer te zijn. Apache kan het genereren uit bestandmetadata, en applicaties kunnen hun eigen identifiers genereren.
Test ETag zelf
Eerst, haal de response-headers op:
curl -I https://example.com/images/logo.webp
Vind de ETag:
ETag: "abc123"
Verstuur dan een voorwaardelijke aanvraag:
curl -I \
-H 'If-None-Match: "abc123"' \
https://example.com/images/logo.webp
Als de weergave ongewijzigd is, kan een goed geconfigureerde server 304 Not Modified retourneren.
Als het is gewijzigd, verwacht je 200 OK met de bijgewerkte weergave.
Een belangrijke beperking: ETag dwingt de browser niet om de server te contacteren terwijl een gecacht antwoord nog vers is. Als een afbeelding een levensduur van één jaar heeft, verandert het bestand op de server niet, garantie dat de browser onmiddellijk zijn ETag controleert.
Daar wordt resourceversieing essentieel.
4. Afbeeldencaching: het onderdeel dat vaak de meeste problemen veroorzaakt
Afbeeldingen zijn vaak onder de grootste bronnen op een website.
Een homepage kan een hero-afbeelding, categorieillustraties, artikelthumbnails, logo's, iconen en productafbeeldingen bevatten.
Zelfs wanneer ze zijn gecomprimeerd naar WebP of AVIF, verspilt het herhaaldelijk downloaden ervan bandbreedte.
Laten we drie echte situaties bekijken.
Situatie A: een afbeelding die nooit verandert
Je website heeft een decoratieve afbeelding:
/images/background-v1.webp
Je weet dat wanneer het design verandert, je een nieuw bestandsnaam gebruikt.
Je kunt veilig configureren:
Cache-Control: public, max-age=31536000, immutable
De browser mag het een jaar hergebruiken zonder de server te contacteren terwijl het antwoord vers is.
Situatie B: een afbeelding die onder dezelfde bestandsnaam is vervangen
Je artikel bevat:
<img src="/images/article-hero.webp" alt="Article illustration">
Je vervangt article-hero.webp door een nieuwe afbeelding, maar behoudt dezelfde URL.
Als de browser een vers gecacht antwoord met een lange levensduur heeft, kan het de oude afbeelding blijven tonen.
De oplossing is het wijzigen van de URL wanneer de inhoud verandert.
Bijvoorbeeld:
<img src="/images/article-hero.webp?v=2" alt="Article illustration">
Of beter, genereer je een versieerbare bestandsnaam:
<img src="/images/article-hero-a81c.webp" alt="Article illustration">
Nu ziet de browser een andere resource-URL en vraagt het nieuwe afbeelding op.
De oude gecachte afbeelding is onschadelijk omdat de HTML er niet meer naar verwijst.
Situatie C: duizenden afbeeldingen met stabiele bestandsnamen
Droom van een editorial website met duizenden artikelen.
Het handmatig hernoemen van elke afbeelding zou onhandig zijn.
Je kunt in plaats daarvan een matige cachelevensduur kiezen, zoals één dag of één week, en vertrouwen op hervalidatie na het verstrijken.
Bijvoorbeeld:
Cache-Control: public, max-age=86400
Dat is een redelijke compromisie wanneer automatische afbeeldversieing niet beschikbaar is.
Echter, bezoekers kunnen tijdens de versheidsperiode nog een oudere afbeelding zien.
Voor afbeeldingen die onmiddellijk moeten worden bijgewerkt, is een gewijzigde URL of expliciete cacheinvalidering de voorkeur.
Wat met JPEG, PNG, SVG, WebP en AVIF?
Het cachesprincipe is voor alle gelijk.
| Afbeeldingformaat | Typisch gebruik | Cachingstrategie |
|---|---|---|
| JPEG | Foto's | Lange cache als URL is versieerd |
| PNG | Grafieken, transparantie | Zelfde |
| WebP | Geoptimaliseerde webafbeeldingen | Zelfde |
| AVIF | Zeer gecomprimeerde afbeeldingen | Zelfde |
| SVG | Iconen, logo's, illustraties | Zelfde |
| GIF | Eenvoudige animaties | Zelfde |
Het formaat beïnvloedt compressie en decodering, maar het verandert HTTP-cachegedrag niet fundamenteel.
Houd ook in het achterkomen dat responsive afbeeldingen meerdere onafhankelijke cache-invoeringen kunnen opleveren:
<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>
Elke geselecteerde URL heeft zijn eigen cachinggedrag.
Als je de afbeelding vervangt, werk je de URLs van elke relevante variant bij.
5. Automatisch versieer CSS, JavaScript en afbeeldingen met PHP
5. Automatisch versieer CSS, JavaScript en afbeeldingen met PHP
Voor PHP-websites kun je het handmatig bijwerken van versienummers vermijden door de bestandsaanpasstijd te gebruiken.
Hier is een kleine helper:
<?php
function assetUrl(string $path): string
{
$file = $_SERVER['DOCUMENT_ROOT'] . $path;
if(!is_file($file)) {
return $path;
}
return $path . '?v=' . filemtime($file);
}
Gebruik het zo:
<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">
Stel voor dat de aanpassingstijd van het bestand 1794800000 is.
De browser ontvangt een URL zoals:
/assets/images/hero.webp?v=1794800000
Wanneer je het bestand bijwerkt en de aanpassingstijd verandert, verandert de URL ook.
Dit is een eenvoudige cache-bustingstrategie.
Voor productie-buildpipelines zijn content-hashes robuuster omdat timestamps tijdens deployments kunnen worden bewaard of kunnen veranderen zonder dat de inhoud verandert.
Belangrijk: als je CDN is geconfigureerd om querystrings in de cache-sleutel te negeren, produceert ?v= mogelijk geen unieke gecachte bron. Controleer de CDN-configuratie of gebruik versierde bestandsnamen in plaats daarvan.
6. Verschil de browsertcache niet met de servercache en de CDNcache
Een website kan meerdere cachinglagen hebben.
De browsertcache slaat antwoorden op op het apparaat van de bezoeker op.
Een CDN slaat geselecteerde antwoorden op op servers die geografisch dichter bij bezoekers liggen.
Een applicatiecache kan gegenereerde HTML, databasequeryresultaten of andere berekende gegevens opslaan.
Deze lagen lossen verschillende problemen op.
Bijvoorbeeld kan een CDN een verouderde afbeelding serveren, zelfs nadat de browsertcache is gewezen.
Hetzelfde geldt voor het wissen van een CMS-cache; het invalidateert niet per se een afbeelding die al door de browser of CDN is opgeslagen.
Bij het debuggen identificeer je welke laag het oude content levert voordat je de configuratie wijzigt.
7. Hostingprestaties en HTTP caching
HTTP caching kan aanzienlijk herhaalde downloads verminderen, maar het kan niet elk hostingprobleem compenseren.
Bijvoorbeeld, als een niet-gecachede PHP-pagina twee seconden kost om te genereren vanwege langzame databasequeries, lost het browsert cachen van afbeeldingen het onderliggende serverreactietijd niet op.
Een betrouwbare hostingomgeving moet passende PHP-prestatie, opslag, compressie, TLS en ondersteuning bieden voor cachingheaders.
Voor kleine en middelgrote websites kan een hostingprovider zoals PlanetHoster onderdeel zijn van een praktische configuratie.
Voor applicaties die meer controle vereisen over serverresources, deploymentworkflows of cachingarchitectuur, kan Cloudways ook waardevol zijn om te evalueren.
Voordat je providers wijzigt, meet je de daadwerkelijke bottleneck: serverreactietijd, afbeeldsgewicht, PHP-uitvoering, databasequeries of cacheconfiguratie.
8. Hoe je caching inspecteert in Firefox en Chrome
Open je browsertools.
In Firefox druk je op F12, en selecteer je Network.
Herlaad je website en klik je op een afbeelding- of stylesheetverzoek.
Kijk naar de responseheaders.
Bijvoorbeeld:
Cache-Control: public, max-age=86400
ETag: "abc123"
Last-Modified: Mon, 16 Nov 2026 09:00:00 GMT
Herhaal nu de navigatie zonder de cache uit te schakelen.
Afhankelijk van de browser, de versheid van de bron en hoe de navigatie is gestart, kan het uit de lokale cache worden geladen, worden opnieuw gevalideerd met een 304, of opnieuw worden gedownload.
Om een specifieke afbeelding onafhankelijk te testen:
curl -sS -D - -o /dev/null \
https://example.com/assets/images/hero.webp
Controleer de status, Cache-Control, ETag en Last-Modified.
Herhaal dan het verzoek met If-None-Match met behulp van de daadwerkelijke ETag die door je server is geretourneerd.
Vermijd het gebruik van een gedwongen herladen als enige cachesessie: het kan bewust gecachte antwoorden omzeilen of opnieuw valideren.
9. Compleet Apache-voorbeeld voor een echte website
Laten we eindigen met een praktische configuratie.
Dit voorbeeld is ontworpen voor een publieke website met Apache 2.4, met een mix van statische bestanden en PHP gegenereerde HTML.
De strategie is opzettelijk conservatief:
- HTML is opnieuw gevalideerd.
- CSS en JavaScript gebruiken een cacheduur van zeven dagen.
- Afbeeldingen gebruiken een cacheduur van zeven dagen.
- Lettertypen gebruiken een langere cache.
- Manifestbestanden gebruiken een korte cache.
- ETag blijft beschikbaar voor het valideren van statische bestanden.
- PHP-antwoorden kunnen hun eigen beleid instellen.
Dit is een startconfiguratie, geen universeel drop-in-replacementeersysteem. Controleer de bestaande regels, ingeschakelde modules en Apache-override-rechten voordat je het deployt.
# ============================================================
# 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.
Belangrijke opmerkingen over deze configuratie
1. Dupliceer niet een bestaande cachingconfiguratie.
Hoe je hostingprovider, CMS of cachesplugin deze headers al instelt, vervang je de beleid zorgvuldig.
De Apache-taak mod_expires genereert verloop en max-age-informatie, terwijl mod_headers expliciet Cache-Control kan instellen. Afhankelijk van hoe headers intern worden gegenereerd en opgeslagen, kunnen beide een duplicaat of conflicterende waarden opleveren.
Inspecteer de daadwerkelijke HTTP-reactie en vereenvoudig de configuratie indien nodig. Voor een productie-deploy kies je voor één consistent mechanisme per resourceklasse.
2. ETag is niet verplicht voor elk antwoord.
De FileETag MTime Size-directive is van toepassing op door Apache geserveerde bestanden. Het biedt automatisch geen betekenisvolle validators voor dynamisch gegenereerde PHP-pagina's.
Op gedistribueerde servers kunnen eveneens metadata-gebaseerde ETags aanvullende overweging vereisen.
3. Compressie is geen beeldoptimalisatie.
Gzip is nuttig voor tekstgebaseerde bronnen zoals HTML, CSS, JavaScript, JSON en SVG.
JPEG, WebP, AVIF en PNG zijn al gecomprimeerde formaten. Extra gzip-compressie levert meestal weinig voordeel op.
Hoe je server al Brotli ondersteunt, voeg dan geen concurerende compressieconfiguraties toe zonder de bestaande setup te controleren.
4. Zeven dagen is een compromisie.
Hoe al je statische bronnen betrouwbaar versieerbare URLs hebben, kun je hun cachelevensduur naar één jaar verlengen en immutable gebruiken.
Hoe je afbeeldingen routineel vervangt zonder de URL te wijzigen, kan zeven dagen nog steeds te lang zijn.
Kies het beleid op basis van hoe je website is geïnstalleerd.
10. Test de configuratie vóór en na deploy
Gebruik deze checklist.
| Test | Verwachte resultaat |
|---|---|
| Een afbeelding opvragen | Cache-Control reflecteert het afbeeldbeleid |
| Een stylesheet opvragen | Juiste CSS-cachingbeleid |
| HTML opvragen | Hervalidatiebeleid |
| Een privépagina opvragen | Geen per ongeluk gedeelde caching |
If-None-Match versturen |
304 als ongewijzigd en validatie ondersteund |
| Een versierde afbeelding vervangen | Nieuwe URL laadt nieuwe afbeelding |
| Gecomprimeerde CSS inspecteren | Passende contentcodering |
| Browser Network-paneel controleren | Geen onverwachte herhaalde volledige downloads |
Bijvoorbeeld:
curl -I https://example.com/assets/images/hero.webp
En dan:
curl -I https://example.com/assets/css/site.css
En tot slot:
curl -I https://example.com/
Vergelijk de responseheaders.
Hoe een bestand geen verwacht cachingheader heeft, verifieer dan of Apache het daadwerkelijk serveert, of de relevante module ingeschakeld is en of een CDN of applicatielaag de reactie overschrijft.
Hoe de site een 500 Internal Server Error retourneert na het bewerken van .htaccess, herstel dan de vorige configuratie en inspecteer de Apache-errorlog. Onondersteunde directives of niet toegestane overrides zijn veelvoorkomende oorzaken.
11. Wanneer een CDN of managed hosting nuttig wordt
Voor websites met bezoekers in verschillende landen kan een CDN de afstand tussen gebruikers en gecachte statische bronnen verminderen.
Echter, het toevoegen van een CDN is niet automatisch een verbetering.
Eerst zorg je ervoor dat afbeeldingen correct zijn geschenen en gecomprimeerd, dat browsert caching werkt en dat statische resource-URLs zijn versieerd.
Meet dan of de CDN de echte leveringstijden verbetert.
Een hostingplatform met passende cachingcontroles kan deze setup vereenvoudigen, maar je moet nog steeds begrijpen welke cachelaag verantwoordelijk is voor elke reactie.
PlanetHoster en Cloudways zijn twee hostingopties die afhankelijk zijn van de vereisten van de applicatie, operationele behoeften en beschikbare servercontroles, die het waard zijn om te evalueren.
De belangrijke vraag is niet welke provider de meeste cachingfuncties adverteert. Het is of je gecachte inhoud betrouwbaar kunt configureren, meten en invalideren.
Conclusie
HTTP caching wordt veel beheersbaarder wanneer je drie vragen scheidt:
Kan dit antwoord worden opgeslagen? Hoe lang kan het worden hergebruikt zonder te controleren? Hoe weet de browser of het is gewijzigd?
Cache-Control beantwoordt de eerste twee vragen.
ETag en voorwaardelijke aanvragen helpen de derde te beantwoorden.
Voor statische bronnen zoals afbeeldingen, CSS en JavaScript zijn versieerbare URLs vaak de meest betrouwbare manier om lange cachelevensduren te combineren met directe updates.
Voor HTML en frequent veranderende inhoud is hervalidatie meestal aantrekkelijker.
Start met een conservatieve configuratie, test deze met echte HTTP-aanvragen en verhoog pas de cachelevensduren wanneer je begrijpt hoe de website omgaat met updates.