Takstbegrænsning er en strategi, du kan bruge til at kontrollere trafikken på et netværk. Det begrænser antallet af anmodninger, som en bruger kan foretage inden for en bestemt tidsramme.

Der findes forskellige hastighedsbegrænsende algoritmer, hver med sine egne afvejninger. En enkel og populær metode er at spore anmodningers IP-adresser og kontrollere, hvor lang tid der går mellem anmodninger. Systemet kan derefter afvise en anmodning, hvis dets IP-adresse overstiger antallet af anmodninger, som grænsen tillader.

Denne tilgang til hastighedsbegrænsning er nem at bygge i en NodeJS-Express-app med blot et par trin.

Trin 1: Opsætning af et udviklingsmiljø

Først skal du oprette og initialisere en Express-applikation.

Start med at oprette en projektmappe ved at køre:

mkdir express-app

Indtast derefter den mappe ved at køre:

cd ekspres-app

Dernæst initialiser npm, node pakke manager, og skabe en package.json fil i din ansøgning ved at køre:

npm init -y

Det -y flag vil skabe din package.json fil med alle standardindstillingerne.

Dernæst skal du installere nogle afhængigheder. De afhængigheder, der kræves til denne øvelse er:

  • ExpressJS: ExpressJS er en NodeJS-ramme der giver et robust sæt funktioner til web- og mobilapplikationer. Det forenkler processen med at bygge backend-applikationer med NodeJS.
  • Express Rate Limit: Express rate limit er en hastighedsbegrænsende middleware til ExpressJS. Det begrænser gentagne anmodninger til offentlige API'er og/eller endepunkter, såsom nulstilling af adgangskode, brugerlogin osv.

Installer de nødvendige afhængigheder ved at køre:

npm installere ekspres-begrænse

Trin 2: Oprettelse af en Express-applikation

Du skal oprette en grundlæggende Express-server, der lytter til anmodninger, der sendes til din applikation.

Først skal du oprette en index.js fil i dit projekts rodmappe. Dette vil være indtastningsfilen for din ansøgning.

Tilføj derefter følgende kode til din index.js fil:

// index.js
konst udtrykke = kræve("udtryk");
konst app = express();
konst port = proces.env. PORT || 3000
app.listen (port, () => {
konsol.log(`App kører på port ${port}`);
});

Denne kode importerer udtrykke og opretter en Express-applikation ved at kalde express() og gemmer dens returværdi i app variabel. Derefter lytter den efter trafik på havnen 3000 ved at ringe til Lyt metode på app objekt.

Trin 3: Oprettelse af rutebehandlere

Dernæst skal du oprette nogle rutehandlere, som du kan implementere den hastighedsbegrænsende løsning på.

Først skal du oprette en mappe, ruter, i dit projekts rodmappe ved at køre:

mkdir ruter

Opret en fil, routes.js, inde i din rutemappe, og tilføj følgende kode:

konst udtrykke = kræve("udtryk");
konst router = ekspres. Router();
router.get("/", (req, res) => {
 res.send({ besked: "Hej, dette er en GET-anmodning" });
});


router.post("/add-demo", (req, res) => {
 res.status (201).send({ besked: "Ressource oprettet" });
});


router.put("/update-demo", (req, res) => {
 res.status (201).send({ besked: "Ressourcen blev opdateret" });
});
modul.eksport = router;

Denne kode importerer udtrykke, kalder Router metode på udtrykke, og gemmer værdien i en variabel, router. Det Router metode giver dig mulighed for at oprette modulære, monterbare rutehandlere. Du kan oprette rutebehandlere for en FÅ anmode om at "/", en STOLPE anmode om at "/add-demo", og en SÆTTE anmode om at "/update-demo”. Til sidst eksporterer du router variabel.

Dernæst importerer du router variabel i din index.js fil:

// index.js
konst ruter = kræve("./ruter/ruter");

Brug den derefter som en middleware i din index.js-fil:

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

Sørg for at placere kodeblokken ovenfor før app.lyt opkald.

Trin 4: Implementering af satsbegrænsning

Først skal du oprette en "mellemvaremappen i dit projekts rodmappe ved at køre:

mkdir middleware

Opret derefter en fil kaldet "rate-limiter.js” inde i middleware-biblioteket. Tilføj følgende kode til denne fil:

// rate-limiter.js
konst rateLimiter = kræve("express-rate-limit");
konst limiter = rateLimiter({
 max: 5,
 windowMS: 10000, // 10 sekunder
 besked: "Du kan'ikke fremsætte flere anmodninger i øjeblikket. Prøv igen senere",
});
modul.eksport = begrænser

Det rateLimiter funktion tager et konfigurationsobjekt med betingelserne for at begrænse antallet af anmodninger.

Egenskaberne i konfigurationsobjektet ovenfor er:

  • max: Denne ejendom skal altid være en nummer eller en funktion, der returnerer et tal. Det repræsenterer det maksimale antal anmodninger, en bruger kan foretage inden for en specificeret tidsramme. Hvis denne egenskab ikke er indstillet i konfigurationsobjektet, er den som standard 5.
  • windowsMS: Denne egenskab skal altid være et tal. Det repræsenterer den tidsramme, hvor flere anmodninger er tilladt millisekunder. Hvis denne egenskab ikke er indstillet i konfigurationsobjektet, er den standard til 60000 millisekunder (et minut).
  • besked: Denne ejendom kan være en snor, et JSON-objekt eller enhver anden værdi, der understøttes af Express's svar.send metode. Hvis denne egenskab ikke er angivet i konfigurationsobjektet, er den som standard "For mange anmodninger. Prøv igen senere."

Funktionen vil derefter kontrollere for gentagne anmodninger til din ansøgning. Hvis en bruger overskrider grænsen (max, 5) inden for tidsrammen (vindueMS, 10s), vil det blokere anmodningen. Det vil også kaste en "Too Many Requests" fejl med en statuskode på 429.

Til sidst importerer du begrænserfunktionen i din index.js fil og anvende den som en global middleware i din applikation. Gør dette ved at placere app.use (begrænser) over ruternes middleware. Dette anvender den hastighedsbegrænsende løsning på alle din applikations ruter.

app.brug(begrænser);

Satsbegrænsende specifikke ruter

Du kan også anvende takstbegrænsning på bestemte ruter. Du kan konfigurere dem separat til at afvise anmodninger fremsat inden for en anden tidsramme, vise en anden besked osv.

Antag for eksempel, at du implementerer en brugerlogonrute i din applikation. Du skal muligvis tilføje en hastighedsbegrænsende konfiguration for login-ruten, der adskiller sig fra den konfiguration, der bruges af de andre ruter.

Først skal du fjerne begrænser som middleware på applikationsniveau og anvende det, fordi der ikke er noget indbygget middleware-filtersystem i ExpressJS. Så selvom du tilføjer en specifik hastighedsbegrænsende løsning til en rute, vil den globale middleware stadig køre på den rute.

Derefter skal du oprette en ny hastighedsbegrænsende konfiguration i din rate-limiter.js fil og eksporter den.

konst signInLimiter = rateLimiter({
 max: 3,
 windowMS: 10000, //10 sekunder
 besked: "For mange loginforsøg. Prøv igen senere."
})
modul.eksport = {
 begrænser,
 signInLimiter
}

Det signInLimiter konfigurationsobjektet har et andet antal max anmodninger og en anden fejlmeddelelse fra den generelle hastighedsbegrænser.

Opdater endelig din router.js fil med kodeblokken nedenfor:

// router.js
konst udtrykke = kræve("udtryk");
konst router = ekspres. Router();
konst {limiter, signInLimiter} = kræve("../middleware/rate-limiter")
router.get("/sign-in", signInLimiter, (req, res, næste) => {
 res.send({ besked: "Hej, dette er en GET-anmodning" });
});


router.brug(begrænser)


router.post("/post", (req, res) => {
 res.status (201).send({ besked: "Ressource oprettet" });
});


router.put("/put", (req, res) => {
 res.status (201).send({ besked: "Ressourcen blev opdateret" });
});
modul.eksport = router;

I kodeblokken ovenfor importerede du begrænser og signInLimiter. Så søgte du signInLimiter som en specifik hastighedsbegrænser til "/sign-in" rute.

Til sidst ved at placere router.use (begrænser) over resten af ​​ruterne anvendte du limiter som hastighedsbegrænser for resten af ​​ruterne.

Vigtigheden af ​​satsbegrænsning

Takstbegrænsning reducerer belastningen på din webserver ved at undgå at skulle behandle for mange anmodninger på én gang. Det sænker botaktivitet, beskytter dig mod Denial of Service (DoS)-angreb og forhindrer brute-force-angreb.