Rate limiting with express-rate-limit - Mini Project: Build & Apply

Rate limiting with express-rate-limit

📖 Scenario: You are building a simple Express server that needs to protect its API from too many requests from the same user. This helps keep the server safe and fair for everyone.

🎯 Goal: Create an Express server that uses express-rate-limit to limit each user to 5 requests every 10 minutes.

📋 What You'll Learn

Create an Express app with a single GET route at /

Set up express-rate-limit with a limit of 5 requests per 10 minutes

Apply the rate limiter middleware to the GET / route

Send a simple text response 'Hello, world!' when the route is accessed

💡 Why This Matters

🌍 Real World

Rate limiting helps protect web servers from too many requests that can slow down or crash the server. It is used in APIs and websites to keep service fair and stable.

💼 Career

Understanding how to use middleware like express-rate-limit is important for backend developers to build secure and reliable web applications.

1

Set up Express app and import express-rate-limit

Write code to import express and express-rate-limit. Then create an Express app by calling express() and store it in a variable called app.

Express

const express = require('express');
const rateLimit = require('express-rate-limit');

// Your code here

Hint

Use require('express') and require('express-rate-limit') to import the packages. Then call express() to create the app.

2

Create a rate limiter configuration

Create a variable called limiter and assign it the result of calling rateLimit() with an object that sets windowMs to 600000 (10 minutes in milliseconds) and max to 5.

Express

const express = require('express');
const rateLimit = require('express-rate-limit');

const app = express();

// Your code here

Hint

Use rateLimit() with an object that has windowMs set to 600000 and max set to 5.

3

Apply the rate limiter to the GET / route

Use app.get to create a GET route at '/'. Pass limiter as middleware before the route handler function. The handler should send the text 'Hello, world!' as the response.

Express

const express = require('express');
const rateLimit = require('express-rate-limit');

const app = express();

const limiter = rateLimit({
  windowMs: 600000,
  max: 5
});

// Your code here

Hint

Use app.get with limiter as middleware and send 'Hello, world!' in the response.

4

Start the Express server

Add code to make the app listen on port 3000 using app.listen. Pass a callback function that does nothing (empty arrow function).

Express

const express = require('express');
const rateLimit = require('express-rate-limit');

const app = express();

const limiter = rateLimit({
  windowMs: 600000,
  max: 5
});

app.get('/', limiter, (req, res) => {
  res.send('Hello, world!');
});

// Your code here

Hint

Use app.listen(3000, () => {}) to start the server on port 3000.

Practice

1. What is the main purpose of using express-rate-limit in an Express app?

easy

A. To handle database connections efficiently

B. To speed up the server response time

C. To automatically restart the server on code changes

D. To limit the number of requests a user can make in a time window

Solution

1. Step 1: Understand the purpose of rate limiting

   Rate limiting is used to protect the server by restricting how many requests a user can send in a short time.

2. Step 2: Identify what express-rate-limit does

   This package helps set these limits easily in Express apps.

3. Final Answer:

   To limit the number of requests a user can make in a time window -> Option D

4. Quick Check:

   Rate limiting = limit requests [OK]

Hint: Rate limiting controls request count per time window [OK]

Common Mistakes:

• Thinking it speeds up server responses
• Confusing it with server restart tools
• Assuming it manages database connections

2. Which of the following is the correct way to import and use express-rate-limit in an Express app?

easy

A. const rateLimit = require('express-rate-limit'); app.use(rateLimit({ windowMs: 60000, max: 5 }));

B. const rateLimit = require('express-rate-limit'); app.use(rateLimit());

C. import rateLimit from 'express-rate-limit'; app.use(rateLimit());

D. import rateLimit from 'express-rate-limit'; app.use(rateLimit);

Solution

1. Step 1: Check import style for CommonJS

   Using require is correct for many Express apps.

2. Step 2: Verify usage of rateLimit function with options

   We must call rateLimit with an options object like { windowMs: 60000, max: 5 } to set limits.

3. Final Answer:

   const rateLimit = require('express-rate-limit'); app.use(rateLimit({ windowMs: 60000, max: 5 })); -> Option A

4. Quick Check:

   Import + call with options = B [OK]

Hint: Call rateLimit with options object, not empty or missing [OK]

Common Mistakes:

• Forgetting to call rateLimit as a function
• Using import without proper setup
• Passing rateLimit directly without options

3. Given this code snippet, what will happen if a user sends 7 requests within 1 minute?

const rateLimit = require('express-rate-limit');
const limiter = rateLimit({ windowMs: 60000, max: 5 });
app.use(limiter);

medium

A. All 7 requests will be accepted without any limit

B. Only the first 2 requests will be accepted; the rest will be blocked

C. Only the first 5 requests will be accepted; the next 2 will be blocked

D. The server will crash after 5 requests

Solution

1. Step 1: Understand the max and windowMs settings

   The limit is 5 requests per 60000 milliseconds (1 minute).

2. Step 2: Analyze the request count

   The first 5 requests are allowed; requests 6 and 7 exceed the limit and get blocked.

3. Final Answer:

   Only the first 5 requests will be accepted; the next 2 will be blocked -> Option C

4. Quick Check:

   max 5 requests = C [OK]

Hint: Requests over max in windowMs get blocked [OK]

Common Mistakes:

• Assuming all requests pass without limit
• Thinking limit resets before 1 minute
• Believing server crashes on limit

4. Identify the error in this code snippet for rate limiting:

const rateLimit = require('express-rate-limit');
const limiter = rateLimit({ max: 10 });
app.use(limiter);

medium

A. Incorrect import statement for express-rate-limit

B. Missing windowMs option to define the time window

C. Using max instead of limit option

D. Calling app.use before defining limiter

Solution

1. Step 1: Check required options for rateLimit

   The windowMs option is needed to specify the time frame for the limit.

2. Step 2: Identify missing option

   The code only sets max but does not set windowMs, so the time window is undefined.

3. Final Answer:

   Missing windowMs option to define the time window -> Option B

4. Quick Check:

   windowMs missing = A [OK]

Hint: Always set windowMs with max for rateLimit [OK]

Common Mistakes:

• Forgetting windowMs causes no time limit
• Confusing max with limit option
• Wrong import syntax

5. You want to apply rate limiting only to the login route to prevent brute force attacks. Which code snippet correctly applies express-rate-limit only to /login?

hard

A. app.use('/login', rateLimit({ windowMs: 60000, max: 5 }));

B. app.use(rateLimit({ windowMs: 60000, max: 5 })); app.use('/login');

C. app.get('/login', rateLimit({ windowMs: 60000, max: 5 }));

D. app.post(rateLimit({ windowMs: 60000, max: 5 }), '/login');

Solution

1. Step 1: Understand how to apply middleware to specific routes

   Using app.use('/login', middleware) applies the middleware only to the /login path.

2. Step 2: Check the correct syntax for rateLimit middleware

   Calling rateLimit with options returns middleware to pass to app.use.

3. Final Answer:

   app.use('/login', rateLimit({ windowMs: 60000, max: 5 })); -> Option A

4. Quick Check:

   Middleware on route = A [OK]

Hint: Use app.use with path and rateLimit middleware [OK]

Common Mistakes:

• Calling app.use without path for specific routes
• Using app.get or app.post incorrectly with middleware
• Passing middleware after route string