La limitazione della velocità è una strategia che puoi utilizzare per controllare il traffico su una rete. Limita il numero di richieste che un utente può effettuare entro un intervallo di tempo specifico.

Esistono vari algoritmi di limitazione della velocità, ciascuno con i propri compromessi. Un metodo semplice e popolare consiste nel tenere traccia degli indirizzi IP delle richieste e controllare quanto tempo trascorre tra le richieste. Il sistema può quindi negare una richiesta se il suo indirizzo IP supera il numero di richieste consentito dal limite.

Questo approccio alla limitazione della velocità è facile da costruire in un'app NodeJS-Express, con pochi passaggi.

Passaggio 1: creazione di un ambiente di sviluppo

Innanzitutto, dovrai creare e inizializzare un'applicazione Express.

Inizia creando una directory di progetto eseguendo:

mkdir express-app

Quindi inserisci quella directory eseguendo:

CD app express

Quindi, inizializza npm, il gestore di pacchetti del nodo, e creare un pacchetto.json file nella tua applicazione eseguendo:

instagram viewer 
npm init -y

Il -y flag creerà il tuo pacchetto.json file con tutte le impostazioni predefinite.

Successivamente, dovrai installare alcune dipendenze. Le dipendenze richieste per questo tutorial sono:

  • ExpressJS: ExpressJS è un framework NodeJS che fornisce un solido set di funzionalità per applicazioni Web e mobili. Semplifica il processo di creazione di applicazioni back-end con NodeJS.
  • Limite di tariffa espresso: Express rate limit è un middleware di limitazione della velocità per ExpressJS. Limita le richieste ripetute alle API pubbliche e/o agli endpoint, come reimpostazioni di password, accessi utente, ecc.

Installa le dipendenze richieste eseguendo:

npm installare espresso-tasso espresso-limite

Passaggio 2: creazione di un'applicazione rapida

Dovrai creare un server Express di base che ascolti le richieste inviate alla tua applicazione.

Innanzitutto, crea un index.js file nella directory principale del tuo progetto. Questo sarà il file di ingresso per la tua domanda.

Quindi, aggiungi il seguente codice al tuo index.js file:

// index.js
cost espresso = richiedere("esprimere");
cost app = espresso();
cost porta = processo.env. PORTO || 3000
app.ascolta (porta, () => {
consolle.tronco d'albero(`App in esecuzione sulla porta ${porta}`);
});

Questo codice importa esprimere e crea un'applicazione Express chiamando express() e memorizzando il suo valore di ritorno in app variabile. Quindi ascolta il traffico sulla porta 3000 chiamando il ascoltare metodo sul app oggetto.

Passaggio 3: creazione di gestori di percorso

Quindi, crea alcuni gestori di percorso su cui puoi implementare la soluzione di limitazione della velocità.

Innanzitutto, crea una cartella, percorsi, nella directory principale del tuo progetto eseguendo:

percorsi mkdir

Crea un file, rotte.js, all'interno della cartella dei percorsi e aggiungi il seguente codice:

cost espresso = richiedere("esprimere");
cost router = espresso. Router();
router.get("/", (richiesto, ris) => {
 res.send({ messaggio: "Ciao, questa è una richiesta GET" });
});


router.post("/add-demo", (richiesto, ris) => {
 res.status (201).send({ messaggio: "Risorsa creata con successo" });
});


router.put("/update-demo", (richiesto, ris) => {
 res.status (201).send({ messaggio: "Risorsa aggiornata con successo" });
});
modulo.esportazioni = router;

Questo codice importa esprimere, chiama il Router metodo attivo esprimeree memorizza il valore in una variabile, router. Il Router Il metodo consente di creare gestori di percorsi modulari e montabili. È possibile creare gestori di route per a OTTENERE richiesta a “/", un INVIARE richiesta a “/add-demo”, e a METTERE richiesta a “/update-demo”. Infine, esporta il router variabile.

Quindi, importa il router variabile nel tuo index.js file:

// index.js
cost percorsi = richiedere("./percorsi/percorsi");

Quindi, usalo come middleware nel tuo file index.js:

// index.js
app.uso(itinerari);

Assicurati di posizionare il blocco di codice sopra prima di app.ascolta chiamata.

Passaggio 4: implementazione della limitazione della velocità

Innanzitutto, crea un "middleware” nella directory principale del tuo progetto eseguendo:

middleware mkdir

Quindi crea un file chiamato "rate-limiter.js” all'interno della directory del middleware. Aggiungi il seguente codice a questo file:

// rate-limiter.js
cost rateLimiter = richiedere("express rate limit");
cost limiter = rateLimiter({
 massimo: 5,
 finestraMS: 10000, // 10 secondi
 Messaggio: "Puoi't fare altre richieste al momento. Riprovare più tardi",
});
modulo.esportazioni = limitatore

Il rateLimiter La funzione accetta un oggetto di configurazione con le condizioni per limitare il numero di richieste.

Le proprietà nell'oggetto di configurazione sopra sono:

  • max: Questa proprietà deve essere sempre a numero o una funzione che restituisce un numero. Rappresenta il numero massimo di richieste che un utente può effettuare entro un periodo di tempo specificato. Se questa proprietà non è impostata nell'oggetto di configurazione, per impostazione predefinita è 5.
  • windowsMS: Questa proprietà dovrebbe essere sempre un numero. Rappresenta il lasso di tempo in cui sono ammesse più richieste millisecondi. Se questa proprietà non è impostata nell'oggetto di configurazione, il valore predefinito è 60000 millisecondi (un minuto).
  • Messaggio: Questa proprietà può essere a corda, un oggetto JSON o qualsiasi altro valore supportato da Risposta di Express.invia metodo. Se questa proprietà non è impostata nell'oggetto di configurazione, il valore predefinito è "Troppe richieste. Per favore riprova più tardi."

La funzione verificherà quindi la presenza di richieste ripetute alla tua applicazione. Se un utente supera il limite (max, 5) entro l'intervallo di tempo (finestraMS, 10s), bloccherà la richiesta. Verrà inoltre generato un errore "Troppe richieste" con un codice di stato di 429.

Infine, importa la funzione limiter nel tuo index.js file e applicalo come middleware globale nella tua applicazione. Fallo posizionando app.use (limitatore) sopra il middleware dei percorsi. Questo applica la soluzione di limitazione della tariffa a tutti i percorsi della tua applicazione.

app.uso(limitatore);

Percorsi specifici con limitazione della tariffa

Puoi anche applicare la limitazione della tariffa a percorsi specifici. Puoi configurarli separatamente per rifiutare le richieste effettuate in un intervallo di tempo diverso, visualizzare un messaggio diverso, ecc.

Ad esempio, supponi di implementare un percorso di accesso utente nella tua applicazione. Potrebbe essere necessario aggiungere una configurazione di limitazione della velocità per la route di accesso diversa dalla configurazione utilizzata dalle altre route.

Per prima cosa, dovrai rimuovere limitatore come middleware a livello di applicazione e applicarlo perché non esiste un sistema di filtri middleware integrato in ExpressJS. Quindi, anche se aggiungi una specifica soluzione di limitazione della velocità a un percorso, il middleware globale funzionerebbe comunque su quel percorso.

Quindi, crea una nuova configurazione di limitazione della velocità nel tuo rate-limiter.js file ed esportalo.

cost signInLimiter = rateLimiter({
 massimo: 3,
 finestraMS: 10000, //10 secondi
 Messaggio: "Troppi tentativi di accesso. Riprovare più tardi."
})
modulo.esportazioni = {
 limitatore,
 signInLimiter
}

Il signInLimiter l'oggetto di configurazione ha un numero diverso di max richieste e un messaggio di errore diverso dal limitatore di velocità generale.

Infine, aggiorna il tuo router.js file con il blocco di codice qui sotto:

// router.js
cost espresso = richiedere("esprimere");
cost router = espresso. Router();
cost {limitatore, signInLimiter} = richiedere("../middleware/limitatore di velocità")
router.get("/sign-in", signInLimiter, (req, res, next) => {
 res.send({ messaggio: "Ciao, questa è una richiesta GET" });
});


router.uso(limitatore)


router.post("/post", (richiesto, ris) => {
 res.status (201).send({ messaggio: "Risorsa creata con successo" });
});


router.put("/put", (richiesto, ris) => {
 res.status (201).send({ messaggio: "Risorsa aggiornata con successo" });
});
modulo.esportazioni = router;

Nel blocco di codice sopra, hai importato limitatore e signInLimiter. Poi hai fatto domanda signInLimiter come limitatore di velocità specifico al “/sign-in" percorso.

Infine, posizionando router.use (limitatore) sopra il resto dei percorsi, hai applicato limiter come limitatore di velocità per il resto dei percorsi.

L'importanza della limitazione delle tariffe

La limitazione della velocità riduce il carico sul tuo server web evitando di dover elaborare troppe richieste contemporaneamente. Riduce l'attività dei bot, ti protegge dagli attacchi Denial of Service (DoS) e previene gli attacchi di forza bruta.