Middleware in Node.js: cosa sono e come crearli con Express

Scopri cosa sono i middleware in Node.js e come crearli con Express per comprimere le risposte HTTP, forzare HTTPS e gestire i redirect www e non-www 
Che cos'è un middleware in Node.js
Un middleware è una funzione che viene eseguita durante il ciclo di elaborazione di una richiesta HTTP. In un'applicazione Express, ogni richiesta attraversa una sequenza di middleware che possono modificarne il contenuto, eseguire controlli, elaborare informazioni oppure interrompere il flusso restituendo direttamente una risposta.
Un middleware Express standard riceve tre parametri:
req: l'oggetto request, che contiene le informazioni relative alla richiesta HTTP, come URL, header, parametri e dati inviati dal client.res: l'oggetto response, utilizzato per costruire e inviare la risposta HTTP.next: una funzione che permette di passare il controllo al middleware successivo nella catena.
La struttura di base di un middleware è la seguente:
function myMiddleware(req, res, next) {
// Logica del middleware
next();
}
La chiamata a next() è fondamentale: permette a Express di continuare l'elaborazione della richiesta. Se un middleware non invia una risposta e non richiama next(), la richiesta rimane in attesa e il client potrebbe non ricevere mai una risposta.
Non tutti i middleware devono necessariamente chiamare next(). Se il loro compito consiste nel terminare il ciclo di richiesta e risposta, possono utilizzare direttamente metodi come res.send(), res.json() o res.redirect().
Come registrare un middleware in Express
Express mette a disposizione il metodo app.use() per registrare middleware a livello di applicazione. I middleware vengono eseguiti nell'ordine in cui sono stati dichiarati, caratteristica importante quando si devono gestire operazioni che riguardano tutte le richieste.
Un esempio minimale:
const express = require("express");
const app = express();
app.use((req, res, next) => {
console.log(`${req.method} ${req.originalUrl}`);
next();
});
app.get("/", (req, res) => {
res.send("Homepage");
});
app.listen(3000);
In questo esempio il middleware intercetta ogni richiesta, registra il metodo HTTP e l'URL richiesto, quindi passa il controllo alla route corrispondente.
È possibile registrare middleware anche su singole route oppure utilizzare router indipendenti attraverso express.Router(). La scelta dipende dall'ambito in cui deve essere applicata la logica.
Middleware per la compressione delle risposte HTTP
Una delle operazioni che possono migliorare le prestazioni di un'applicazione web consiste nella compressione delle risposte HTTP.
Quando il server restituisce contenuti come HTML, CSS, JavaScript o JSON, è possibile ridurne le dimensioni utilizzando algoritmi di compressione supportati dal client, diminuendo la quantità di dati trasferiti attraverso la rete.
In Express possiamo implementare questa funzionalità utilizzando il pacchetto compression, che si occupa di gestire automaticamente la negoziazione della compressione attraverso l'header HTTP Accept-Encoding.
Installazione del pacchetto compression
Per prima cosa installiamo la dipendenza:
npm install compression
Implementazione del middleware
Una volta installato il pacchetto, possiamo registrare il middleware all'interno dell'applicazione:
const express = require("express");
const compression = require("compression");
const app = express();
// Abilita la compressione delle risposte HTTP
app.use(compression());
app.get("/", (req, res) => {
res.send("Contenuto della pagina");
});
app.listen(3000);
Con una sola istruzione, Express applicherà la compressione alle risposte idonee generate dai middleware e dalle route successive.
Il pacchetto verifica le caratteristiche dichiarate dal client e utilizza un algoritmo compatibile, evitando di comprimere risposte per le quali non è opportuno farlo.
Personalizzare la compressione
Il middleware compression permette di specificare alcune opzioni per controllare il comportamento della compressione.
Ad esempio, possiamo utilizzare la proprietà threshold per stabilire una dimensione minima della risposta al di sotto della quale non applicare la compressione:
app.use(compression({
threshold: 1024,
level: 6
}));
In questo esempio vengono compresse, in condizioni normali, le risposte con una dimensione di almeno 1 KB. Il parametro level controlla il livello di compressione: valori più elevati possono ridurre maggiormente le dimensioni dei dati, a fronte di un maggiore utilizzo della CPU.
È importante considerare che la compressione non è sempre vantaggiosa. Per contenuti già compressi, come immagini JPEG, WebP o file ZIP, il risparmio può essere trascurabile o nullo.
Inoltre, in ambienti di produzione è opportuno valutare se la compressione debba essere gestita direttamente dall'applicazione Node.js oppure da un reverse proxy, un web server o un'infrastruttura CDN. Evitare di comprimere due volte la stessa risposta è una buona pratica.
Middleware per il redirect automatico da HTTP a HTTPS
Un'altra operazione comune nelle applicazioni web consiste nell'obbligare l'utilizzo del protocollo HTTPS.
HTTPS protegge la comunicazione tra client e server attraverso TLS, garantendo la cifratura del traffico e l'autenticazione del server. In un sito pubblico è quindi opportuno evitare che gli utenti possano continuare a navigare utilizzando la versione HTTP.
Possiamo ottenere questo comportamento attraverso un middleware che verifica il protocollo utilizzato e, quando necessario, restituisce un redirect verso la versione HTTPS della stessa risorsa.
Implementazione del middleware
In Express possiamo utilizzare la proprietà req.secure per verificare se la richiesta viene considerata sicura:
function forceHttps(req, res, next) {
if (!req.secure) {
return res.redirect(
308,
`https://${req.headers.host}${req.originalUrl}`
);
}
next();
}
Il middleware controlla il protocollo della richiesta. Se la connessione non è HTTPS, restituisce una risposta HTTP 308 che indirizza il client alla stessa risorsa attraverso HTTPS.
Il codice 308 indica un redirect permanente e, a differenza del comportamento storico associato al 301 per alcune richieste, mantiene il metodo HTTP e il corpo della richiesta.
Attenzione alle applicazioni dietro un reverse proxy
In produzione è molto frequente che un'applicazione Node.js non gestisca direttamente la connessione HTTPS. Il certificato TLS può essere installato su un reverse proxy, un load balancer o un servizio CDN, che successivamente inoltra la richiesta all'applicazione attraverso HTTP.
In questo scenario, Express potrebbe interpretare erroneamente la richiesta come non sicura, anche se il client si è collegato correttamente tramite HTTPS.
Per risolvere il problema è necessario configurare correttamente l'impostazione trust proxy, in modo che Express possa utilizzare le informazioni inoltrate dal proxy:
const express = require("express");
const app = express();
// Esempio: il proxy affidabile si trova su localhost
app.set("trust proxy", "loopback");
La configurazione deve corrispondere alla reale infrastruttura. Non è consigliabile impostare indiscriminatamente trust proxy a true: in questo modo l'applicazione potrebbe fidarsi di header inoltrati dal client o da proxy non attendibili.
Il reverse proxy deve essere configurato per sovrascrivere correttamente gli header X-Forwarded-Proto e gli altri header di inoltro. Solo così req.secure potrà riflettere correttamente il protocollo originale utilizzato dal client.
Una nota sull'ambiente di produzione
Se hai il controllo dell'infrastruttura, la soluzione preferibile è spesso configurare il redirect HTTP verso HTTPS direttamente sul reverse proxy o sul web server che gestisce il traffico in ingresso.
In questo modo le richieste HTTP vengono reindirizzate prima di raggiungere Node.js, evitando di impegnare l'applicazione in un'operazione che può essere gestita a un livello infrastrutturale.
Il middleware rimane comunque una soluzione valida quando il redirect deve essere gestito dall'applicazione stessa.
Middleware per il redirect da www a non-www
Un altro aspetto importante nella configurazione di un sito web riguarda la scelta del dominio canonico.
Ad esempio, un sito potrebbe essere raggiungibile attraverso entrambi questi indirizzi:
https://www.example.comhttps://example.com
Anche se il contenuto è identico, per i motori di ricerca si tratta di URL differenti. Per evitare di distribuire i segnali SEO tra più versioni dello stesso contenuto, è opportuno scegliere un dominio principale e reindirizzare tutte le altre varianti verso di esso.
In questo esempio utilizzeremo la versione senza www.
Implementazione del middleware
Possiamo realizzare il redirect controllando il nome host della richiesta e confrontandolo con il dominio che vogliamo utilizzare:
function removeWww(req, res, next) {
const hostname = req.hostname.toLowerCase();
if (hostname === "www.example.com") {
return res.redirect(
308,
`https://example.com${req.originalUrl}`
);
}
next();
}
Quando viene ricevuta una richiesta diretta a www.example.com, il middleware restituisce un redirect permanente verso example.com, mantenendo il percorso e gli eventuali parametri della query string.
Ad esempio:
https://www.example.com/blog/nodejs?page=2
Viene reindirizzato a:
https://example.com/blog/nodejs?page=2
Il confronto esplicito del dominio è importante: non bisogna eliminare semplicemente il prefisso www. da qualsiasi hostname ricevuto, perché l'applicazione potrebbe gestire più domini o sottodomini.
Inoltre, quando si utilizza req.hostname dietro un reverse proxy, bisogna considerare la configurazione di trust proxy e verificare che l'header X-Forwarded-Host venga gestito esclusivamente da proxy attendibili.
Come combinare i middleware HTTP e www in un'unica implementazione
Le due operazioni viste in precedenza possono essere gestite anche attraverso un unico middleware. Questa soluzione permette di controllare contemporaneamente protocollo e hostname, evitando redirect multipli.
Ad esempio, possiamo definire un middleware che utilizza direttamente un dominio canonico e verifica se la richiesta deve essere reindirizzata:
const CANONICAL_HOST = "example.com";
function canonicalRedirect(req, res, next) {
const isSecure = req.secure;
const hostname = req.hostname.toLowerCase();
const needsRedirect =
!isSecure ||
hostname !== CANONICAL_HOST;
if (needsRedirect) {
return res.redirect(
308,
`https://${CANONICAL_HOST}${req.originalUrl}`
);
}
next();
}
Con questa implementazione vengono gestiti entrambi i casi:
- Una richiesta HTTP viene reindirizzata alla versione HTTPS.
- Una richiesta diretta al dominio
www.example.comviene reindirizzata alla versione senzawww.
Il redirect avviene direttamente verso il dominio canonico HTTPS, evitando una prima risposta verso la versione HTTPS con www e una seconda verso quella senza www.
È importante notare che questo esempio presuppone che l'applicazione sia destinata esclusivamente a example.com. In un'applicazione multi-dominio, la logica deve prevedere una mappatura esplicita dei domini autorizzati e delle rispettive destinazioni canoniche.
Ordine di esecuzione dei middleware: un aspetto da non sottovalutare
In Express l'ordine con cui vengono registrati i middleware influenza direttamente il comportamento dell'applicazione.
Quando si implementano compressione, redirect e altri controlli trasversali, è importante stabilire una sequenza coerente.
Una possibile configurazione è la seguente:
const express = require("express");
const compression = require("compression");
const app = express();
// Configurazione del reverse proxy, se presente
app.set("trust proxy", "loopback");
// Redirect verso il dominio e il protocollo canonici
app.use(canonicalRedirect);
// Compressione delle risposte
app.use(compression());
// Altri middleware
app.use(express.json());
// Route applicative
app.get("/", (req, res) => {
res.send("Homepage");
});
app.listen(3000);
Il middleware di canonicalizzazione viene eseguito prima della compressione, così le richieste da reindirizzare vengono gestite immediatamente.
La compressione viene invece registrata prima delle route, in modo da poter intervenire sulle risposte prodotte successivamente.
Naturalmente, questa è una configurazione di esempio: l'ordine degli altri middleware deve essere definito in funzione delle esigenze applicative, soprattutto quando entrano in gioco autenticazione, sessioni, gestione degli errori e caricamento dei file.
Redirect HTTP e SEO: 301 o 308?
Quando si configura un redirect permanente, la scelta del codice HTTP è importante sia dal punto di vista tecnico sia da quello SEO.
I due codici più interessanti in questo contesto sono:
- 301 Moved Permanently: comunica che una risorsa è stata spostata definitivamente. Alcuni client possono trasformare una richiesta POST in GET durante il redirect.
- 308 Permanent Redirect: comunica anch'esso uno spostamento permanente, ma mantiene il metodo HTTP e il corpo della richiesta originale.
Per un sito web che gestisce prevalentemente richieste GET, entrambi possono essere appropriati. Se invece è necessario preservare il metodo e il corpo delle richieste, il 308 offre un comportamento più esplicito.
Dal punto di vista SEO, Google considera sia il 301 sia il 308 come segnali di redirect permanente e li utilizza per individuare l'URL canonico.
Oltre a implementare i redirect, è consigliabile:
- Utilizzare sempre la versione canonica degli URL nei link interni.
- Aggiornare la sitemap XML utilizzando esclusivamente gli URL definitivi.
- Impostare correttamente il tag
rel="canonical"sulle pagine HTML. - Evitare catene di redirect e redirect circolari.
- Verificare che tutte le varianti del dominio convergano verso un unico indirizzo definitivo.
Come verificare il funzionamento dei middleware
Dopo aver implementato i middleware, è importante verificarne il comportamento attraverso richieste HTTP reali.
Possiamo utilizzare curl per controllare gli header delle risposte senza dover necessariamente aprire un browser.
Per verificare il redirect da HTTP a HTTPS:
curl -I http://example.com
Per verificare il redirect dal dominio con www a quello senza:
curl -I https://www.example.com
In entrambi i casi dovremmo ottenere un codice di redirect permanente e un header Location contenente l'indirizzo di destinazione corretto.
Per verificare la compressione possiamo invece inviare una richiesta che dichiara il supporto a gzip:
curl -I -H "Accept-Encoding: gzip" https://example.com
Quando la risposta è effettivamente compressa, dovrebbe essere presente l'header:
Content-Encoding: gzip
La presenza dell'header dipende comunque dal tipo e dalle dimensioni della risposta, dalla configurazione del middleware e dalle eventuali impostazioni del server o del reverse proxy.
Link utili per approfondire
Per approfondire il funzionamento dei middleware e le funzionalità utilizzate negli esempi, puoi consultare la documentazione ufficiale:
- Express.js - Using Middleware: panoramica sul funzionamento dei middleware.
- Express.js - Writing Middleware: guida alla creazione di middleware personalizzati.
- Express.js - Compression Middleware: documentazione del pacchetto compression.
- Express.js - Behind Proxies: configurazione delle applicazioni dietro reverse proxy.
- Node.js - HTTP: documentazione del modulo HTTP di Node.js.
- Google Search Central - Redirects: indicazioni sui redirect e sulla gestione degli URL nei motori di ricerca.
- Google Search Central - Canonical URLs: approfondimento sulla canonicalizzazione degli URL.
Conclusioni
I middleware rappresentano uno strumento fondamentale per organizzare e centralizzare la logica trasversale di un'applicazione Node.js basata su Express. Grazie alla loro struttura modulare, è possibile intervenire sulle richieste e sulle risposte HTTP senza dover replicare la stessa logica all'interno di ogni singola route.
La compressione delle risposte permette di ridurre la quantità di dati trasferiti, mentre i redirect da HTTP a HTTPS e dal dominio con www a quello senza www consentono di gestire correttamente la sicurezza e la canonicalizzazione degli URL.
Quando si sviluppano questi middleware è importante prestare attenzione all'ordine di esecuzione, alla configurazione dei reverse proxy e alla scelta dei codici HTTP. Una corretta implementazione permette di ottenere un'applicazione più ordinata, efficiente e coerente anche dal punto di vista SEO.
Conoscere e utilizzare correttamente i middleware significa quindi avere maggiore controllo sul ciclo di vita delle richieste HTTP e costruire applicazioni web Node.js più solide e manutenibili.
