Ograniczanie i kontrola przepustowości
Implementuj ograniczanie liczby żądań i kontrolę przepustowości, aby chronić API przed nadużyciami i zapewnić sprawiedliwe wykorzystanie zasobów przez klientów.
Ograniczanie i kontrola przepustowości to bezpłatna lekcja NestJS Enterprise Backend APIs na CoddyKit. To lekcja 1 z 3. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej NestJS Enterprise Backend APIs, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs NestJS Enterprise Backend APIs zawiera 3 lekcji w sumie.
Części tej lekcji nie zostały jeszcze przetłumaczone i są wyświetlane po angielsku.
What is Rate Limiting?
Imagine a popular API. Without limits, a single user or malicious bot could flood it with requests, slowing it down for everyone or even crashing it.
Rate limiting is a technique to control the number of requests a client can make to a server within a specific time window. It's like a bouncer at a club, ensuring fair entry for all.
Protecting Your API
Rate limiting is vital for several reasons:
- Prevent Abuse: Stops bots and malicious users from overwhelming your API.
- Ensure Fair Usage: Guarantees that all users get a reasonable share of API resources.
- DDoS Protection: A basic layer of defense against distributed denial-of-service attacks.
- Cost Management: For cloud-based services, too many requests can lead to higher bills.
Rate Limiting in Action
Let's see a simple example of how a rate limiter might work behind the scenes. This script tracks requests from different "IP addresses" and allows only a certain number within a time window.
const requestCounts = new Map<string, { count: number; resetTime: number }>();
const LIMIT = 3; // Max 3 requests
const WINDOW_MS = 5000; // per 5 seconds
function checkRateLimit(ip: string): boolean {
const now = Date.now();
let entry = requestCounts.get(ip);
if (!entry || now > entry.resetTime) {
entry = { count: 1, resetTime: now + WINDOW_MS };
requestCounts.set(ip, entry);
return true; // Request allowed
}
if (entry.count < LIMIT) {
entry.count++;
requestCounts.set(ip, entry);
return true; // Request allowed
}
return false; // Request denied
}
// Simulate requests for IP "192.168.1.1"
console.log("Req 1 (IP A):", checkRateLimit("192.168.1.1"));
console.log("Req 2 (IP A):", checkRateLimit("192.168.1.1"));
console.log("Req 3 (IP A):", checkRateLimit("192.168.1.1"));
console.log("Req 4 (IP A):", checkRateLimit("192.168.1.1")); // Denied
console.log("Req 1 (IP B):", checkRateLimit("192.168.1.2"));What is Throttling?
While often used interchangeably, throttling has a subtle difference. Rate limiting is a hard cap: once you hit the limit, you're blocked.
Throttling, however, aims to smooth out the request rate, often by delaying requests or allowing a slower, sustained rate rather than blocking entirely. It's more about resource management and preventing a system from becoming overloaded.
Introducing NestJS Throttler
NestJS provides a robust solution for both rate limiting and throttling through the @nestjs/throttler package. It's built on top of the express-rate-limit or fastify-rate-limit packages, offering a declarative way to protect your endpoints.
The module uses a guard to intercept requests and apply rules before they reach your controller logic.
Global Throttling Configuration
First, install the package. Then, integrate ThrottlerModule into your root module (AppModule) and apply the ThrottlerGuard globally.
// 1. Install package
// npm install @nestjs/throttler
// 2. src/app.module.ts
import { Module } from '@nestjs/common';
import { ThrottlerModule, ThrottlerGuard } from '@nestjs/throttler';
import { APP_GUARD } from '@nestjs/core'; // For global guard
@Module({
imports: [
ThrottlerModule.forRoot([{
ttl: 60000, // Time to live (1 minute)
limit: 10 // Max 10 requests
}]),
],
providers: [
{
provide: APP_GUARD,
useClass: ThrottlerGuard,
},
],
})
export class AppModule {}Overriding Limits per Route
Sometimes, you need different limits for specific endpoints. For example, a login route might have a stricter limit than a public data endpoint. You can override the global settings using the @Throttle() decorator.
// src/app.controller.ts
import { Controller, Get } from '@nestjs/common';
import { Throttle } from '@nestjs/throttler';
@Controller('posts')
export class PostsController {
@Get()
findAll(): string {
return 'This is a public list of posts.';
}
@Throttle({ default: { limit: 3, ttl: 60000 } }) // 3 req/min
@Get('protected')
findProtected(): string {
return 'This is a protected list of posts.';
}
@Throttle({ default: { limit: 1, ttl: 5000 } }) // 1 req/5s
@Get('critical')
findCritical(): string {
return 'Accessing critical data.';
}
}Skipping Throttling
There might be routes you want to completely exempt from any throttling rules, such as health check endpoints or webhook receivers that expect high traffic. Use the @SkipThrottle() decorator for this.
// src/status.controller.ts
import { Controller, Get } from '@nestjs/common';
import { SkipThrottle } from '@nestjs/throttler';
@Controller('status')
export class StatusController {
@SkipThrottle() // This route will ignore all throttling
@Get('health')
getHealth(): string {
return 'API is healthy!';
}
@Get('metrics')
getMetrics(): string {
return 'Application metrics data.'; // This route is throttled
}
}Beyond IP Address
By default, the NestJS Throttler module identifies clients by their IP address. However, for authenticated users, you might want to apply limits based on their user ID, rather than their IP.
This requires extending the ThrottlerGuard and overriding the getRequestResponse method to extract a different key (e.g., from a JWT token). This ensures that a single user cannot bypass limits by changing IPs.
Understanding Throttling
You've learned about rate limiting and throttling. Let's test your understanding!
Summary of Protection
Great job! In this lesson, you learned about the importance of rate limiting and throttling to protect your NestJS APIs. You explored how to set up the @nestjs/throttler module, configure global limits, apply route-specific rules, and even skip throttling for certain endpoints.
Implementing these techniques is a crucial step in building robust and secure backend services. Keep exploring how to fine-tune these limits and integrate them with other security measures!
Ucz się TypeScript dzięki korepetycjom AI — za darmo
Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.
- Kursy
- 20
- Lekcje
- 76
Często zadawane pytania
Czy lekcja „Ograniczanie i kontrola przepustowości” jest bezpłatna?
Tak — pełny tekst „Ograniczanie i kontrola przepustowości” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu NestJS Enterprise Backend APIs, przejdź na CoddyKit PRO. Kurs NestJS Enterprise Backend APIs zawiera 3 lekcji w sumie.
Co nauczysz się w „Ograniczanie i kontrola przepustowości”?
Implementuj ograniczanie liczby żądań i kontrolę przepustowości, aby chronić API przed nadużyciami i zapewnić sprawiedliwe wykorzystanie zasobów przez klientów. Ćwiczysz NestJS Enterprise Backend APIs z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.
Czy potrzebuję doświadczenia, aby zacząć NestJS Enterprise Backend APIs?
Nie wymagamy żadnego doświadczenia. NestJS Enterprise Backend APIs w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 3.
Ile czasu zajmuje lekcja „Ograniczanie i kontrola przepustowości”?
Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.
Czy mogę pisać i uruchamiać kod w tej lekcji NestJS Enterprise Backend APIs?
Tak. Każda lekcja NestJS Enterprise Backend APIs zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.
Wszystkie lekcje w tym kursie
- Ograniczanie i kontrola przepustowości
- Logowanie za pomocą Winston/Pino
- Monitorowanie za pomocą Prometheus