Web e sviluppo

Spiegazione della Cache HTTP: Cache-Control, ETag, Immagini e Configurazione Apache

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

Impara come configurare la cache del browser per HTML, CSS, JavaScript, immagini e font. Comprendi ETag e risposte 304 con esempi pratici, evita file obsoleti e utilizza una configurazione completa di Apache .htaccess.

Caching HTTP spiegato: Cache-Control, ETag, immagini e configurazione Apache

Ottimizzi le tue immagini, minifichi il CSS e comprimi il JavaScript. Il tuo sito web si carica più velocemente. Ma quando i visitatori tornano, i loro browser potrebbero scaricare di nuovo gli stessi file.

Abiliti il caching. Tutto sembra migliore — finché non sostituisci un'immagine e scopri che alcuni visitatori vedono ancora quella vecchia.

Questa è la sfida del caching HTTP: riutilizzare i file che non sono cambiati, ma recuperare le nuove versioni quando cambiano.

In questa guida costruiremo una strategia di caching per un sito web reale usando Apache, PHP e gli strumenti per sviluppatori del browser.

1. Il caching HTTP spiegato con un semplice esempio

Immagina un sito web con cinque file:

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

Quando qualcuno visita il tuo sito web per la prima volta, il browser scarica questi file.

Prima visita — il browser ha bisogno di tutto

Ora immagina che il visitatore torni dieci minuti dopo.

Se il server ha precedentemente comunicato al browser che il file CSS poteva essere riutilizzato per un giorno, il browser non deve scaricarlo di nuovo.

Il browser ne ha già una copia.

Questa è l'idea di base del caching.

Le istruzioni provengono dagli header HTTP inviati con la risposta del server.

Per esempio:

Cache-Control: public, max-age=86400

Questo significa che la risposta può essere riutilizzata finché è fresca per 86.400 secondi — un giorno.

Ma cosa succede se aggiorni il CSS dopo solo un'ora?

Il browser potrebbe continuare a usare la versione vecchia per le restanti 23 ore.

Ecco perché aumentare semplicemente la durata della cache non è sufficiente.

2. Cache-Control: le istruzioni inviate al browser

L'header Cache-Control indica ai browser e agli altri cache HTTP come gestire una risposta.

Ecco le direttive che userai più spesso.

Direttiva Spiegazione semplice
max-age=3600 Riutilizza la risposta per un massimo di un'ora
public Le cache condivise, inclusi i CDN, possono memorizzare la risposta
private Memorizza solo in una cache privata, non in una cache condivisa
no-cache Memorizza se consentito, ma convalida prima del riutilizzo
no-store Non memorizzare la risposta
immutable Non si prevede che la risorsa cambi mentre è fresca
must-revalidate Una volta non più fresca, non riutilizzare senza una convalida riuscita

Una direttiva particolarmente confusa è no-cache.

Non significa "non memorizzare mai questo file".

Significa "prima di usare una copia memorizzata, chiedi al server se è ancora valida".

Per le risposte che non devono essere memorizzate, usa no-store.

Questa distinzione è importante quando si configurano pagine HTML e contenuti sensibili.

3. ETag spiegato: come il browser chiede se un file è cambiato

Rendiamo tutto concreto.

Immagina di avere un file chiamato logo.webp.

Il browser lo scarica lunedì.

Il server invia anche un identificatore:

ETag: "logo-version-1"

Pensa a questo identificatore come a un'etichetta attaccata a quella particolare versione dell'immagine.

Il browser conserva l'immagine e ricorda l'etichetta.

Martedì, la risposta in cache necessita di convalida. Invece di scaricare immediatamente di nuovo l'intera immagine, il browser chiede:

"Ciao server, ho già l'immagine identificata da logo-version-1. È ancora la stessa?"

Tecnicamente, invia:

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

Il server confronta quell'identificatore con la versione corrente.

Richiesta condizionale ETag: 304 se invariata, 200 se cambiata

Caso A: l'immagine non è cambiata

Il server risponde:

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

Il browser dice, in pratica: "Ottimo, continuerò a usare l'immagine che ho già."

Il server non invia di nuovo il corpo dell'immagine.

Caso B: l'immagine è cambiata

Supponi di sostituire il logo con una nuova versione.

Il server ora la identifica come logo-version-2.

Il browser chiede ancora informazioni su logo-version-1, ma il server risponde:

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

Questa volta, la risposta include la nuova immagine.

Il browser sostituisce la copia in cache.

Questo è tutto ciò che ETag fa per il caching: aiuta il browser a verificare se la sua copia è ancora aggiornata.

L'identificatore non deve necessariamente essere un hash o un numero di versione. Apache può generarlo dai metadati del file, e le applicazioni possono generare i propri identificatori.

Testa ETag da solo

Per prima cosa, recupera gli header della risposta:

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

Trova l'ETag:

ETag: "abc123"

Poi invia una richiesta condizionale:

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

Se la rappresentazione non è cambiata, un server configurato correttamente può restituire 304 Not Modified.

Se è cambiata, aspettati 200 OK con la rappresentazione aggiornata.

Una limitazione importante: ETag non obbliga il browser a contattare il server mentre una risposta in cache è ancora fresca. Se un'immagine ha una durata di freschezza di un anno, cambiare il file sul server non garantisce che il browser controllerà immediatamente il suo ETag.

È qui che il versioning delle risorse diventa essenziale.

4. Caching delle immagini: la parte che spesso causa più problemi

Le immagini sono spesso tra le risorse più pesanti di un sito web.

Una home page potrebbe contenere un'immagine hero, illustrazioni di categoria, miniature di articoli, loghi, icone e immagini di prodotti.

Anche quando sono compresse in WebP o AVIF, scaricarle ripetutamente spreca larghezza di banda.

Esaminiamo tre situazioni reali.

Situazione A: un'immagine che non cambia mai

Il tuo sito web ha un'immagine decorativa:

/images/background-v1.webp

Sai che, ogni volta che il design cambia, userai un nuovo nome file.

Puoi configurare in sicurezza:

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

Il browser può riutilizzarla per un anno senza contattare il server mentre la risposta è fresca.

Situazione B: un'immagine sostituita con lo stesso nome file

Il tuo articolo contiene:

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

Sostituisci article-hero.webp con una nuova immagine, ma mantieni lo stesso URL.

Se il browser ha una risposta in cache fresca con una lunga durata, potrebbe continuare a mostrare l'immagine vecchia.

La soluzione è cambiare l'URL quando cambia il contenuto.

Per esempio:

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

O, meglio ancora, generare un nome file versionato:

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

Ora il browser vede un URL di risorsa diverso e richiede la nuova immagine.

L'immagine vecchia in cache è innocua perché l'HTML non la referenzia più.

Sostituire un'immagine con lo stesso URL rispetto all'uso di un nuovo URL versionato

Situazione C: migliaia di immagini con nomi file stabili

Immagina un sito editoriale contenente migliaia di articoli.

Rinominare manualmente ogni immagine sarebbe scomodo.

Puoi invece scegliere una durata della cache moderata, come un giorno o una settimana, e affidarti alla riconvalida dopo la scadenza.

Per esempio:

Cache-Control: public, max-age=86400

Questo è un compromesso ragionevole quando il versioning automatico delle immagini non è disponibile.

Tuttavia, i visitatori possono ancora vedere un'immagine più vecchia durante il periodo di freschezza.

Per le immagini che devono aggiornarsi immediatamente, è preferibile un URL cambiato o un'invalidazione esplicita della cache.

E per JPEG, PNG, SVG, WebP e AVIF?

Il principio di caching è identico per tutti.

Formato immagine Uso tipico Strategia di caching
JPEG Foto Cache lunga se l'URL è versionato
PNG Grafica, trasparenza Uguale
WebP Immagini web ottimizzate Uguale
AVIF Immagini altamente compresse Uguale
SVG Icone, loghi, illustrazioni Uguale
GIF Animazioni semplici Uguale

Il formato influisce sulla compressione e sulla decodifica, ma non cambia fondamentalmente il comportamento della cache HTTP.

Ricorda anche che le immagini responsive possono produrre diverse voci di cache indipendenti:

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

Ogni URL selezionato ha il proprio comportamento di caching.

Se sostituisci l'immagine, aggiorna gli URL di ogni variante rilevante.

5. Versionare automaticamente CSS, JavaScript e immagini con PHP

Per i siti web PHP, puoi evitare di aggiornare manualmente i numeri di versione usando l'ora di modifica del file.

Ecco un piccolo helper:

<?php

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

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

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

Usalo così:

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

Supponi che il timestamp di modifica del file sia 1794800000.

Il browser riceve un URL come:

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

Quando aggiorni il file e il suo timestamp di modifica cambia, cambia anche l'URL.

Questa è una semplice strategia di cache busting.

Per le pipeline di build di produzione, gli hash del contenuto sono più robusti perché i timestamp possono essere preservati durante i deployment o cambiare senza che il contenuto cambi.

Importante: se il tuo CDN è configurato per ignorare le query string nella sua chiave di cache, ?v= potrebbe non produrre una risorsa distinta in cache. Verifica la configurazione del CDN oppure usa nomi file versionati.

6. Non confondere cache del browser, cache del server e cache CDN

Un sito web può avere diversi livelli di caching.

La cache del browser memorizza le risposte sul dispositivo del visitatore.

Un CDN memorizza le risposte selezionate su server geograficamente più vicini ai visitatori.

Una cache applicativa può memorizzare HTML generato, risultati di query al database o altri dati calcolati.

Questi livelli risolvono problemi diversi.

Per esempio, un CDN può servire un'immagine obsoleta anche dopo che la cache del browser è stata svuotata.

Allo stesso modo, svuotare la cache di un CMS non invalida necessariamente un'immagine già memorizzata da un browser o da un CDN.

Durante il debug, identifica quale livello sta servendo il contenuto vecchio prima di cambiare la configurazione.

7. Prestazioni dell'hosting e caching HTTP

Il caching HTTP può ridurre significativamente i download ripetuti, ma non può compensare ogni problema di hosting.

Per esempio, se una pagina PHP non in cache impiega due secondi per essere generata a causa di query lente al database, il caching delle immagini da parte del browser non risolverà il tempo di risposta sottostante del server.

Un ambiente di hosting affidabile dovrebbe offrire prestazioni PHP adeguate, storage, compressione, TLS e supporto per gli header di caching.

Per siti web piccoli e medi, un provider di hosting come PlanetHoster può far parte di una configurazione pratica.

Per applicazioni che richiedono maggiore controllo sulle risorse del server, sui flussi di deployment o sull'architettura di caching, anche Cloudways potrebbe valere la pena di essere valutato.

Prima di cambiare provider, misura il collo di bottiglia reale: tempo di risposta del server, peso delle immagini, esecuzione PHP, query al database o configurazione della cache.

8. Come ispezionare il caching in Firefox e Chrome

Apri gli strumenti per sviluppatori del browser.

In Firefox, premi F12, poi seleziona Network.

Ricarica il tuo sito web e fai clic su una richiesta di immagine o foglio di stile.

Guarda i suoi header di risposta.

Per esempio:

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

Ora ripeti la navigazione senza disabilitare la cache.

A seconda del browser, della freschezza della risorsa e di come è stata avviata la navigazione, la risorsa potrebbe essere caricata dalla cache locale, riconvalidata con un 304 oppure scaricata di nuovo.

Per testare un'immagine specifica in modo indipendente:

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

Controlla lo stato, Cache-Control, ETag e Last-Modified.

Poi ripeti la richiesta con If-None-Match usando l'ETag effettivo restituito dal tuo server.

Evita di usare un ricaricamento forzato come unico test della cache: potrebbe bypassare o riconvalidare deliberatamente le risposte in cache.

9. Esempio completo di .htaccess Apache per un sito web reale

Concludiamo con una configurazione pratica.

Questo esempio è pensato per un sito web pubblico in esecuzione su Apache 2.4, con una combinazione di file statici e HTML generato da PHP.

La strategia è deliberatamente conservativa:

  • L'HTML viene riconvalidato.
  • CSS e JavaScript usano una cache di sette giorni.
  • Le immagini usano una cache di sette giorni.
  • I font usano una cache più lunga.
  • I file manifest usano una cache breve.
  • ETag rimane disponibile per la convalida dei file statici.
  • Le risposte PHP possono impostare le proprie policy.

Questa è una configurazione di partenza, non una sostituzione universale pronta all'uso. Controlla le regole esistenti del provider di hosting, i moduli abilitati e i permessi di override di Apache prima di distribuirla.

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

Note importanti su questa configurazione

1. Non duplicare una configurazione di caching esistente.

Se il tuo provider di hosting, il tuo CMS o il tuo plugin di cache impostano già questi header, unisci le policy con attenzione.

mod_expires di Apache genera informazioni di scadenza e max-age, mentre mod_headers può impostare esplicitamente Cache-Control. A seconda di come gli header vengono generati e memorizzati internamente, combinare entrambi può produrre valori duplicati o in conflitto.

Ispeziona la risposta HTTP effettiva e semplifica la configurazione se necessario. Per un deployment in produzione, è preferibile scegliere un unico meccanismo coerente per ogni classe di risorsa.

2. ETag non è obbligatorio per ogni risposta.

La direttiva FileETag MTime Size si applica ai file serviti da Apache. Non fornisce automaticamente validatori significativi per le pagine PHP generate dinamicamente.

Su server distribuiti, gli ETag basati sui metadati possono anche richiedere considerazioni aggiuntive.

3. La compressione non è ottimizzazione delle immagini.

Gzip è utile per risorse basate su testo come HTML, CSS, JavaScript, JSON e SVG.

JPEG, WebP, AVIF e PNG sono formati già compressi. Un'ulteriore compressione gzip di solito offre pochi vantaggi.

Se il tuo server supporta già Brotli, evita di aggiungere configurazioni di compressione in competizione senza controllare la configurazione esistente.

4. Sette giorni sono un compromesso.

Se tutte le tue risorse statiche hanno URL versionati in modo affidabile, puoi estendere la loro durata in cache a un anno e usare immutable.

Se sostituisci regolarmente immagini senza cambiarne gli URL, sette giorni potrebbero essere comunque troppo.

Scegli la policy in base a come viene distribuito il tuo sito web.

10. Testa la configurazione prima e dopo il deployment

Usa questa checklist.

Test Risultato atteso
Richiedi un'immagine Cache-Control riflette la policy delle immagini
Richiedi un foglio di stile Policy di caching CSS corretta
Richiedi HTML Policy di riconvalida
Richiedi una pagina privata Nessun caching condiviso accidentale
Invia If-None-Match 304 se invariata e convalida supportata
Sostituisci un'immagine versionata Il nuovo URL carica la nuova immagine
Ispeziona il CSS compresso Content encoding appropriato
Controlla il pannello Network del browser Nessun download completo ripetuto imprevisto

Per esempio:

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

Poi:

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

E infine:

curl -I https://example.com/

Confronta gli header di risposta.

Se un file non ha l'header di caching atteso, verifica se Apache lo sta effettivamente servendo, se il modulo rilevante è abilitato e se un CDN o un livello applicativo sovrascrive la risposta.

Se il sito restituisce un 500 Internal Server Error dopo aver modificato .htaccess, ripristina la configurazione precedente e ispeziona il log degli errori di Apache. Direttive non supportate o override non consentiti sono cause comuni.

11. Quando un CDN o un hosting gestito diventa utile

Per siti web con visitatori in paesi diversi, un CDN può ridurre la distanza tra gli utenti e le risorse statiche in cache.

Tuttavia, aggiungere un CDN non è automaticamente un miglioramento.

Per prima cosa, assicurati che le immagini siano dimensionate e compresse correttamente, che il caching del browser funzioni e che gli URL delle risorse statiche siano versionati.

Poi misura se il CDN migliora i tempi di consegna reali.

Una piattaforma di hosting con controlli di caching adeguati può semplificare questa configurazione, ma dovresti comunque capire quale livello di cache è responsabile di ogni risposta.

PlanetHoster e Cloudways sono due opzioni di hosting che vale la pena valutare a seconda dei requisiti dell'applicazione, delle esigenze operative e dei controlli server disponibili.

La domanda importante non è quale provider pubblicizzi il maggior numero di funzionalità di caching. È se puoi configurare, misurare e invalidare in modo affidabile il contenuto in cache.

Conclusione

Il caching HTTP diventa molto più facile da gestire una volta separate tre domande:

Questa risposta può essere memorizzata? Per quanto tempo può essere riutilizzata senza controllo? Come fa il browser a sapere se è cambiata?

Cache-Control risponde alle prime due domande.

ETag e le richieste condizionali aiutano a rispondere alla terza.

Per le risorse statiche come immagini, CSS e JavaScript, gli URL versionati sono spesso il modo più affidabile per combinare lunghe durate della cache con aggiornamenti immediati.

Per l'HTML e i contenuti che cambiano frequentemente, la riconvalida è di solito più appropriata.

Inizia con una configurazione conservativa, testala con richieste HTTP reali e aumenta le durate della cache solo quando hai capito come il sito web gestisce gli aggiornamenti.