Hastighetsbegrensning er en strategi du kan bruke for å kontrollere trafikk på et nettverk. Det begrenser antallet forespørsler som en bruker kan gjøre innenfor en bestemt tidsramme.

Ulike hastighetsbegrensende algoritmer finnes, hver med sine egne avveininger. En enkel og populær metode er å spore forespørslers IP-adresser og sjekke hvor mye tid som går mellom forespørsler. Systemet kan da avslå en forespørsel hvis IP-adressen overskrider antallet forespørsler grensen tillater.

Denne tilnærmingen til hastighetsbegrensning er enkel å bygge i en NodeJS-Express-app, med bare noen få trinn.

Trinn 1: Sette opp et utviklingsmiljø

Først må du opprette og initialisere en Express-applikasjon.

Start med å lage en prosjektkatalog ved å kjøre:

mkdir express-app

Gå deretter inn i den katalogen ved å kjøre:

cd ekspress-app

Deretter initialiser npm, nodepakkebehandleren, og lage en package.json fil i applikasjonen din ved å kjøre:

npm init -y

De -y flagget vil lage din package.json fil med alle standardinnstillingene.

instagram viewer

Deretter må du installere noen avhengigheter. Avhengighetene som kreves for denne opplæringen er:

  • ExpressJS: ExpressJS er et NodeJS-rammeverk som gir et robust sett med funksjoner for nett- og mobilapplikasjoner. Det forenkler prosessen med å bygge backend-applikasjoner med NodeJS.
  • Express Rate Limit: Express rate limit er en hastighetsbegrensende mellomvare for ExpressJS. Den begrenser gjentatte forespørsler til offentlige APIer og/eller endepunkter, for eksempel tilbakestilling av passord, brukerpålogging osv.

Installer de nødvendige avhengighetene ved å kjøre:

npm installere ekspresshastighet-grense

Trinn 2: Opprette en ekspressapplikasjon

Du må opprette en grunnleggende Express-server som lytter til forespørsler som sendes til applikasjonen din.

Først oppretter du en index.js filen i prosjektets rotkatalog. Dette vil være oppføringsfilen for søknaden din.

Deretter legger du til følgende kode til din index.js fil:

// index.js
konst uttrykke = krever("uttrykke");
konst app = express();
konst port = prosess.env. PORT || 3000
app.listen (port, () => {
konsoll.Logg(`App kjører på port ${port}`);
});

Denne koden importerer uttrykke og oppretter en Express-applikasjon ved å kalle express() og lagre returverdien i app variabel. Den lytter deretter etter trafikk på havn 3000 ved å ringe til lytte metode på app gjenstand.

Trinn 3: Opprette rutebehandlere

Deretter oppretter du noen rutebehandlere du kan implementere den hastighetsbegrensende løsningen på.

Først oppretter du en mappe, ruter, i prosjektets rotkatalog ved å kjøre:

mkdir ruter

Lag en fil, routes.js, inne i rutemappen din og legg til følgende kode:

konst uttrykke = krever("uttrykke");
konst ruter = ekspress. Ruter();
router.get("/", (req, res) => {
 res.send({ melding: "Hei, dette er en GET-forespørsel" });
});


router.post("/add-demo", (req, res) => {
 res.status (201).send({ melding: "Ressursen ble opprettet" });
});


router.put("/update-demo", (req, res) => {
 res.status (201).send({ melding: "Ressursen er oppdatert" });
});
modul.eksport = ruter;

Denne koden importerer uttrykke, kaller Ruter metode på uttrykke, og lagrer verdien i en variabel, ruter. De Ruter metoden lar deg lage modulære, monterbare rutebehandlere. Du kan opprette rutebehandlere for en FÅ be om å "/", a POST be om å "/add-demo", og en SETTE be om å "/update-demo”. Til slutt eksporterer du ruter variabel.

Deretter importerer du ruter variabel i din index.js fil:

// index.js
konst ruter = krever("./ruter/ruter");

Deretter bruker du den som mellomvare i index.js-filen din:

// index.js
app.bruk(ruter);

Pass på å plassere kodeblokken ovenfor før app.lytt anrop.

Trinn 4: Implementering av satsbegrensning

Først lager du en "mellomvare"-mappen i prosjektets rotkatalog ved å kjøre:

mkdir mellomvare

Lag deretter en fil som heter "rate-limiter.js” inne i mellomvarekatalogen. Legg til følgende kode i denne filen:

// rate-limiter.js
konst rateLimiter = krever("express-rate-limit");
konst limiter = rateLimiter({
 maks: 5,
 windowMS: 10000, // 10 sekunder
 beskjed: "Du kan'kommer ikke med flere forespørsler for øyeblikket. Prøv igjen senere",
});
modul.eksport = begrenser

De rateLimiter funksjonen tar et konfigurasjonsobjekt med betingelsene for å begrense antall forespørsler.

Egenskapene i konfigurasjonsobjektet ovenfor er:

  • maks: Denne egenskapen må alltid være en Antall eller en funksjon som returnerer et tall. Den representerer det maksimale antallet forespørsler en bruker kan gjøre innenfor en spesifisert tidsramme. Hvis denne egenskapen ikke er angitt i konfigurasjonsobjektet, er den standard til 5.
  • windowsMS: Denne egenskapen skal alltid være et tall. Det representerer tidsrammen der flere forespørsler er tillatt millisekunder. Hvis denne egenskapen ikke er angitt i konfigurasjonsobjektet, er den standard til 60 000 millisekunder (ett minutt).
  • beskjed: Denne egenskapen kan være en streng, et JSON-objekt eller en annen verdi som støttes av Express sitt svar.send metode. Hvis denne egenskapen ikke er angitt i konfigurasjonsobjektet, er den standard til "For mange forespørsler. Prøv igjen senere."

Funksjonen vil da se etter gjentatte forespørsler til applikasjonen din. Hvis en bruker overskrider grensen (maks, 5) innenfor tidsrammen (windowMS, 10s), vil den blokkere forespørselen. Det vil også gi en "Too Many Requests"-feil med en statuskode på 429.

Til slutt importerer du begrenserfunksjonen i din index.js fil og bruk den som en global mellomvare i applikasjonen din. Gjør dette ved å plassere app.use (begrenser) over rutene mellomvare. Dette gjelder den satsbegrensende løsningen på alle applikasjonens ruter.

app.bruk(begrenser);

Prisbegrensende spesifikke ruter

Du kan også bruke takstbegrensning på bestemte ruter. Du kan konfigurere dem separat for å avvise forespørsler gjort i en annen tidsramme, vise en annen melding osv.

Anta for eksempel at du implementerer en brukerpåloggingsrute i applikasjonen din. Det kan hende du må legge til en hastighetsbegrensende konfigurasjon for påloggingsruten som er forskjellig fra konfigurasjonen som brukes av de andre rutene.

Først må du fjerne begrenser som en mellomvare på applikasjonsnivå og bruk den fordi det ikke er noe innebygd mellomvarefiltersystem i ExpressJS. Så selv om du legger til en spesifikk hastighetsbegrensende løsning til en rute, vil den globale mellomvaren fortsatt kjøre på den ruten.

Deretter oppretter du en ny hastighetsbegrensende konfigurasjon i din rate-limiter.js fil og eksporter den.

konst signInLimiter = rateLimiter({
 maks: 3,
 windowMS: 10000, //10 sekunder
 beskjed: "For mange påloggingsforsøk. Prøv igjen senere."
})
modul.eksport = {
 begrenser,
 signInLimiter
}

De signInLimiter konfigurasjonsobjektet har et annet antall maks forespørsler og en annen feilmelding fra den generelle hastighetsbegrenseren.

Til slutt, oppdater din router.js fil med kodeblokken nedenfor:

// router.js
konst uttrykke = krever("uttrykke");
konst ruter = ekspress. Ruter();
konst {limiter, signInLimiter} = krever("../middleware/rate-limiter")
router.get("/sign-in", signInLimiter, (req, res, neste) => {
 res.send({ melding: "Hei, dette er en GET-forespørsel" });
});


ruter.bruk(begrenser)


router.post("/post", (req, res) => {
 res.status (201).send({ melding: "Ressursen ble opprettet" });
});


router.put("/put", (req, res) => {
 res.status (201).send({ melding: "Ressursen er oppdatert" });
});
modul.eksport = ruter;

I kodeblokken ovenfor importerte du begrenser og signInLimiter. Så søkte du signInLimiter som en spesifikk hastighetsbegrenser for "/sign-in" rute.

Til slutt, ved å plassere router.use (begrenser) over resten av rutene brukte du limiter som rate-limiter for resten av rutene.

Viktigheten av satsbegrensning

Ratebegrensning reduserer belastningen på webserveren din ved å unngå å måtte behandle for mange forespørsler på en gang. Det senker botaktivitet, beskytter deg mot Denial of Service (DoS)-angrep og forhindrer brute-force-angrep.