A sebességkorlátozás egy olyan stratégia, amelyet a hálózat forgalmának szabályozására használhat. Korlátozza a felhasználó által adott időkereten belül benyújtható kérések számát.

Különféle sebességkorlátozó algoritmusok léteznek, mindegyiknek megvan a maga kompromisszuma. Az egyik egyszerű és népszerű módszer a kérések IP-címének nyomon követése és annak ellenőrzése, hogy mennyi idő telik el a kérések között. A rendszer ezután visszautasíthat egy kérést, ha annak IP-címe meghaladja a korlát által megengedett kérések számát.

Ez a sebességkorlátozási megközelítés néhány lépéssel egyszerűen beépíthető egy NodeJS-Express alkalmazásba.

1. lépés: Fejlesztési környezet beállítása

Először létre kell hoznia és inicializálnia kell egy Express alkalmazást.

Kezdje a projektkönyvtár létrehozásával a következő futtatással:

mkdir express-app

Ezután lépjen be a könyvtárba a következő futtatással:

CD express-app

Ezután inicializálja npm, a csomóponti csomagkezelő, és hozzon létre a package.json fájlt az alkalmazásban a következő futtatással:

instagram viewer 
npm init -y

Az -y zászló létrehozza az Ön package.json fájlt az összes alapértelmezett beállítással.

Ezután telepítenie kell néhány függőséget. Az oktatóanyaghoz szükséges függőségek a következők:

  • ExpressJS: Az ExpressJS egy NodeJS keretrendszer amely robusztus funkciókészletet biztosít webes és mobilalkalmazásokhoz. Leegyszerűsíti a háttéralkalmazások NodeJS segítségével történő felépítésének folyamatát.
  • Expressz Rate Limit: Az Express rate limit egy sebességkorlátozó köztes szoftver az ExpressJS számára. A nyilvános API-kra és/vagy végpontokra korlátozza az ismételt kéréseket, például a jelszó-visszaállítást, a felhasználói bejelentkezéseket stb.

Telepítse a szükséges függőségeket a következő futtatásával:

npm telepítés expressz gyorsdíjhatár

2. lépés: Expressz alkalmazás létrehozása

Létre kell hoznia egy alapszintű Expressz-kiszolgálót, amely figyeli az alkalmazására érkező kéréseket.

Először hozzon létre egy index.js fájlt a projekt gyökérkönyvtárában. Ez lesz a jelentkezésed beviteli fájlja.

Ezután adja hozzá a következő kódot a sajátjához index.js fájl:

// index.js
const expressz = igényelnek("Expressz");
const app = express();
const port = process.env. PORT || 3000
app.listen (port, () => {
konzol.log(`Porton futó alkalmazás ${port}`);
});

Ez a kód importál Expressz és létrehoz egy Express alkalmazást az express() meghívásával és a visszatérési értékének tárolásával a kb változó. Ezután figyeli a porton lévő forgalmat 3000 hívásával a hallgat módszer a kb tárgy.

3. lépés: Útvonalkezelők létrehozása

Ezután hozzon létre néhány útvonalkezelőt, amelyeken megvalósíthatja a sebességkorlátozó megoldást.

Először hozzon létre egy mappát, útvonalakat a projekt gyökérkönyvtárában a következő futtatással:

mkdir útvonalak

Hozzon létre egy fájlt, routes.js, az útvonalak mappájába, és adja hozzá a következő kódot:

const expressz = igényelnek("Expressz");
const router = expressz. Router();
router.get("/", (req, res) => {
 res.send({ üzenet: "Helló, ez egy GET kérés" });
});


router.post("/add-demo", (req, res) => {
 res.status (201).send({ üzenet: "Az erőforrás sikeresen létrehozva" });
});


router.put("/update-demo", (req, res) => {
 res.status (201).send({ üzenet: "Az erőforrás sikeresen frissítve" });
});
modult.export = router;

Ez a kód importál Expressz, hívja a Router módszer bekapcsolva Expressz, és az értéket egy változóban tárolja, router. Az Router módszer lehetővé teszi moduláris, felszerelhető útvonalkezelők létrehozását. Létrehozhat útvonalkezelőket a KAP kérni "/”, a POST kérni "/add-demo” és a PUT kérni "/update-demo”. Végül exportálja a router változó.

Ezután importálja a router változó a te index.js fájl:

// index.js
const útvonalak = igényelnek(./routes/routes");

Ezután használja köztes szoftverként az index.js fájlban:

// index.js
kb.használat(útvonalak);

Ügyeljen arra, hogy a fenti kódblokkot a app.hallgatni hívás.

4. lépés: A sebességkorlátozás végrehajtása

Először hozzon létre egy "köztes szoftver” mappába a projekt gyökérkönyvtárában a következő futtatással:

mkdir köztes szoftver

Ezután hozzon létre egy fájlt "rate-limiter.js” a köztes szoftver könyvtárban. Adja hozzá a következő kódot ehhez a fájlhoz:

// rate-limiter.js
const rateLimiter = igényelnek("express-rate-limit");
const limiter = rateLimiter({
 max: 5,
 windowMS: 10000, // 10 másodperc
 üzenet: "tudsz'jelenleg ne kérjen többet. Próbáld újra később",
});
modult.export = korlátozó

Az rateLimiter függvény egy konfigurációs objektumot vesz fel a feltételekkel, hogy korlátozza a kérések számát.

A fenti konfigurációs objektum tulajdonságai a következők:

  • max: Ennek a tulajdonságnak mindig a szám vagy egy számot visszaadó függvény. Ez a felhasználó által adott időkereten belül benyújtható kérések maximális számát jelenti. Ha ez a tulajdonság nincs beállítva a konfigurációs objektumban, akkor az alapértelmezett érték 5.
  • WindowsMS: Ennek a tulajdonságnak mindig számnak kell lennie. Azt az időtartamot jelöli, amelyen belül több kérés is megengedett ezredmásodperc. Ha ez a tulajdonság nincs beállítva a konfigurációs objektumban, akkor az alapértelmezett érték 60000 ezredmásodperc (egy perc).
  • üzenet: Ez az ingatlan lehet a húr, egy JSON-objektum vagy bármely más által támogatott érték Express válasza.küld módszer. Ha ez a tulajdonság nincs beállítva a konfigurációs objektumban, akkor alapértelmezés szerint „Túl sok kérés. Kérlek, próbáld újra később."

A funkció ezután ellenőrzi, hogy nem érkezik-e ismétlődő kérés az alkalmazáshoz. Ha egy felhasználó túllépi a korlátot (max, 5) az időkereten belül (windowsMS, 10s), blokkolja a kérést. Ezenkívül „Túl sok kérés” hibát fog kiadni állapotkóddal 429.

Végül importálja a limiter funkciót a sajátjába index.js fájlt, és globális köztes szoftverként alkalmazza az alkalmazásban. Tegye ezt az elhelyezéssel app.use (korlátozó) az útvonalak köztes szoftvere felett. Ez a díjkorlátozó megoldást alkalmazza az alkalmazás összes útvonalára.

kb.használat(korlátozó);

Díjkorlátozó meghatározott útvonalak

Adott útvonalakra díjkorlátozást is alkalmazhat. Külön beállíthatja őket, hogy elutasítsák a különböző időkeretben benyújtott kéréseket, más üzenetet jelenítsenek meg stb.

Tegyük fel például, hogy egy felhasználói bejelentkezési útvonalat valósít meg az alkalmazásban. Előfordulhat, hogy a bejelentkezési útvonalhoz olyan sebességkorlátozó konfigurációt kell hozzáadnia, amely eltér a többi útvonal által használt konfigurációtól.

Először is el kell távolítania korlátozó alkalmazásszintű köztes szoftverként, és alkalmazza, mert az ExpressJS-ben nincs beépített köztes szoftverszűrő rendszer. Tehát még ha egy adott díjkorlátozó megoldást is hozzáad egy útvonalhoz, a globális köztes szoftver továbbra is futni fog ezen az útvonalon.

Ezután hozzon létre egy új sebességkorlátozó konfigurációt az Ön számára rate-limiter.js fájlt és exportálja azt.

const signInLimiter = rateLimiter({
 max: 3,
 windowMS: 10000, //10 másodperc
 üzenet: "Túl sok bejelentkezési kísérlet. Próbáld újra később."
})
modult.export = {
 korlátozó,
 signInLimiter
}

Az signInLimiter konfigurációs objektumnak különböző száma van max kéréseket és az általános sebességkorlátozótól eltérő hibaüzenetet.

Végül frissítse router.js fájl az alábbi kódblokkkal:

// router.js
const expressz = igényelnek("Expressz");
const router = expressz. Router();
const {limiter, signInLimiter} = igényelnek("../middleware/rate-limiter")
router.get("/sign-in", signInLimiter, (req, res, next) => {
 res.send({ üzenet: "Helló, ez egy GET kérés" });
});


router.használat(korlátozó)


router.post("/post", (req, res) => {
 res.status (201).send({ üzenet: "Az erőforrás sikeresen létrehozva" });
});


router.put("/put", (req, res) => {
 res.status (201).send({ üzenet: "Az erőforrás sikeresen frissítve" });
});
modult.export = router;

A fenti kódblokkban importált korlátozó és signInLimiter. Aztán jelentkeztél signInLimiter a „/sign-in” útvonalon.

Végül az elhelyezéssel router.use (limiter) a többi útvonal felett korlátozót alkalmazott sebességkorlátozóként a többi útvonalra.

A mértékkorlátozás jelentősége

A sebességkorlátozás csökkenti a webszerver megterhelését, mivel elkerüli, hogy túl sok kérést kelljen egyszerre feldolgoznia. Csökkenti a botaktivitást, megvédi Önt a szolgáltatásmegtagadási (DoS) támadásoktól, és megakadályozza a brute force támadásokat.