HTTP e Web Serverper Svogliati
Ogni pagina, ogni API, ogni app sul telefono parla HTTP. Una domanda, una risposta, qualche riga di intestazioni. Sopra ci hanno costruito cookie, HTTPS, HTTP/2 e HTTP/3. Capita la domanda e la risposta, il resto si legge con curl -v.
"Sul mio computer funziona." — Detto con la cache del browser piena da tre settimane.
Da una riga di testo a QUIC
Trent'anni per passare da "dammi questa pagina" a un protocollo che viaggia su UDP e cifra tutto, anche le intestazioni.
Al CERN i fisici volevano leggere i documenti dei colleghi su computer diversi, con un clic su un collegamento. Serviva un modo semplicissimo per dire a un altro computer "mandami il documento che si chiama così". HTTP (HyperText Transfer Protocol) è nato per questo. Tutto il resto, dalle intestazioni ai cookie a HTTP/3, è stato aggiunto dopo, man mano che il web diventava negozi, banche, video e applicazioni.
HTTP/0.9
Tim Berners-Lee scrive il primo server e il primo browser. Il protocollo è una riga: GET /pagina. Niente intestazioni, niente codici di errore, solo HTML.
Netscape: cookie e SSL
Per fare il carrello di un negozio serve ricordarsi chi sei: Lou Montulli inventa i cookie. Per pagare serve cifrare: nasce SSL, il nonno di TLS.
HTTP/1.0 e HTTP/1.1
Arrivano intestazioni, codici di stato, tipi di contenuto. HTTP/1.1 aggiunge l'intestazione Host (tanti siti su un solo IP) e le connessioni che restano aperte. È ancora in uso oggi.
Il problema C10K
Come si servono diecimila client insieme su un solo server? Un processo per connessione non regge. Da questa domanda nasceranno nginx (2004) e i server a eventi.
SPDY
Google sperimenta in Chrome un protocollo binario con più richieste sulla stessa connessione. Funziona, e diventa la base di HTTP/2.
HTTP/2
Stessi metodi e stesse intestazioni, ma trasporto nuovo: frame binari, multiplexing, intestazioni compresse. I browser lo usano solo con HTTPS.
QUIC e HTTP/3
QUIC diventa standard (RFC 9000): un trasporto nuovo su UDP con TLS 1.3 incorporato. HTTP/3 (RFC 9114) ci gira sopra. Nello stesso anno le specifiche di HTTP vengono riscritte e separate: la semantica (RFC 9110) è una sola, le versioni sono solo modi diversi di trasportarla.
Perché devi capirlo
Perché "il sito non va" è una frase che non vuol dire niente, e HTTP ti dice esattamente cosa non va. Basta leggerlo.
I codici parlano
502 non è 504, 401 non è 403. Il codice ti dice già se il problema è il client, il proxy o l'applicazione (sezione 14).
Il reverse proxy
Quasi ogni servizio oggi sta dietro a nginx, Caddy o Cloudflare. Se non sai cosa aggiunge e cosa toglie il proxy, impazzisci con IP, redirect e WebSocket.
Login e sessioni
"Mi butta fuori ogni cinque minuti", "da Chrome entra, da Safari no": quasi sempre sono attributi dei cookie.
La cache
"Ho cambiato il file ma vedo quello vecchio." La cache del browser, del proxy o del CDN: sapere chi la controlla ti risparmia ore.
La sicurezza
HSTS, CSP, CORS e gli attributi dei cookie sono intestazioni HTTP. Metà della sicurezza di un sito si configura in cinque righe del server.
La velocità
HTTP/2, HTTP/3, compressione e cache fanno più differenza di quasi ogni ottimizzazione del codice. E costano una riga di configurazione.
Le versioni, a confronto
Cambia il modo di trasportare le richieste, non le richieste. GET resta GET, 404 resta 404.
| Voce | HTTP/1.1 | HTTP/2 | HTTP/3 |
|---|---|---|---|
| Trasporto | TCP | TCP | QUIC su UDP, porta 443 |
| Formato | Testo | Frame binari | Frame binari |
| Richieste in parallelo | Una alla volta per connessione; i browser aprono fino a 6 connessioni per sito | Tante sulla stessa connessione (multiplexing) | Tante, e indipendenti anche quando si perde un pacchetto |
| Intestazioni | Ripetute per intero a ogni richiesta | Compresse (HPACK) | Compresse (QPACK) |
| Cifratura | Facoltativa | Nei browser sì, sempre | Sempre, non si può togliere |
| Va bene per | Tra proxy e applicazione, debug, client semplici | Il default di qualsiasi sito in HTTPS | Telefoni, reti lente o che perdono pacchetti, chi cambia rete (Wi-Fi → 4G) |
Alt-Svc: h3=":443", dalla volta dopo prova HTTP/3 su UDP. Se UDP è bloccato, torna a TCP senza dire niente a nessuno. Per questo HTTP/3 "rotto" di solito non si nota: si nota solo che non viene usato.
Il concetto chiave: una domanda, una risposta
Il client chiede, il server risponde, e poi si dimentica di te. Tutto HTTP sta qui.
Arrivi allo sportello con un modulo: cosa vuoi (il metodo e l'indirizzo) e qualche casella compilata (le intestazioni). L'impiegato ti restituisce il modulo con un timbro (il codice di stato), qualche nota (le intestazioni di risposta) e, se c'è, il pacco (il corpo). Poi chiama il prossimo e non si ricorda di te. Se torni, devi farti riconoscere di nuovo: per questo esistono i cookie (sezione 7).
HTTP non ha memoria
Ogni richiesta è indipendente. Login, carrello, lingua scelta: tutto quello che deve "ricordarsi" viaggia di nuovo in ogni richiesta, quasi sempre in un cookie.
Le intestazioni comandano
Il corpo è il contenuto, le intestazioni sono le istruzioni: che tipo di file è, quanto tenerlo in cache, chi può leggerlo, dove andare dopo. Quando qualcosa si comporta in modo strano, guarda prima le intestazioni.
Il codice di stato non mente
Le pagine di errore possono essere belle, brutte o vuote. Il numero nella prima riga della risposta è quello che conta: è lì che inizi a cercare.
URL, metodi e codici di stato
Tre cose da sapere a memoria: com'è fatto un indirizzo, cosa vuole dire ogni verbo, cosa vuole dire ogni centinaio.
| Metodo | Cosa fa | Sicuro / idempotente | Nota |
|---|---|---|---|
| GET | Legge una risorsa | Sì / sì | Non deve mai modificare niente: i crawler e i prefetch dei browser lo chiamano da soli |
| HEAD | Come GET, ma solo le intestazioni | Sì / sì | curl -I. Comodo per vedere dimensione, tipo e cache senza scaricare |
| POST | Manda dati: un modulo, un upload, un'azione | No / no | Ripeterlo può creare due ordini. Per questo il browser chiede "inviare di nuovo il modulo?" |
| PUT | Sostituisce una risorsa intera | No / sì | Ripeterlo dà lo stesso risultato |
| PATCH | Modifica una parte | No / non sempre | Tipico delle API REST |
| DELETE | Cancella | No / sì | |
| OPTIONS | Chiede cosa si può fare | Sì / sì | Il browser lo usa da solo per il "preflight" CORS (sezione 13) |
| Famiglia | Vuol dire | I codici che vedrai |
|---|---|---|
| 1xx | Informazione, vai avanti | 101 cambio protocollo (WebSocket), 103 Early Hints |
| 2xx | Tutto bene | 200 OK, 201 creato, 204 fatto, niente da mostrare, 206 un pezzo (video, download ripresi) |
| 3xx | Vai da un'altra parte | 301/308 spostato per sempre, 302/307 per ora, 304 non cambiato, usa la tua copia |
| 4xx | Hai sbagliato tu (il client) | 400, 401 chi sei?, 403 so chi sei ma no, 404, 413, 429 rallenta |
| 5xx | Ha sbagliato il server | 500 l'applicazione è esplosa, 502/504 il proxy non ha avuto risposta dall'applicazione, 503 non disponibile |
Le intestazioni, quelle che contano
Ne esistono centinaia. Queste sono quelle che leggerai davvero, e curl è l'unico strumento che ti serve per vederle.
# tutto: richiesta (righe con >), risposta (righe con <), TLS e connessione (righe con *)
curl -v https://example.com -o /dev/null
# solo le intestazioni della risposta
curl -sI https://example.com
# seguire i redirect e vedere ogni passaggio
curl -sIL http://example.com | grep -iE '^(HTTP|location)'
# mandare un'intestazione a mano
curl -s -H 'Accept-Language: it' -H 'User-Agent: prova' https://example.com
# chiedere un sito a un IP preciso (prima di cambiare il DNS, o per un server dietro al bilanciatore)
curl -sI --resolve example.com:443:192.168.1.20 https://example.com
| Intestazione | Chi la manda | A cosa serve |
|---|---|---|
Host | Client | Quale sito vuoi su quell'IP. Senza, i virtual host non esisterebbero |
User-Agent | Client | Chi sei: browser, curl, bot. Si può falsificare, non fidarti |
Accept, Accept-Language, Accept-Encoding | Client | Che formati, lingue e compressioni capisci |
Authorization | Client | Credenziali: Basic (utente e password in base64, solo con HTTPS) o Bearer (un token) |
Cookie / Set-Cookie | Client / server | Il server consegna un cookie, il client lo rimanda (sezione 7) |
Content-Type | Entrambi | Che cos'è il corpo: text/html; charset=utf-8, application/json. Sbagliato = file scaricato invece che mostrato, o caratteri strani |
Content-Length / Transfer-Encoding: chunked | Entrambi | Quanto è lungo il corpo, o "arriva a pezzi, ti dico io quando è finito" |
Location | Server | Dove andare dopo un 3xx o un 201 |
Cache-Control, ETag, Last-Modified | Server | Per quanto tenere la copia e come verificarla (sezione 12) |
X-Forwarded-For, X-Forwarded-Proto | Proxy | L'IP vero del client e se era in HTTPS, aggiunti dal reverse proxy (sezione 11) |
Strict-Transport-Security, Content-Security-Policy | Server | Sicurezza: solo HTTPS, cosa può caricare la pagina (sezione 13) |
Server | Server | Nome e versione del server. Meglio senza versione: server_tokens off; |
Content-Type e content-type sono la stessa cosa. In HTTP/2 e HTTP/3 viaggiano sempre in minuscolo, e infatti curl -v te le mostra così. Non è un errore. I valori invece spesso le distinguono, i cookie per primi.
HTTPS: lo stesso HTTP, dentro TLS
HTTPS non è un altro protocollo. È HTTP che viaggia in un tubo cifrato, e il tubo si apre prima che parta la prima richiesta.
🔒 Cosa protegge
- Riservatezza: chi sta in mezzo (Wi-Fi pubblico, provider) non legge percorso, intestazioni, cookie e contenuto
- Integrità: nessuno può modificare la pagina per strada (una volta i provider ci infilavano pubblicità)
- Identità: il certificato dimostra che stai parlando con quel nome (Certificati per Svogliati)
👀 Cosa resta visibile
- L'IP del server, e quindi spesso chi lo ospita
- Il nome del sito, perché il client lo manda in chiaro nell'handshake (SNI), salvo con ECH, ancora poco diffuso
- Le query DNS, se non usi DNS cifrato (DNS per Svogliati)
- Quanto scarichi e quando
| Pezzo | Cosa fa |
|---|---|
| SNI (Server Name Indication) | Il client dice il nome del sito all'inizio dell'handshake, così il server sceglie il certificato giusto tra tanti sullo stesso IP |
| ALPN | Client e server si accordano sul protocollo dentro TLS: h2 o http/1.1 |
| TLS 1.3 | Handshake in un solo giro invece di due, solo algoritmi moderni. Con TLS 1.2 è l'unico da tenere attivo |
| HSTS | Il server dice "da oggi solo HTTPS per un anno": il browser non prova più nemmeno http://, quindi nessuno può intercettare il primo redirect |
server {
listen 80;
listen [::]:80;
server_name example.com www.example.com;
# la sfida di Let's Encrypt deve restare raggiungibile in http
location /.well-known/acme-challenge/ { root /var/www/html; }
location / { return 301 https://$host$request_uri; }
}
# ALPN: se risponde "ALPN protocol: h2" il server parla HTTP/2
openssl s_client -connect example.com:443 -servername example.com -alpn h2,http/1.1 </dev/null 2>/dev/null | grep -i alpn
# versione HTTP usata e tempi di ogni fase, in secondi
curl -so /dev/null -w 'http/%{http_version} dns %{time_namelookup} tcp %{time_connect} tls %{time_appconnect} primo byte %{time_starttransfer}\n' https://example.com
HTTP/2, HTTP/3, QUIC e il push
Le pagine moderne sono fatte di cento file. Il problema non è la banda, sono le attese: ogni versione nuova ne toglie un po'.
📱 Cosa porta QUIC in più
- Cambio di rete senza interruzioni: la connessione ha un suo identificativo, non dipende dall'IP. Esci di casa, passi dal Wi-Fi al 4G e il download continua
- Tutto cifrato: anche i dati di controllo del trasporto, che con TCP viaggiano in chiaro
- Aggiornabile: sta nel programma, non nel kernel. I browser lo migliorano a ogni versione
⚠️ I suoi difetti
- Molte reti aziendali bloccano UDP 443: il browser torna a HTTP/2 e nessuno se ne accorge
- Usa più CPU di TCP, che il kernel e le schede di rete accelerano da decenni
- Il 0-RTT può essere ripetuto da chi intercetta: va accettato solo per richieste che non cambiano niente (GET)
- I firewall e gli strumenti di analisi vedono molto meno
| "Push" | Cos'è | Stato |
|---|---|---|
| Server Push di HTTP/2 | Il server manda il CSS insieme alla pagina, prima che il browser lo chieda | Morto. Mandava spesso file già in cache. Chrome l'ha tolto nel 2022, nginx ha rimosso http2_push. Al suo posto: 103 Early Hints e <link rel="preload"> |
| 103 Early Hints | Il server risponde subito "intanto inizia a scaricare questi file", mentre prepara la pagina | Supportato da Chrome, Firefox, Safari e da Cloudflare |
| Web Push | Le notifiche del browser e delle PWA, anche a sito chiuso, passando dal servizio del browser (Google, Mozilla, Apple) con chiavi VAPID | Vivo. Su iPhone solo per siti aggiunti alla schermata Home |
| Server-Sent Events | Il server tiene aperta una risposta e manda eventi di testo man mano | Vivo e semplice: chat, avanzamento, notifiche dentro la pagina |
| WebSocket | Parte come HTTP (101 Switching Protocols) e diventa un canale nei due sensi | Vivo. Dietro a nginx servono due intestazioni in più (sezione 11) |
Come funziona un web server
Ascolta su una porta, legge richieste, manda risposte. La differenza tra uno e l'altro è come aspetta.
Nel primo modello ogni tavolo ha il suo cameriere, che resta lì in piedi anche mentre i clienti leggono il menu: con cento tavoli servono cento camerieri. Nel secondo, un cameriere gira tra tutti i tavoli e si ferma solo da chi ha deciso. Il sistema operativo gli dice chi è pronto (epoll su Linux, kqueue su BSD e macOS). Funziona finché nessun tavolo lo tiene occupato a lungo: per questo il lavoro pesante (PHP, Python) si passa a un processo dietro.
| Server | Com'è fatto | Quando |
|---|---|---|
| nginx | A eventi, in C, dal 2004. Configurazione a blocchi, ricaricabile senza interruzioni | Il default per siti, reverse proxy e file statici |
| Apache httpd | Dal 1995. Moduli per tutto, file .htaccess nelle cartelle. Con l'MPM event è a eventi anche lui; prefork è il vecchio un processo per connessione | Hosting condiviso, applicazioni che contano su .htaccess, chi lo conosce già |
| Caddy | In Go. Certificati Let's Encrypt automatici, HTTP/3 attivo di default, configurazione cortissima | Il più svogliato: un sito con HTTPS in tre righe |
| LiteSpeed / OpenLiteSpeed | A eventi, legge le regole di Apache e i .htaccess | Hosting WordPress (molti provider lo usano) |
| HAProxy, Traefik | Non servono file: smistano il traffico | Bilanciamento tra più server; Traefik nei container, con configurazione presa dalle etichette Docker |
| Gunicorn, uvicorn, Node, PHP-FPM | Server dell'applicazione, non server web completi | Sempre dietro a un reverse proxy, in ascolto su 127.0.0.1 o su un socket |
Host; in HTTPS ancora prima, dallo SNI, perché deve presentare il certificato giusto. Se nessun blocco corrisponde, risponde il sito di default: è per questo che aprire il server per IP mostra un sito a caso. Conviene un blocco default_server che risponde 444 (nginx chiude e basta).
nginx e il reverse proxy
Il reverse proxy è l'unico che parla con Internet. Dietro, le applicazioni parlano HTTP semplice con lui e basta.
server {
listen 443 ssl;
listen [::]:443 ssl;
listen 443 quic reuseport; # HTTP/3 (reuseport una volta sola per porta)
listen [::]:443 quic reuseport;
http2 on;
http3 on;
server_name example.com;
ssl_certificate /etc/letsencrypt/live/example.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/example.com/privkey.pem;
ssl_protocols TLSv1.2 TLSv1.3;
add_header Alt-Svc 'h3=":443"; ma=86400' always; # dice al browser che c'è HTTP/3
client_max_body_size 20m; # default 1m: upload più grandi = 413
location / {
proxy_pass http://127.0.0.1:8000;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
}
location /ws/ { # WebSocket
proxy_pass http://127.0.0.1:8000;
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection "upgrade";
proxy_read_timeout 1h;
}
location /static/ { # i file li serve nginx, l'applicazione non li vede
alias /srv/app/static/;
expires 30d;
}
}
sudo nginx -t && sudo systemctl reload nginx # reload: nessuna connessione interrotta
nginx -V 2>&1 | grep -o http_v3_module # il tuo nginx sa fare HTTP/3? (serve la 1.25 o successiva)
sudo ufw allow 443/udp # HTTP/3 è UDP: senza, non arriva niente
curl -sI --http3 https://example.com # solo se il tuo curl è compilato con HTTP/3
127.0.0.1, o l'IP di Cloudflare. L'IP vero sta in X-Forwarded-For, ma l'applicazione deve fidarsi di quell'intestazione solo quando arriva dal proxy: altrimenti chiunque può scriverci un IP a caso. In nginx dietro Cloudflare si usa il modulo real_ip con l'elenco degli IP di Cloudflare; nelle applicazioni c'è un'impostazione "trusted proxies".
Cache e compressione
La richiesta più veloce è quella che non parte. La seconda più veloce è quella che risponde "non è cambiato niente".
| Cache-Control | Vuol dire | Per cosa |
|---|---|---|
max-age=31536000, immutable | Tienilo un anno e non chiedere mai | File con l'impronta nel nome: app.3f9a2c.js. Se cambia, cambia il nome |
no-cache | Puoi tenerlo, ma chiedi sempre se è cambiato prima di usarlo | Le pagine HTML: sempre aggiornate, e con il 304 costano poco |
no-store | Non salvarlo da nessuna parte | Dati personali, pagine dopo il login con dati sensibili |
private / public | Solo il browser / anche proxy e CDN | private per tutto ciò che cambia da utente a utente |
s-maxage=… | Durata solo per le cache condivise (CDN) | Il CDN tiene la pagina 5 minuti, il browser la ricontrolla sempre |
🗜️ Compressione
Il client dice cosa capisce (Accept-Encoding: gzip, br, zstd), il server sceglie e lo scrive in Content-Encoding. gzip va ovunque, brotli comprime meglio i testi, zstd è il più recente e veloce. HTML, CSS, JS, JSON e SVG si comprimono anche dell'80%; JPEG, PNG, video e zip sono già compressi: non toccarli.
🌍 CDN
Un CDN (Cloudflare, Bunny, Fastly) tiene copie dei tuoi file vicino agli utenti e assorbe il traffico. Rispetta il Cache-Control che mandi tu: se mandi intestazioni sbagliate, il CDN servirà in tutto il mondo la versione sbagliata, oppure la pagina di un utente a un altro. Per questo private su tutto ciò che dipende dal login.
# in http { } o nel server
gzip on;
gzip_types text/css application/javascript application/json image/svg+xml; # text/html è sempre incluso
location ~* \.(css|js|woff2|png|jpg|webp|svg)$ {
add_header Cache-Control "public, max-age=31536000, immutable";
}
location / {
add_header Cache-Control "no-cache";
}
Sicurezza: le intestazioni che difendono
Cinque righe nel server bloccano intere famiglie di attacchi. Il difficile è non rompere niente mentre le metti.
server_tokens off; # niente versione di nginx nelle risposte
add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;
add_header X-Content-Type-Options "nosniff" always;
add_header Referrer-Policy "strict-origin-when-cross-origin" always;
add_header Permissions-Policy "camera=(), microphone=(), geolocation=()" always;
add_header Content-Security-Policy "default-src 'self'; frame-ancestors 'none'" always;
| Intestazione | Contro cosa | Attenzione a |
|---|---|---|
Strict-Transport-Security | Il primo accesso in http intercettato e dirottato | Dopo averla mandata, tornare a http è impossibile per la durata indicata. includeSubDomains vale anche per sottodomini che magari non hanno HTTPS |
Content-Security-Policy | XSS: script iniettati che caricano o eseguono codice | La più potente e la più facile da rompere. Inizia con Content-Security-Policy-Report-Only e guarda la console del browser |
frame-ancestors (in CSP) | Clickjacking: il tuo sito dentro un iframe invisibile | Sostituisce il vecchio X-Frame-Options |
X-Content-Type-Options: nosniff | Il browser che "indovina" il tipo e tratta un file caricato come script | Richiede Content-Type giusti |
Referrer-Policy | Percorsi e parametri che finiscono ad altri siti | Quasi nessuna |
Per default una pagina di sito-a.com non può leggere con JavaScript le risposte di api.sito-b.com. CORS è il modo in cui il server B dice "va bene, a sito-a lo permetto" con Access-Control-Allow-Origin: https://sito-a.com. Lo controlla il browser, non il server: per questo con curl funziona tutto. E l'errore CORS si risolve sul server che risponde, mai sulla pagina che chiede.
✅ Fai
- HTTPS ovunque, redirect 301 da http, HSTS quando tutto funziona da un po'
- Cookie di sessione con
Secure; HttpOnly; SameSite=Lax alwayssugliadd_header, così valgono anche sulle pagine di errore- Limiti di dimensione e di frequenza (
limit_req) sui login e sulle API - Applicazioni in ascolto solo su
127.0.0.1 - Controllare le intestazioni dopo ogni modifica, con curl
❌ Non fare
Access-Control-Allow-Origin: *su API che usano cookie o token- Fidarsi di
X-Forwarded-Forche non arriva dal tuo proxy - Mettere un
add_headerin unalocatione aspettarsi che restino quelli delserver: in nginx non si sommano, quelli di sopra spariscono - Token o password nella query string: finiscono nei log e nella cronologia
- Pagine di errore con stack trace e versioni in produzione
curl -sI, con la scheda Rete degli strumenti per sviluppatori del browser, o con l'analisi HTTP e SSL/TLS di NetForge. Per la configurazione TLS di partenza c'è ssl-config.mozilla.org.
Errori tipici, tradotti
Il codice ti dice di chi è la colpa. Il log di nginx (/var/log/nginx/error.log) ti dice il resto.
| Cosa vedi | Cosa vuol dire | Cosa fare |
|---|---|---|
502 Bad Gateway | Il proxy non è riuscito a parlare con l'applicazione: è spenta, ascolta su un'altra porta, o il socket non ha i permessi giusti | systemctl status dell'applicazione, ss -tlnp, e l'error.log di nginx dice "connection refused" o "permission denied" |
504 Gateway Timeout | L'applicazione c'è ma ci mette troppo (in nginx 60 secondi di default) | Trova la query lenta. Alzare proxy_read_timeout solo per le operazioni che sono lente di natura |
500 Internal Server Error | L'applicazione è andata in errore | Il log dell'applicazione, non quello di nginx |
413 Request Entity Too Large | Upload più grande del limite | client_max_body_size in nginx, e il limite dell'applicazione (in PHP upload_max_filesize e post_max_size) |
400 Request Header Or Cookie Too Large | Troppi cookie o troppo grandi | Cancella i cookie del sito; lato server large_client_header_buffers, ma prima chiediti chi li ha gonfiati |
401 contro 403 | 401: non so chi sei. 403: so chi sei, ma non puoi; o, per i file statici, permessi Unix sbagliati | 401: credenziali. 403: permessi dell'utente, o ls -l sul file e sulle cartelle sopra |
ERR_TOO_MANY_REDIRECTS | Un redirect che rimanda a sé stesso. Classico: Cloudflare in modalità "Flexible" parla in http col server, il server rimanda a https, e così via | Cloudflare in "Full (strict)". Dietro a un proxy, l'applicazione deve leggere X-Forwarded-Proto |
CORS: No 'Access-Control-Allow-Origin' header | Il server dell'API non autorizza la pagina che chiama | Aggiungi l'intestazione sul server dell'API, anche sulla risposta a OPTIONS |
| Mixed content | Pagina in HTTPS che carica script o immagini in http | Percorsi in https o relativi; in WordPress l'URL del sito nelle impostazioni |
ERR_HTTP2_PROTOCOL_ERROR | La risposta si è interrotta a metà o ha intestazioni non valide | error.log: spesso il disco è pieno (nginx scrive lì le risposte grandi) o l'applicazione manda intestazioni malformate |
499 nei log di nginx | Il client ha chiuso prima della risposta | Se sono tanti, l'applicazione è lenta e gli utenti si stufano |
| Il WebSocket si chiude subito o dopo 60 secondi | Mancano Upgrade e Connection, o il timeout del proxy | La location /ws/ della sezione 11 |
| HTTP/3 configurato ma il browser usa HTTP/2 | UDP 443 chiuso, o manca Alt-Svc | ufw allow 443/udp, firewall del provider, e ricarica la pagina due volte: la prima visita è sempre HTTP/2 |
| "Ho cambiato il file ma vedo il vecchio" | Cache del browser, del CDN o dell'applicazione | curl -sI e guarda Age, Cache-Control, cf-cache-status. Poi svuota la cache giusta |
Da dove continuare
HTTP non si studia, si guarda. Apri curl -v e la scheda Rete del browser, e leggi.
🗺️ Un percorso in quattro tappe
- Oggi:
curl -sIsui tuoi siti. Codici, redirect,Server, cookie, cache: scoprirai almeno una cosa che non sapevi. - Questa settimana: redirect da http, HTTP/2, intestazioni di sicurezza con
always,server_tokens off. - Poi: cache giusta per file statici e HTML, compressione, applicazioni solo in locale dietro al reverse proxy.
- Dopo: HTTP/3 con UDP 443 aperto, una CSP prima in Report-Only e poi vera, limiti sui login.
| Risorsa | Cos'è |
|---|---|
| developer.mozilla.org/docs/Web/HTTP | La documentazione migliore su HTTP, intestazioni, cookie, CORS e cache, anche in italiano |
| RFC 9110, 9111, 9112, 9113, 9114 | Semantica, cache, HTTP/1.1, HTTP/2, HTTP/3: le specifiche, leggibili più di quanto sembri |
| everything.curl.dev | Il libro di curl, scritto da chi l'ha creato |
| nginx.org/en/docs | Tutte le direttive di nginx, con i valori di default |
| caddyserver.com/docs | Per chi vuole HTTPS e HTTP/3 senza scrivere configurazione |
| ssl-config.mozilla.org | Configurazioni TLS pronte per nginx, Apache, HAProxy, Caddy |
| Certificati · DNS · Networking · PHP per Svogliati | Le guide da leggere insieme a questa |
curl -v ti dice protocollo, certificato, codice, intestazioni e redirect in un colpo solo. Nove volte su dieci il problema è scritto lì.