p-limit vs express-rate-limit vs limiter vs bottleneck vs rate-limiter-flexible vs ratelimiter
Node.js におけるレート制限と並列処理制御の実装戦略
p-limitexpress-rate-limitlimiterbottleneckrate-limiter-flexibleratelimiter類似パッケージ:

Node.js におけるレート制限と並列処理制御の実装戦略

これらのライブラリは、Node.js アプリケーションにおけるリクエスト頻度の制御(レート制限)と、同時実行タスク数の管理(コンカレンシー制限)という 2 つの重要な課題を解決するために設計されています。express-rate-limit や rate-limiter-flexible などは、主に API サーバーに対して外部から来る過剰なリクエストを遮断し、サーバーを保護する「ゲートキーパー」として機能します。一方、p-limit や bottleneck は、アプリケーション内部から外部サービス(データベースや他 API)へ送信するリクエストを調整し、制限値を超えないように制御する「トラフィックコントローラー」として働きます。limiter と ratelimiter は歴史的なパッケージですが、現在はメンテナンスが停止しているか、より現代的な代替案が存在するため、新規プロジェクトでの採用には注意が必要です。

npmのダウンロードトレンド

3 年

GitHub Starsランキング

統計詳細

パッケージ
ダウンロード数
Stars
サイズ
Issues
公開日時
ライセンス
p-limit461,131,1332,94316.1 kB02ヶ月前MIT
express-rate-limit99,847,9223,318158 kB911時間前MIT
limiter23,887,4361,571103 kB52ヶ月前MIT
bottleneck15,603,3862,009-897年前MIT
rate-limiter-flexible4,759,0733,605234 kB124日前ISC
ratelimiter46,514720-117年前MIT

Node.js におけるレート制限と並列処理制御:アーキテクチャ別完全ガイド

Node.js アプリケーションの開発において、「誰が・いつ・どれだけアクセスできるか」を制御するレート制限と、「内部処理をどれだけ同時に行うか」を管理する並列制御は、システムの安定性を保つための両輪です。しかし、これらを解決するパッケージは目的によって全く異なるアプローチを取ります。ここでは、6 つの主要パッケージを「外部からの攻撃を防ぐ盾(Rate Limiting)」と「内部からの過負荷を防ぐ弁(Concurrency Control)」という 2 つの視点から徹底比較します。

🛡️ 外部リクエストの遮断:サーバー保護のためのレート制限

まず、クライアントからサーバーへ向かうトラフィックを制御するパッケージ群を見てみましょう。これらは主にミドルウェアとして動作し、特定の IP アドレスやユーザーからのリクエストが閾値を超えた場合にエラーを返します。

1. シンプルさと軽量化:express-rate-limit

express-rate-limit は、Express アプリケーション向けに設計された最もポピュラーなミドルウェアです。メモリ上でカウンターを管理するため、追加のインフラ(Redis など)が不要で、設定も極めて簡単です。単一サーバー構成の小規模〜中規模プロジェクトにおいて、DDoS 対策や API 乱用防止のファーストチョイスとなります。

// express-rate-limit: シンプルな IP ベース制限
import rateLimit from 'express-rate-limit';

const limiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15 分
  max: 100, // 各 IP につき 100 リクエストまで
  message: 'リクエストが多すぎます。少し待ってください。'
});

app.use('/api/', limiter);

2. 分散環境と柔軟性:rate-limiter-flexible

rate-limiter-flexible は、より複雑な要件を持つために設計されています。Redis、Memcached、MongoDB など 15 種類以上のストレージに対応しており、複数サーバー間で制限状態を共有できます。また、違反者に対する「ペナルティ時間」の付与や、ポイントベースのきめ細かい制御が可能で、大規模な SaaS やマイクロサービス構成に適しています。

// rate-limiter-flexible: Redis を使った分散制限とペナルティ設定
import { RateLimiterRedis } from 'rate-limiter-flexible';
import Redis from 'ioredis';

const redisClient = new Redis();

const rateLimiter = new RateLimiterRedis({
  storeClient: redisClient,
  keyPrefix: 'middleware',
  points: 10, // 10 ポイント消費
  duration: 1, // 1 秒あたり
  blockDuration: 60, // 違反すると 60 秒ブロック
});

// ミドルウェアとして使用
app.use(async (req, res, next) => {
  try {
    await rateLimiter.consume(req.ip);
    next();
  } catch (rejRes) {
    res.status(429).send('Too Many Requests');
  }
});

3. 歴史的パッケージの警告:limiter と ratelimiter

limiter と ratelimiter は、かつて広く使われていたパッケージですが、現在はメンテナンスが停止しているか、更新が非常に緩やかです。特に ratelimiter はセキュリティ上の懸念や、現代の非同期処理(Promise/async-await)への対応不足が指摘されています。新規プロジェクトでこれらを選ぶ理由はほぼありません。既存プロジェクトで使われている場合は、rate-limiter-flexible などへの移行を計画すべきです。

// ⚠️ 非推奨:limiter の古いコールバックスタイル
// 新規プロジェクトでは使用しないでください
import { RateLimiter } from 'limiter';

const limiter = new RateLimiter({ tokensPerInterval: 10, interval: 'second' });

limiter.removeTokens(1, (err, remainingTokens) => {
  // コールバック地獄になりやすく、エラー処理も煩雑
  if (remainingTokens < 0) {
    // 待機処理を手動で実装する必要あり
  }
});

🚦 内部処理の制御:外部 API 呼び出しの調整

次に、サーバー内部から外部サービス(Twitter API、Stripe、データベースなど)へリクエストを送る際の制御です。これらはミドルウェアというより、コード内の関数呼び出しをラップして使用します。

4. 軽量な並列制御:p-limit

p-limit は、驚くほど軽量なパッケージで、同時に実行される Promise の数を制限します。「1 秒間に 10 回まで」といった時間ベースの制限ではなく、「同時に 5 つまで」という並列数の制限に特化しています。外部依存がなく、ファイルアップロードやバッチ処理など、単純な並列制御が必要な場合に最適です。

// p-limit: 同時実行数の制限
import pLimit from 'p-limit';

const limit = pLimit(2); // 同時に 2 つまで

const input = [
  limit(() => fetchUrl('url1')),
  limit(() => fetchUrl('url2')),
  limit(() => fetchUrl('url3')),
  limit(() => fetchUrl('url4'))
];

// 全ての実行が完了するのを待つ
await Promise.all(input);

5. 高度なジョブ管理:bottleneck

bottleneck は、単なる並列制限を超えた機能を提供します。トークンバケットアルゴリズムに基づき、「1 秒間に 10 リクエスト」といった時間ベースの制限と並列制限を同時に扱えます。さらに、失敗したタスクの自動リトライ、優先度付きキュー、そして実行中のジョブ数監視など、本番環境の重要な機能が含まれています。信頼性が求められる重要なバックグラウンドジョブに最適です。

// bottleneck: 時間ベース制限とリトライ機構
import Bottleneck from 'bottleneck';

const limiter = new Bottleneck({
  maxConcurrent: 5,   // 同時 5 つ
  minTime: 100,       // 各ジョブ間に 100ms 空ける
  highWater: 10,      // キューが 10 を超えたら戦略発動
  strategy: Bottleneck.strategy.OVERFLOW // あふれたら捨てる
});

// 自動リトライ設定
limiter.on('failed', (error, jobInfo) => {
  return 2000; // 2 秒後にリトライ
});

const result = await limiter.schedule(() => {
  return externalApi.call();
});

⚔️ 実装パターンの深掘り:ミドルウェア vs ラッパー

これらのツールを使う際、最大の違いは「どこに組み込むか」です。レート制限系は Express の app.use に渡すことで、ルートハンドラーに到達する前にリクエストを弾きます。一方、並列制御系は、具体的な処理関数をラップして使用します。

比較:エラー処理とフィードバック

express-rate-limit や rate-limiter-flexible は、制限を超えた際に HTTP 429 ステータスを返すことを前提としています。これはクライアントに対して「待ち時間」を明確に伝えます。

// express-rate-limit: ヘッダーで残り時間を通知
// 自動的に以下のヘッダーが設定される
// X-RateLimit-Limit: 100
// X-RateLimit-Remaining: 95
// X-RateLimit-Reset: 1625097600

対照的に、bottleneck は内部処理が失敗した場合のリトライロジックを持っています。外部 API が一時的にダウンしていても、アプリケーション全体を止めずに回復を試みます。

// bottleneck: リトライによる回復
limiter.on('failed', (error, jobInfo) => {
  if (error.statusCode === 429) {
    // API 側からの制限なら、少し待ってリトライ
    return 5000; 
  }
  // それ以外のエラーはリトライしない
});

📊 選定ガイド:ユースケース別ベストプラクティス

要件推奨パッケージ理由
Express で手軽に IP 制限をしたいexpress-rate-limit設定が簡単で、メモリ動作のため Redis 不要。
複数サーバーで状態を共有したいrate-limiter-flexibleRedis 等に対応し、分散環境で一貫した制限が可能。
外部 API 呼び出しを並列制御したいp-limit軽量で、Promise の並列実行数を簡単に制限できる。
リトライや優先度キューが必要bottleneck高度なフロー制御とエラー回復機構が内置されている。
既存のレガシーコードを維持しているlimiter / ratelimiter非推奨。新規では使用せず、移行を検討すべき。

💡 結論:目的に応じて使い分ける

これら 6 つのパッケージは、それぞれ異なる「痛み」を解決するために存在します。

express-rate-limit は、小さな店舗の入口にある「入場制限係」のように、シンプルに来客数を調整します。一方、rate-limiter-flexible は、大規模スタジアムのセキュリティシステムのように、複数のゲートを跨いで厳密に管理を行います。

内部処理においては、p-limit が「一度に運べる荷物は 2 つまで」という単純なルールを課すのに対し、bottleneck は「壊れやすい荷物は優先的に、失敗したらやり直し」という複雑な物流システムを管理します。

limiter と ratelimiter は、かつての名機ですが、今は現役を引退しています。新しいプロジェクトを始める際は、メンテナンスが活発で、現代の非同期処理パターンに最適化された bottleneck や rate-limiter-flexible を選択することが、長期的なシステムの安定性につながります。

最終的には、「外部からの攻撃を防ぎたい」のか、「内部から外部へ迷惑をかけたくない」のかという目的を明確にし、それに最適なツールを選ぶことが重要です。

選び方: p-limit vs express-rate-limit vs limiter vs bottleneck vs rate-limiter-flexible vs ratelimiter

  • p-limit:

    外部ライブラリに依存せず、Promise ベースのタスク並列実行数を単純に制限したい場合に最適です。設定ファイルやストレージ不要で、コード内に数行追加するだけで「同時に 5 つまで」といった制約を課せるため、軽量なスクリプトや関数レベルの制御に適しています。

  • express-rate-limit:

    Express アプリケーションにおいて、シンプルに IP アドレスごとのリクエスト数を制限したい場合に最も適しています。設定が簡単で依存関係も少なく、ブログや小規模な API サーバーなど、複雑なストレージ連携が不要なプロジェクトで即戦力となります。

  • limiter:

    このパッケージは長期間メンテナンスされておらず、現代の非同期処理パターンやセキュリティ要件に合致しない可能性があるため、新規プロジェクトでの使用は避けるべきです。代わりに bottleneck や rate-limiter-flexible などのアクティブに管理されている代替案を検討してください。

  • bottleneck:

    外部 API やデータベースへのアクセス頻度を厳密に制御し、かつジョブの優先順位付けやリトライ機構が必要な場合に選択します。単なる制限だけでなく、タスクをキューに入れて順次処理する高度な制御が必要な複雑なバックグラウンド処理に適しています。

  • rate-limiter-flexible:

    Redis や Memcached などの分散ストレージを使用して、複数サーバー間でレート制限状態を共有する必要がある大規模システムに選択します。Express だけでなく Koa や Hapi など様々なフレームワークに対応しており、きめ細かいペナルティ設定や柔軟なストア連携が求められるエンタープライズ環境に適しています。

  • ratelimiter:

    このパッケージもメンテナンスが停止しており、セキュリティ修正や機能アップデートが期待できないため、新規プロジェクトでの採用は推奨されません。同等の機能を提供し、より活発に開発が続けられている rate-limiter-flexible への移行を強く推奨します。

p-limit のREADME

p-limit

Run multiple promise-returning & async functions with limited concurrency

Works in Node.js and browsers.

Install

npm install p-limit

Usage

import pLimit from 'p-limit';

const limit = pLimit(1);

const input = [
	limit(() => fetchSomething('foo')),
	limit(() => fetchSomething('bar')),
	limit(() => doSomething())
];

// Only one promise is run at once
const result = await Promise.all(input);
console.log(result);

API

pLimit(concurrency) default export

Returns a limit function.

concurrency

Type: number | object
Minimum: 1

Concurrency limit.

You can pass a number or an options object with a concurrency property.

rejectOnClear

Type: boolean
Default: false

Reject pending promises with an AbortError when clearQueue() is called. This is recommended if you await the returned promises, for example with Promise.all, so pending tasks do not remain unresolved after clearQueue().

import pLimit from 'p-limit';

const limit = pLimit({concurrency: 1});

limit(fn, ...args)

Returns the promise returned by calling fn(...args).

fn

Type: Function

Promise-returning/async function.

args

Any arguments to pass through to fn.

Support for passing arguments on to the fn is provided in order to be able to avoid creating unnecessary closures. You probably don't need this optimization unless you're pushing a lot of functions.

Warning: Avoid calling the same limit function inside a function that is already limited by it. This can create a deadlock where inner tasks never run. Use a separate limiter for inner tasks.

limit.map(iterable, mapperFunction)

Process an iterable of inputs with limited concurrency.

The mapper function receives the item value and its index.

Returns a promise equivalent to Promise.all(Array.from(iterable, (item, index) => limit(mapperFunction, item, index))).

If the iterable throws during iteration, the returned promise rejects with that error. Mapper functions that were already scheduled still run, and their results are discarded.

This is a convenience function for processing inputs that arrive in batches. For more complex use cases, see p-map.

limit.activeCount

The number of promises that are currently running.

limit.pendingCount

The number of promises that are waiting to run (i.e. their internal fn was not called yet).

limit.clearQueue()

Discard pending promises that are waiting to run.

This might be useful if you want to tear down the queue at the end of your program's lifecycle or discard any function calls referencing an intermediary state of your app.

Note: This does not cancel promises that are already running.

When rejectOnClear is enabled, pending promises are rejected with an AbortError. This is recommended if you await the returned promises, for example with Promise.all, so pending tasks do not remain unresolved after clearQueue().

limit.concurrency

Get or set the concurrency limit.

limitFunction(fn, options) named export

Returns a function with limited concurrency.

The returned function manages its own concurrent executions, allowing you to call it multiple times without exceeding the specified concurrency limit.

Ideal for scenarios where you need to control the number of simultaneous executions of a single function, rather than managing concurrency across multiple functions.

import {limitFunction} from 'p-limit';

const limitedFunction = limitFunction(async () => {
	return doSomething();
}, {concurrency: 1});

const input = Array.from({length: 10}, limitedFunction);

// Only one promise is run at once.
await Promise.all(input);

fn

Type: Function

Promise-returning/async function.

options

Type: object

concurrency

Type: number
Minimum: 1

Concurrency limit.

rejectOnClear

Type: boolean
Default: false

Reject pending promises with an AbortError when clearQueue() is called. This is recommended if you await the returned promises, for example with Promise.all, so pending tasks do not remain unresolved after clearQueue().

limitedFunction.clearQueue()

Discard pending calls that have not started yet.

When rejectOnClear is enabled, pending promises are rejected with an AbortError. Otherwise, their promises remain unresolved.

This does not cancel calls that are already running.

Recipes

See recipes.md for common use cases and patterns.

FAQ

How is this different from the p-queue package?

This package is only about limiting the number of concurrent executions, while p-queue is a fully featured queue implementation with lots of different options, introspection, and ability to pause the queue.

Related

  • p-throttle - Throttle promise-returning & async functions
  • p-debounce - Debounce promise-returning & async functions
  • p-map - Run promise-returning & async functions concurrently with different inputs
  • p-all - Run promise-returning & async functions concurrently with optional limited concurrency
  • More…