Nett og utvikling

HTTP-caching forklart: Cache-Control, ETag, bilder og Apache-konfigurasjon

HTTP Caching Explained: Cache-Control, ETag, Images and Apache Configuration

Lær hvordan du konfigurerer nettleser-caching for HTML, CSS, JavaScript, bilder og fonter. Forstå ETag og 304-respons med praktiske eksempler, forhindre utdaterte filer, og bruk en komplett Apache .htaccess-konfigurasjon.

Du optimaliserer bildene, minifiserer CSS-en og komprimerer JavaScripten. Nettsiden laster raskere. Men når besøkende kommer tilbake, kan nettleserne laste ned samme filer igjen.

Du aktiverer caching. Alt ser bedre ut — inntil du erstatter et bilde og oppdager at noen besøkende fortsatt ser det gamle.

Dette er utfordringen med HTTP-caching: gjenbruke filer som ikke har endret seg, men hente nye versjoner når de gjør det.

I denne guiden bygger vi en caching-strategi for et ekte nettsted med Apache, PHP og nettleserutviklerverktøy.

1. HTTP-caching forklart med et enkelt eksempel

Forestill deg et nettsted med fem filer:

index.html
assets/css/style.css
assets/js/app.js
assets/images/hero.webp
assets/fonts/site.woff2

Noen besøker nettstedet ditt for første gang, så nettleseren laster ned disse filene.

Første besøk — nettleseren trenger alt

Forestill deg nå at besøkende kommer tilbake ti minutter senere.

Hvis serveren tidligere har fortalt nettleseren at CSS-filen kunne gjenbrukes i én dag, trenger nettleseren ikke å laste den ned igjen.

Nettleseren har allerede en kopi.

Det er grunnidéen med caching.

Instruksjonene kommer fra HTTP-header som sendes med serverens svar.

For eksempel:

Cache-Control: public, max-age=86400

Dette betyr at svaret kan gjenbrukes mens det er frisk i 86 400 sekunder — én dag.

Men hva skjer hvis du oppdaterer CSS-en etter bare én time?

Nettleseren kan fortsette å bruke den gamle versjonen i de resterende 23 timene.

Dette er grunnen til at det ikke er nok bare å øke cache-varigheter.

2. Cache-Control: instruksjonene som sendes til nettleseren

Cache-Control-headeren forteller nettlesere og andre HTTP-caches hvordan de skal håndtere et svar.

Her er direktivene du bruker mest.

Direktiv Enkel forklaring
max-age=3600 Gjenbruk svaret i opptil én time
public Delte cachelag, inkludert CDN-er, kan lagre svaret
private Lagre kun i et privat cachelag, ikke i et delt cachelag
no-cache Lagre hvis tillatt, men valider før gjenbruk
no-store Lagre ikke svaret
immutable Ressursen forventes ikke å endre seg mens den er frisk
must-revalidate Når den er utdatert, gjenbruk ikke uten vellykket validering

Ett særlig forvirrende direktiv er no-cache.

Det betyr ikke «lagre aldri denne filen».

Det betyr «før du bruker en lagret kopi, spør serveren om den fortsatt er gyldig».

For svar som ikke må lagres, bruk no-store.

Den distinkasjonen er viktig når du konfigurerer HTML-sider og sensitivt innhold.

3. ETag forklart: hvordan nettleseren spør om en fil har endret seg

La oss gjøre dette konkret.

Forestill deg at du har en fil som heter logo.webp.

Nettleseren laster den ned mandag.

Serveren sender også en identifikator:

ETag: "logo-version-1"

Tenk på denne identifikatoren som en etikett knyttet til denne bestemte versjonen av bildet.

Nettleseren beholder bildet og husker etiketten.

Tirsdag trenger det cachede svaret validering. I stedet for å laste ned hele bildet umiddelbart igjen, spør nettleseren:

«Hei server, jeg har allerede bildet identifisert av logo-version-1. Er det fortsatt det samme?»

Teknisk sett sender den:

GET /images/logo.webp HTTP/1.1
Host: example.com
If-None-Match: "logo-version-1"

Serveren sammenligner den identifikatoren med gjeldende versjon.

ETag-betinget forespørsel: 304 når uendret, 200 når endret

Tilfelle A: bildet har ikke endret seg

Serveren svarer:

HTTP/1.1 304 Not Modified
ETag: "logo-version-1"

Nettleseren sier, effektivt, «Flott, jeg fortsetter å bruke mitt eksisterende bilde.»

Serveren sender ikke bildedelen igjen.

Tilfelle B: bildet har endret seg

Anta at du erstatter logoet med en ny versjon.

Serveren identifiserer det nå som logo-version-2.

Nettleseren spør fortsatt om logo-version-1, men serveren svarer:

HTTP/1.1 200 OK
Content-Type: image/webp
ETag: "logo-version-2"

Denne gangen inneholder svaret det nye bildet.

Nettleseren erstatter sin lagrede kopi.

Det er alt ETag gjør for caching: det hjelper nettleseren med å sjekke om kopien fortsatt er oppdatert.

Identifikatoren trenger ikke å være en hash eller et versjonsnummer. Apache kan generere det fra filmetadata, og applikasjoner kan generere egne identifikatorer.

Test ETag selv

Først, hent responshetene:

curl -I https://example.com/images/logo.webp

Finn ETag:

ETag: "abc123"

Send deretter en betinget forespørsel:

curl -I \
  -H 'If-None-Match: "abc123"' \
  https://example.com/images/logo.webp

Hvis representasjonen er uendret, kan en riktig konfigurert server returnere 304 Not Modified.

Hvis den har endret seg, forvent 200 OK med den oppdaterte representasjonen.

En viktig begrensning: ETag tvinger ikke nettleseren til å kontakte serveren mens et cachet svar fortsatt er frisk. Hvis et bilde har en ettårs friskhetslevetid, garanterer det ikke at nettleseren sjekker ETag-en sin umiddelbart om du endrer filen på serveren.

Derfor blir ressursversjonering avgjørende.

4. Bildcaching: delen som ofte forårsaker flest problemer

Bilder er ofte blant de største ressursene på et nettsted.

En forsideside kan inneholde et heltegrønt bilde, kategoriillustrasjoner, artikkelminiatyrer, logoer, ikoner og produktbilder.

Selv når de er komprimert til WebP eller AVIF, sløkser det med båndbredde å laste ned dem gentatte ganger.

La oss se på tre virkelige situasjoner.

Situasjon A: et bilde som aldri endrer seg

Nettstedet ditt har et dekorativt bilde:

/images/background-v1.webp

Du vet at når som helst designet endres, vil du bruke et nytt filnavn.

Du kan trygt konfigurere:

Cache-Control: public, max-age=31536000, immutable

Nettleseren kan gjenbruke det i ett år uten å kontakte serveren mens svaret er frisk.

Situasjon B: et bilde erstattet under samme filnavn

Artikelen din inneholder:

<img src="/images/article-hero.webp" alt="Article illustration">

Du erstatter article-hero.webp med et nytt bilde, men beholder samme URL.

Hvis nettleseren har et friskt cachet svar med lang levetid, kan det fortsette å vise det gamle bildet.

Løsningen er å endre URL-en når innholdet endres.

For eksempel:

<img src="/images/article-hero.webp?v=2" alt="Article illustration">

Eller, bedre, generer et versjonsert filnavn:

<img src="/images/article-hero-a81c.webp" alt="Article illustration">

Nå ser nettleseren en annen ressurs-URL og forespør det nye bildet.

Det gamle cachede bildet er ufarlig fordi HTML ikke lenger refererer til det.

Erstatte et bilde under samme URL versus å bruke en ny versjonsert URL

Situasjon C: tusenvis av bilder med stabile filnavn

Forestill deg en redaksjonell nettside med tusenvis av artikler.

Å omdøpe hvert bilde manuelt ville være upraktisk.

Du kan i stedet velge en moderat cache-levetid, som én dag eller én uke, og stole på revalidering etter utløp.

For eksempel:

Cache-Control: public, max-age=86400

Det er en rimelig kompromis når automatisk bildeversjonering ikke er tilgjengelig.

Likevel kan besøkende fortsatt se et eldre bilde i løpet av friskhetsperioden.

For bilder som må oppdateres umiddelbart, er en endret URL eller eksplisitt cache-invalidering at foretrekke.

Hva med JPEG, PNG, SVG, WebP og AVIF?

Caching-prinsippet er identisk for alle dem.

Bildeformat Typisk bruk Caching-strategi
JPEG Foto Lang cache hvis URL er versjonsert
PNG Grafikk, gjennomsiktighet Samme
WebP Optimerte nettbilder Samme
AVIF Høyt komprimert bilder Samme
SVG Ikoner, logoer, illustrasjoner Samme
GIF Enkle animasjoner Samme

Formatet påvirker komprimering og avkoding, men det endrer ikke grunnleggende HTTP-cache oppførsel.

Husk også at responsive bilder kan produsere flere uavhengige cache-poster:

<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>

Hver valgt URL har sin egen caching-atferd.

Hvis du erstatter bildet, oppdater URL-ene for hver relevant variant.

5. Versjonsstyr CSS, JavaScript og bilder automatisk med PHP

For PHP-nettsteder kan du unngå manuell oppdatering av versjonsnumre ved å bruke filens endringstid.

Her er en liten hjelpefunksjon:

<?php

function assetUrl(string $path): string
{
    $file = $_SERVER['DOCUMENT_ROOT'] . $path;

    if(!is_file($file)) {
        return $path;
    }

    return $path . '?v=' . filemtime($file);
}

Bruk den slik:

<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">

Anta at filens endringstidsstempel er 1794800000.

Nettleseren mottar en URL som:

/assets/images/hero.webp?v=1794800000

Når du oppdaterer filen og endringstiden endres, endres også URL-en.

Dette er en enkel cache-busting-strategi.

For produksjonsbygg-pipeliner er innholdshasjer mer robuste fordi tidsstempler kan bevares under distribusjoner eller endre seg uten at innholdet endrer seg.

Viktig: Hvis CDN-en din er konfigurert til å ignorere spørringsstrenger i cache-nøkkelen, vil ?v= kanskje ikke produsere et distinkt cachet ressurs. Verifiser CDN-konfigurasjonen eller bruk versjonserte filnavn i stedet.

6. Forveksle ikke nettlesercache, servercache og CDN-cache

Et nettsted kan ha flere cachelag.

Nettlesercachen lagrer svar på de besøkendes enhet.

En CDN lagrer utvalgte svar på servere geografisk nærmere de besøkende.

En applikasjonscache kan lagre generert HTML, databaseforespørselsresultater eller annen beregnet data.

Disse lagene løser forskjellige problemer.

For eksempel kan en CDN levere et utdatert bilde selv etter at nettlesercachen er tømt.

Tilsvarende vil tømming av en CMS-cache ikke nødvendigvis ugyldigjøre et bilde som allerede er lagret av en nettleser eller CDN.

Når du feilsøker, identifiser hvilket lager som leverer det gamle innholdet før du endrer konfigurasjonen.

7. Hostingytelse og HTTP-caching

HTTP-caching kan betydelig redusere gjentatte nedlastninger, men det kan ikke kompensere for alle hosting-problemer.

For eksempel, hvis en ucachet PHP-side tar to sekunder å generere på grunn av langsomme databasespørringer, vil nettlesercaching av bilder ikke løse den underliggende serverresponstiden.

Et pålitelig hosting-miljø bør gi passende PHP-yteevne, lagring, komprimering, TLS og støtte for caching-header.

For små og mellomstore nettsteder kan en hosting-leverandør som PlanetHoster være en del av en praktisk oppsett.

For applikasjoner som krever mer kontroll over serverressurser, distribueringsarbeidsflyter eller caching-arkitektur, kan Cloudways også være verdt å evaluere.

Før du bytter leverandør, mål den faktiske flaskehalsen: serverresponstid, bildevekt, PHP-utførelse, databasespørringer eller cache-konfigurasjon.

8. Slik inspeksjonerer du caching i Firefox og Chrome

Åpne nettleserutviklerverktøyene dine.

I Firefox, trykk F12, deretter velg Nettverk.

Last inn nettstedet ditt på nytt og klikk på et bilde- eller stylesheet-forespørsel.

Se på responshetene.

For eksempel:

Cache-Control: public, max-age=86400
ETag: "abc123"
Last-Modified: Mon, 16 Nov 2026 09:00:00 GMT

Gjenta nå navigasjonen uten å deaktivere cachen.

Avhengig av nettleseren, ressursens friskhet og hvordan navigasjonen ble initiert, kan det lastes fra lokal cache, revalideres med en 304, eller lastes ned igjen.

For å teste et spesifikt bilde uavhengig:

curl -sS -D - -o /dev/null \
  https://example.com/assets/images/hero.webp

Sjekk status, Cache-Control, ETag og Last-Modified.

Gjenta deretter forespørselen med If-None-Match ved å bruke den faktiske ETag-en som returneres av serveren din.

Unngå å bruke en tvingt omlastning som din eneste cache-test: det kan bevisst omgå eller revaliderere cachede svar.

9. Fullstendig Apache .htaccess-eksempel for et ekte nettsted

La oss avslutte med en praktisk konfigurasjon.

Dette eksempelet er laget for et offentlig nettsted som kjører Apache 2.4, med en blanding av statiske filer og PHP-generert HTML.

Strategien er bevisst konservativ:

  • HTML revalideres.
  • CSS og JavaScript bruker en sju dagers cache.
  • Bilder bruker en sju dagers cache.
  • Skrifttyper bruker en lengre cache.
  • Manifestfiler bruker en kort cache.
  • ETag forblir tilgjengelig for validering av statiske filer.
  • PHP-svar kan sette egne policyer.

Dette er en startkonfigurasjon, ikke en universell ferdig å bruke erstatning. Sjekk hosting-leverandørens eksisterende regler, aktivierte moduler og Apache-override-tillatelser før du distribuerer den.

# ============================================================
# 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.

Viktige merknader om denne konfigurasjonen

1. Dupliser ikke en eksisterende caching-konfigurasjon.

Hvis hosting-leverandøren, CMS-en eller cache-plugin-en din allerede setter disse headerne, slå sammen policyene nøye.

Apaches mod_expires genererer utløps- og max-age-informasjon, mens mod_headers kan angi Cache-Control eksplisitt. Avhengig av hvordan headerne genereres og lagres internt, kan kombinasjon av begge produsere duplikate eller motsidige verdier.

Inspektér den faktiske HTTP-responsen og forenkle konfigurasjonen om nødvendig. For en produksjonsdistribusjon er det å foretrekke å velge ett konsistent mekanisme for hver ressursklasse.

2. ETag er ikke obligatorisk for hvert svar.

FileETag MTime Size-direktivet gjelder for filer servert av Apache. Det gir ikke automatisk meningsfulle validerere for dynamisk genererte PHP-sider.

På distribuerte servere kan metadata-baserte ETags også kreve ytterligere vurdering.

3. Komprimering er ikke bildeoptimalisering.

Gzip er nyttig for tekstbaserte ressurser som HTML, CSS, JavaScript, JSON og SVG.

JPEG, WebP, AVIF og PNG er allerede komprimerte formater. Ytterligere gzip-komprimering gir som regel liten nytte.

Hvis serveren din allerede støtter Brotli, unngå å legge til konkurranseende komprimeringskonfigurasjoner uten å sjekke den eksisterende oppsettet.

4. Sju dager er en kompromis.

Hvis alle dine statiske ressurser har pålitelig versjonserte URL-er, kan du forlænge cache-levetiden deres til ett år og bruke immutable.

Hvis du rutinemessig erstatter bilder uten å endre URL-ene, kan sju dager fortsatt være for lang tid.

Velg policyen basert på hvordan nettstedet ditt distribueres.

10. Test konfigurasjonen før og etter distribusjon

Bruk denne listen.

Test Forventet resultat
Forespør et bilde Cache-Control avspeiler bildepolicy
Forespør et stylesheet Riktig CSS-caching-policy
Forespør HTML Revalideringspolicy
Forespør en privat side Ingen utilsiktet delt caching
Send If-None-Match 304 hvis uendret og validering støttes
Erstatt et versjonsert bilde Ny URL laster nytt bilde
Inspekter komprimert CSS Pass innholdskoding
Sjekk nettleser-Nettverks-panel Ingen uventede gjentatte fulle nedlastinger

For eksempel:

curl -I https://example.com/assets/images/hero.webp

Deretter:

curl -I https://example.com/assets/css/site.css

Og til slutt:

curl -I https://example.com/

Sammenlign responshetene.

Hvis en fil ikke har forventet caching-header, verifiser om Apache faktisk serverer det, om den relevante modulen er aktivert, og om en CDN eller applikasjonslager overskriver responsen.

Hvis nettstedet returnerer en 500 Internal Server Error etter redigering av .htaccess, gjenopprett den forrige konfigurasjonen og inspiser Apache-feilloggen. Ustøttede direktiver eller ikke-tillatte overstyringer er vanlige årsaker.

11. Når en CDN eller administret hosting blir nyttig

For nettsteder med besøkende i forskjellige land kan en CDN redusere avstanden mellom brukere og cachede statiske ressurser.

Likevel er det ikke automatisk en forbedring å legge til en CDN.

Først, sørg for at bilder er korrekt størrelse og komprimert, nettlesercaching fungerer, og statiske ressurs-URL-er er versjonserte.

Mål deretter om CDN-en forbedrer faktiske leveringstider.

En hosting-plattform med passende caching-kontroller kan forenkle dette oppsettet, men du bør fortsatt forstå hvilket cachelag som er ansvarlig for hvert svar.

PlanetHoster og Cloudways er to hosting-alternativer verdt å evaluere avhengig av applikasjonens krav, driftsbehov og tilgjengelige serverkontroller.

Det viktige spørsmålet er ikke hvilken leverandør som reklamere mest med caching-funksjoner. Det er om du kan konfigurere, måle og ugyldiggjøre cachet innhold pålitelig.

Konklusjon

HTTP-caching blir mye enklere å administrere når du skiller tre spørsmål:

Kan dette svaret lagres? Hvor lenge kan det gjenbrukes uten å sjekke? Hvordan vet nettleseren om det har endret seg?

Cache-Control svarer på de to første spørsmålene.

ETag og betingede forespørsler hjelper med å svare på det tredje.

For statiske ressurser som bilder, CSS og JavaScript er versjonserte URL-er ofte den mest pålitelige måten å kombinere lange cache-levetider med umiddelbare oppdateringer.

For HTML og hyppig endret innhold er revalidering vanligvis mer hensiktsmessig.

Start med en konservativ konfigurasjon, test den med ekte HTTP-forespørsler, og øk bare cache-levetider når du forstår hvordan nettstedet håndterer oppdateringer.