Een cache versnelt een webapplicatie door eerder opgehaalde of berekende gegevens tijdelijk opnieuw te gebruiken. Je leest hoe caching in browsers, applicaties en databases werkt, welke gegevens daarvoor geschikt zijn en waarom verversing en consistentie bepalend zijn voor de uitkomst.
Wat caching in een webapplicatie doet en waar data wordt opgeslagen
Caching betekent: gegevens bewaren die je anders steeds opnieuw zou moeten ophalen of uitrekenen. Denk aan een JPG-bestand dat de browser al eens zag, het resultaat van een SQL-query, of misschien zelfs een complete webpagina. Doel: sneller laden, minder druk op de server. Maar let op, elk cache creëert wel een kopie. En jij bepaalt wanneer die kopie bruikbaar is, en wanneer de achtergrondbron weer aangesproken wordt.
Er zijn flink wat plekken waar zo'n cache kan zitten. Je browser houdt responses lokaal vast. Een CDN (zoals Cloudflare of Akamai) slaat bestanden op dichter bij de gebruiker. Applicatieservers gebruiken RAM of gedeelde caches als Redis. Zelfs de database cacht eigen dingen zoals indexpagina’s. Elke laag heeft eigen regels voor hoe lang data blijft staan en wanneer iets ververst wordt. Een update in één laag zorgt niet meteen voor updates in alle andere caches.
Dat verschil wordt vaak zichtbaar als data ‘ineens’ anders is afhankelijk van waar je kijkt. Zie je oude info? Dan kan het uit een CDN komen, terwijl alle nieuwere lagen al up-to-date zijn. Zonder inzicht in caching voelt dat alsof er geen reden is. Een goed ontwerp laat zien welke laag het resultaat teruggaf, hoe oud deze dat mag zijn, en volgens welke logica een waarde ververst of weggegooid wordt. Voor maatwerk aan een webapplicatie kan ik helpen als PHP developer.
Browsercache en HTTP-headers instellen voor webpagina’s
Browsers volgen wat er in de HTTP-response staat qua cache-headers. Je stelt met Cache-Control, ETag of Last-Modified in of een bestand uit de cache mag komen, gecontroleerd moet worden of altijd opnieuw gevraagd wordt. Een scriptbestand met unieke naam (zoals app.8c9f3b.js) kun je gerust lang laten cachen. Komt er een nieuwe release? Dan krijgt het bestand een nieuwe naam of hash, zodat de browser weet dat er nieuwe inhoud is.
HTML met persoonlijke of actuele data is een ander verhaal. Daar zet je de cache vaak op Cache-Control: no-cache: hergebruik mag, mits gecontroleerd wordt of de server niet iets nieuws heeft. Dat is niet hetzelfde als no-store, waarbij niets op schijf mag. Met verkeerde headers kun je per ongeluk privé-data onthouden op gedeelde apparaten, of juist voorkomen dat iets ooit uit de cache komt. Vooral bij ingelogde pagina’s let je op wat cookies doen en welke cacheafspraken gelden voor proxies.
De ETag geeft de browser een manier om te vragen of de inhoud nog steeds hetzelfde is. Zie je bij het volgende verzoek dezelfde ETag? Dan reageert de server meestal kort: "je hebt het juiste bestand nog". Minder dataverkeer dus. Echte betrouwbaarheid krijg je alleen als de server de validator baseert op de inhoud. Test cachegedrag altijd met echte requests, en kijk wat gebeurd als je via een CDN langsgaat: een correcte browsercache repareert geen fout aan de netwerkzijde. Voor snelheid en toegankelijkheid in de browser is front-end development relevant.
Applicatiecache voor berekende resultaten en veelgebruikte data
Een applicatiecache laat je zware bewerkingen vermijden door resultaten tijdelijk vast te houden. Neem een homepage met veel relaties, een externe REST-call, of een rapportberekening: vaak verandert dat niet per request. Je kunt in het geheugen van de server cachen, of via een gedeelde store als Redis. Lokaal is snel, maar verdwijnt bij een herstart en blijft per server; gedeeld geeft consistentie tussen instanties, maar kost netwerkverkeer en beheerinzet.
De cache-key moet alle informatie bevatten die het antwoord beïnvloedt. Dus: taal, regio, filters, gebruikersrechten, catalogusversie, enz. Mis je een relevant onderdeel, dan krijgt een gebruiker soms het resultaat van iemand anders. Neem je alles in de sleutel op, dan explodeert het aantal unieke keys en blijft hergebruik uit. Je kiest gericht wat deel uitmaakt van de key, en normaliseert opties zoals hoofdletters of sorteervolgorde waar mogelijk.
Let ook op capaciteit, grenzen en foutafhandeling. Gebruik een geheugenlimiet met bijbehorende policy. Als een item eruit valt, hoort het alleen herberekend te worden (geen foute data). Storing met een gedeelde cache? Dan moet rechtstreekse toegang tot de bron mogelijk zijn, maar voorkom dat de originele bron ineens overladen raakt bij uitval. Cachebeheer begint niet met wáár je cachet, maar wát en hóe lang. Een maatwerkcache in PHP past bij PHP-ontwikkeling.
Databasecaching en de invloed op queryprestaties
Elke database houdt eigen caches bij om veelgebruikte data sneller op te leveren. Denk aan pagina's van tabellen en indexen, doorgeregende plannen, soms zelfs segmenten van een zoekresultaat. Maar die database kent je businesslogica niet, dus merkt niet dat bijvoorbeeld een productlijst opnieuw opgebouwd moet worden na een update. Interne caching spaart schijftijd uit, maar is geen vervanging voor indexen of goede query’s.
Je kunt queryresultaten ook buiten de database cachen, helemaal via een aparte laag. Zo hoef je minder SQL uit te voeren. Maar nu ben jij zelf verantwoordelijk voor de logica rond vernieuwing: als queries steeds anders zijn opgebouwd (bijvoorbeeld vanwege dynamische filters), levert cachen op SQL-niveau weinig op. Cachen per businessobject, bijvoorbeeld een product-ID, sluit beter aan, maar vraagt meer discipline: bij elke mutatie moet de cache weten wat moet worden opgeruimd.
Voor je iets cachet: meet eerst goed. Kijk naar je queryplannen, leesfrequentie, totale duur van requests, en hoeveel herhaling er is. Een tragere query die steeds veel data teruggeeft, los je bij voorkeur op met een betere index. Alleen als dat niet helpt of onhaalbaar is, kun je caching als extra stap inzetten. Bij een lege cache, serverherstart of sync-probleem valt alle load weer terug op de database. Dat moet de infrastructuur aankunnen, óók op piekmomenten.
Welke gegevens geschikt zijn voor caching
Cache het liefst data die vaak gelezen worden, veel rekenwerk kosten en niet bij iedere aanvraag veranderen. Denk aan productcategorieën, taalbestanden, of een dashboardberekening. Kijk niet alleen naar frequentie van wijzigingen, maar ook naar gevolgen bij een afwijking. Een te oude marketingtekst levert minder pijn op dan een verouderde voorraad, toegangscontrole of saldo.
Voor elke cachebare waarde maak je een expliciet plan. Leg vast: wat is de bron, hoe snel verwachten we wijzigingen, hoe oud mag het resultaat zijn, en wat zijn de gevolgen als een cachemiss optreedt. Verschilt de waarde per gebruiker? Extra opletten bij autorisaties en persoonsgegevens, want een cache met een fout in de key kan zomaar gevoelige info tussen accounts lekken. Zelfs als je een account-ID in de key steekt, is ongeldige data meteen wissen bij autorisatieveranderingen onmisbaar.
De eigenschappen van je data bepalen je keuze:
- Statische publieke bestanden: Die mag je gerust lang cachen, mits iedere wijziging een nieuwe URL heeft.
- Veelgevraagde referentiegegevens: Korte levensduur of gerichte invalidatie werkt hier beter.
- Persoonlijke resultaten: Alleen cachebaar met complete context in de sleutel en tussenlaag waarin beveiliging klopt.
- Snel wijzigende, gevoelige data: Haal direct uit de bron of gebruik versies met strikte afstemming.
Caching werkt niet als je niet precies weet wat de foutimpact is. Blind optimaliseren levert soms alleen extra variatie in bugs op. Bij een WooCommerce-webshop vraagt vooral voorraad om een bewuste cachekeuze.
Cache-invalidatie: resultaten verversen na een wijziging
Cache-invalidatie betekent: data uit de cache gooien nadat ze in de bron veranderen. Je kunt simpelweg met TTL’s werken, een tijd waarna een item ongeldig wordt. Dat houdt de ouderdom van resultaten binnen limiet, maar betekent niet dat het resultaat direct actueel is na een wijziging. Gebeurt de update net na het vullen? Dan kan een (deels) oude waarde nog een tijdje zichtbaar zijn. Kortere TTL? Meer directe verzoeken naar de originele bron.
Met expliciete invalidatie gooi je direct en gericht de cachekeys weg na een update. Nauwkeuriger, maar de koppeling tussen wat wijzigt en wat afhankelijk is kan complex zijn. Stel een product updatet: dat raakt lijstpagina’s, suggesties, zoekresultaten en meer. Vergeet je een key? Dan blijft een deel oud. Brede invalidatie (meer sleutels tegelijk) is veiliger, maar raakt performance. Veel vaker berekenen betekent meer werk voor de bron.
Versiebeheer werkt anders. Je plakt een versie aan je cachekey, bijvoorbeeld een catalogusnummer dat verhoogt na wijziging. Nieuwe requests krijgen automatisch een nieuwe key; oude items verdwijnen zodra TTL verlopen is of ruimte nodig is. Dit geeft voorspelbaar gedrag, maar je moet een centrale plek hebben voor de versie en alle processen daarmee in lijn houden. Fouten bij commit van de wijziging of synchronisatie ervan zorgen dat oude data langer blijft staan dan gewenst. Vooral bij gevoelige data moet versiebeheer en cache-invalideren geen onderling los proces zijn.
Consistentie en verouderde data in meerdere cachelagen
Consistentie zegt iets over hoe snel een aanpassing overal zichtbaar wordt waar diezelfde gegevens gebruikt worden. Heb je database, applicatiecache en CDN? Elk onderdeel kan op eigen tempo updaten. Je zet bijvoorbeeld iets nieuws weg in de database, maar krijgt via een andere route alsnog een oude waarde voorgeschoteld. Of de ene gebruiker pint op server A, de ander op B, en die hebben caches die net uit de pas lopen. Die tijdelijke verschillen zijn technisch legitiem, maar kunnen functionele problemen geven als je software verwacht dat data per direct synchroon zijn.
Veel applicaties kiezen voor ‘eventual consistency’: updaten gebeurt z.s.m., maar niet elke response is instant. Voor bijvoorbeeld nieuwsitems is dat prima, bij saldo’s of toegangsrechten niet. Voor die gevoelige paden kun je cachen overslaan of een mechanisme gebruiken dat versies of transacties vergelijkt, zodat fouten te herkennen zijn en niet per ongeluk worden ingeslikt.
Let extra op directe feedback na bewerkingen. Iemand wil een aanpassing terugzien op de volgende pagina, maar als je uit cache leest gebeurt dat soms niet. Vang dat op door na het wegschrijven van een wijziging meteen de cachekey in kwestie te wissen, direct uit de bron te lezen of een versie mee te sturen zodat de gebruiker de wijziging nooit mist. Denk eraan: replicatie tussen databases vertraagt soms ook, een cache omzeilen is niet altijd genoeg. Test met meerdere servers tegelijk om echte race conditions te ontdekken.
Cache stampedes, sleutelproblemen en andere fouten opsporen
Een cache stampede krijg je als een populair item verloopt en plots tientallen tot duizenden verzoeken tegelijk die dure bewerking loslaten op de originele bron. Ineens is het druk juist als je het niet wilt. Oplossing: blokkeer per key. Laat één proces de cache weer vullen, de rest houdt even in of krijgt een tijdelijke oude waarde. Je lock moet wel een houdbaarheid hebben (stel er crasht iets), anders blijft alles eeuwig op slot zitten.
Voorkom stampedes verder door te verversen vóór een item echt verloopt. ‘Background refresh’ pakt alvast een nieuwe waarde op, lezers krijgen ondertussen de oude terug. Zo spreid je de belasting. Spreid TTL's door kleine random verschillen, zodat niet alles tegelijk verloopt. Schakel een circuit-breaker in bij externe systemen: als de bron faalt, niet eindeloos opnieuw proberen.
Cachefouten zijn lastig op te sporen als je alleen kijkt naar de totale doorlooptijd. Hou daarom bij: aantal hits, missers, verversingen, foutmeldingen en de ouderdom van aangereikte waarden. Sla geen persoonsgegevens op in cachekeys of logs. Controleer hoeveel unieke sleutels er actief zijn; extreem hoge aantallen wijzen vaak op een key die te breed is. Bij fouten is het verschil belangrijk: was de cache kapot, miste het item, of werkte de bron niet? Elk scenario vereist andere maatregelen (herstellen, fallback, of weigeren van oud resultaat). Lees ook over foutafhandeling bij betrouwbare automatisering.
Veelgestelde vragen
Hoe vind ik uit welke cachelaag een verouderde pagina serveert?
Je krijgt antwoord door responses te vergelijken op verschillende plekken in de keten en te kijken waar voor het eerst de oude pagina uitgeleverd wordt. Sla de belangrijkste headers op (zoals Age, ETag, Cache-Control), en voeg indien mogelijk een marker toe die aangeeft op welke server of uit welke cachebron de response komt. Vraag dezelfde URL rechtstreeks op bij de applicatieserver en check of je daar al de nieuwe versie krijgt. Zo zie je of het verschil in de browser, het CDN, of de applicatiecache zit.
Wil je extra controleren, voeg dan een unieke queryparameter toe, of gebruik een request dat caching overslaat (als dat kan zonder ongewenste gevolgen). Blijf dit soort checks zien als tijdelijk onderzoeksmiddel, niet als vast onderdeel van je workflow.
Welke cachemetrics moet ik monitoren in een webapplicatie?
Begin met het bijhouden van het hitpercentage (hoe vaak data uit cache komen), het aantal cachemisses, de resolutietijd voor caches, en de belasting (load) op de onderliggende database of API. Die cijfers laten je zien of caching het werk echt verlicht, of er vertraging optreedt bij missers, en of backend-systemen te zwaar belast raken. Log ook hoeveel timeouts en fouten je ziet, geheugengebruik, en hoeveel items verlopen of verwijderd zijn.
Splits cijfers uit per cachelaag, en als het helpt, per type key of endpoint, een hoog totaalpercentage maskeert problemen bij kritieke functies. Stel meldingen in voor plotselinge daling van hits, langere latencies of gelijktijdige stijging van backend-verkeer. Gebruik een dashboard en kijk verschillen tussen normaal gebruik, deployments en piekkwartieren na.
Hoe voorkom ik dat cache-invalidatie verloren gaat na een databasewijziging?
Zorg dat een databasewijziging en de boodschap voor cache-invalidatie samen opgenomen worden in één transactionele outbox. Dus: schrijf tegelijk het datapunt en een event-bericht voor invalidatie, in één commitch. Een achtergrondproces verwerkt deze events, en doet herhaalde pogingen tot het lukt. Daardoor raak je geen invalidatie kwijt bij haperingen halverwege.
Zorg dat je verwerking idempotent is: hetzelfde bericht mag gerust nogmaals verwerkt worden zonder dat dat schade aanricht. Log mislukte pogingen, en bied vastgelopen berichten aan voor handmatige analyse. Voor gevoelige gegevens kun je een beperkte TTL als vangnet toevoegen, dat vangt incidentele fouten af, maar is geen vervanger voor goede afhandeling van wijzigingen.
Hoe voorkom ik een cache stampede wanneer een populair item verloopt?
Laat per cachekey maar één verzoek tegelijk de nieuwe waarde berekenen. Andere verzoeken wachten, krijgen desnoods tijdelijk een oude waarde, of een nette foutmelding als wachttijd niet kan. Zet altijd een maximale tijd op de lock, zodat je niet vastloopt als een proces crasht tijdens berekenen.
Maak vervaltijden iets verschillend per item, dan verloopt niet alles tegelijk. Ververs populaire sleutels voordat ze verlopen (‘prewarm’). Krijg je tijdelijk verouderde antwoorden? Meet of dat voor deze gegevens acceptabel is. Begrens het aantal gelijktijdige berekeningen: zo blijft je database zelfs bij storing overeind.
Hoe test ik of caching correct blijft werken bij gelijktijdige verzoeken?
Stuur meerdere gelijktijdige requests op dezelfde waarde los terwijl deze voorbij de vervaldatum is of net gewijzigd werd. Kijk: voeren maar weinig requests de zware berekening uit? Zien alle gebruikers na verloop van tijd de nieuwe versie? Worden fouten netjes afgehandeld of raken onjuiste data in de cache? Test niet alleen met één server, maar met scenario’s waarin je meerdere instanties tegelijk hebt draaien (zoals productie doet).
Neem tests op voor koude cache, haperingen in de cache, verloren invalidaties en snelle opeenvolging van update en read. Kijk verder dan alleen de uiteindelijke response: meet databaseverkeer, check logs en bekijk wat er in de cache zit. Herhaal onder belasting, en sla op welke tijdelijke verschillen je als acceptabel beschouwt voor de betreffende data.
Foto: Digital Buggu