レートリミティング: APIのアルゴリズムと実装
トークンバケット、リーキーバケット、スライディングウィンドウなどの主要アルゴリズムと、Node.jsやCloudflareでの実践的な実装を解説。
レートリミティング(Rate Limiting、利用制限)は、悪意のある乱用、ブルートフォース攻撃、急激なトラフィック急増(スパイク)からAPIを保護するための不可欠な技術です。本記事では、代表的なレート制限アルゴリズムの仕組みと、Node.jsやCloudflare Workersにおける本番向けの具体的な実装方法を解説します。
なぜレートリミティングが必要なのか?#
レートリミティングは、サーバーを守る「警備員」のような役割を果たします:
- DDoS攻撃やブルートフォース(総当たり攻撃)の防止: 認証エンドポイントへのパスワード総当たりや、不正なスクレイピングを入口で遮断します。
- リソースの公平な利用(Fair Usage)の保証: 一部のヘビーユーザー(Noisy Neighbor)がリソースを占有し、他の正常なユーザーの利用を妨げることを防ぎます。
- バックエンドの過負荷防止: トラフィック急増時にも、後続のデータベースやマイクロサービスが過負荷でダウンしないよう保護します。
- APIコストの抑制: OpenAIやAnthropicなどの従量課金制AI APIをプロキシ経由で提供する場合、予期せぬ高額請求を回避します。
主要なアルゴリズム#
1. 固定ウィンドウカウンター(Fixed Window Counter)#
最もシンプルなアプローチで、固定された時間枠(例: 1分間)ごとにリクエスト数をカウントします。
class FixedWindowRateLimiter {
private windows = new Map<string, { count: number; resetAt: number }>();
constructor(
private windowMs: number,
private maxRequests: number,
) {}
check(key: string): boolean {
const now = Date.now();
let window = this.windows.get(key);
if (!window || now > window.resetAt) {
window = { count: 0, resetAt: now + this.windowMs };
this.windows.set(key, window);
}
window.count++;
return window.count <= this.maxRequests;
}
}
const limiter = new FixedWindowRateLimiter(60_000, 10);
// 1分間に10リクエストまでtypescript[!WARNING] 境界でのバースト問題:
0:59に10回、続く1:00に10回のリクエストが発生した場合、実質わずか2秒間で20回のリクエストが実行され、想定の2倍の負荷がサーバーにかかります。
2. スライディングウィンドウログ(Sliding Window Log)#
各リクエストのタイムスタンプを配列に記録し、直近の一定期間(例: 過去60秒間)に含まれるリクエスト数のみを計算します。
class SlidingWindowLog {
private logs = new Map<string, number[]>();
constructor(
private windowMs: number,
private maxRequests: number,
) {}
check(key: string): boolean {
const now = Date.now();
let log = this.logs.get(key) || [];
const windowStart = now - this.windowMs;
// 期限切れのエントリを削除
log = log.filter(t => t > windowStart);
this.logs.set(key, log);
if (log.length >= this.maxRequests) {
return false;
}
log.push(now);
return true;
}
}typescript[!NOTE] 境界バーストが発生せず非常に高精度ですが、全リクエストのタイムスタンプを保持するため、リクエスト数に比例してメモリ消費量が増加します。
3. スライディングウィンドウカウンター(Redis Sorted Sets)#
固定ウィンドウの省メモリ性とスライディングログの正確性を両立させた手法で、Redisのソート済みセット(ZSET)を活用します。
import { createClient } from 'redis';
const redis = createClient();
async function checkRateLimit(
key: string,
limit: number,
windowSec: number,
): Promise<{ allowed: boolean; remaining: number; resetAt: number }> {
const now = Date.now();
const windowStart = now - windowSec * 1000;
// アトミックなパイプライン処理
const multi = redis.multi();
multi.zRemRangeByScore(key, 0, windowStart); // 期限切れエントリの削除
multi.zAdd(key, { score: now, value: `${now}` });
multi.zCard(key); // ウィンドウ内のリクエスト数を取得
multi.expire(key, windowSec);
const [, , count] = await multi.exec();
const requestCount = count as number;
return {
allowed: requestCount <= limit,
remaining: Math.max(0, limit - requestCount),
resetAt: Math.ceil((windowStart + windowSec * 1000) / 1000),
};
}typescript4. トークンバケット(Token Bucket)#
バケット(容量)に一定速度(トークン/秒)でトークンが補充されます。リクエストはトークンを1つ消費して処理され、トークンが不足している場合はリクエストが拒否されます。
class TokenBucket {
private buckets = new Map<string, { tokens: number; lastRefill: number }>();
constructor(
private capacity: number, // 最大トークン容量
private refillRate: number, // 1秒あたりの補充トークン数
) {}
private refill(key: string) {
const bucket = this.buckets.get(key);
if (!bucket) return;
const now = Date.now();
const elapsed = (now - bucket.lastRefill) / 1000;
const newTokens = elapsed * this.refillRate;
bucket.tokens = Math.min(this.capacity, bucket.tokens + newTokens);
bucket.lastRefill = now;
}
tryConsume(key: string): boolean {
if (!this.buckets.has(key)) {
this.buckets.set(key, { tokens: this.capacity, lastRefill: Date.now() });
}
this.refill(key);
const bucket = this.buckets.get(key)!;
if (bucket.tokens >= 1) {
bucket.tokens -= 1;
return true;
}
return false;
}
}typescript[!TIP] メリット: バケットが満タンであれば一時的なトラフィックバーストを許容しつつ、長期的には安定した平均レートを維持します。AWSやStripeのAPIで広く採用されています。
5. リーキーバケット(Leaky Bucket)#
底に小さな穴が開いたバケツのような仕組みです。リクエストはキューに入り、穴から水滴が滴るように常に一定の速度で処理されます。バケツの容量を超えたリクエストは溢れ出て破棄されます。
非同期ジョブキューやバックグラウンド処理の平滑化(トラフィックシェーピング)に適しています。
実装例 — Express Middleware#
実際のExpressアプリケーションでは、エンドポイントの重要度やユーザーのティアに応じて階層的な制限を設定します:
import rateLimit from 'express-rate-limit';
import RedisStore from 'rate-limit-redis';
import { createClient } from 'redis';
const redis = createClient();
// グローバルリミッター — 全体のベースライン保護
const globalLimiter = rateLimit({
windowMs: 60_000,
max: 100,
standardHeaders: true,
legacyHeaders: false,
message: { error: 'Too many requests' },
});
// 認証リミッター — ブルートフォース攻撃を防ぐ厳格な制限
const authLimiter = rateLimit({
windowMs: 15 * 60_000,
max: 5,
skipSuccessfulRequests: false,
keyGenerator: (req) => req.ip,
handler: (req, res) => {
res.status(429).json({
error: 'Too many login attempts. Try again later.',
retryAfter: Math.ceil(req.rateLimit.resetTime / 1000),
});
},
});
// APIキーリミッター — 分散Redisストアを用いた階層別制限
const apiLimiter = rateLimit({
store: new RedisStore({
sendCommand: (...args: string[]) => redis.sendCommand(args),
}),
windowMs: 60_000,
max: (req) => {
// プランに応じた上限設定
const tier = req.headers['x-api-tier'] || 'free';
const limits = { free: 10, pro: 100, enterprise: 1000 };
return limits[tier as keyof typeof limits] || 10;
},
keyGenerator: (req) => req.headers['x-api-key'] as string,
});
app.use('/api/', globalLimiter);
app.use('/api/auth/login', authLimiter);
app.use('/api/v2', apiLimiter);typescriptレスポンスヘッダー(Response Headers)#
クライアント側が適切なリトライ間隔(指数バックオフなど)を判断できるよう、常にレート制限情報をヘッダーに含めます:
X-RateLimit-Limit: 100
X-RateLimit-Remaining: 45
X-RateLimit-Reset: 1718845200
Retry-After: 45httpCloudflareでのレートリミティング#
ネットワークエッジ(CDN層)でレート制限を適用することで、悪意のあるトラフィックがオリジンサーバーに到達する前に遮断できます。
Wrangler CLIまたはダッシュボードでルールを作成します:
# Wrangler CLIによる作成
wrangler ratelimit create my-limit --limit 100 --period 60bashCloudflare Workersでのバインディング実装例:
export default {
async fetch(request: Request, env: Env): Promise<Response> {
const key = request.headers.get('CF-Connecting-IP') || 'unknown';
const { success } = await env.myRateLimiter.limit({ key });
if (!success) {
return new Response('Too Many Requests', { status: 429 });
}
return new Response('OK');
},
};typescript分散システムにおけるレートリミティング#
複数のサーバーで構成されるクラスター環境では、各サーバーのローカルメモリでカウントするとユーザーのリクエストが分散して制限をすり抜けてしまいます。中央集権型のRedisを用いて状態を共有します:
競合状態(Race Condition)を防ぐアトミックなRedis Luaスクリプト:
-- rate_limit.lua
local key = KEYS[1]
local limit = tonumber(ARGV[1])
local window = tonumber(ARGV[2])
local now = tonumber(ARGV[3])
redis.call('ZREMRANGEBYSCORE', key, 0, now - window)
local count = redis.call('ZCARD', key)
if count >= limit then
return 0
end
redis.call('ZADD', key, now, now)
redis.call('EXPIRE', key, window)
return limit - count - 1luaベストプラクティス#
- 常に標準ヘッダーを返却する: クライアントが
Retry-Afterを解釈して無駄なリトライを防ぐことができます。 - エンドポイントごとに異なる制限値を設ける: 一般的な閲覧APIは緩やかに、ログインや決済、重量級検索エンドポイントは厳格に設定します。
- 複合キーを利用する: IPアドレスだけでなく、APIキーやユーザーID(
IP + apiKey + userId)を組み合わせることで、IP切り替えによる回避を防ぎます。 - 分散データストアの活用: 複数インスタンス環境ではRedisとLuaスクリプトを用いて正確なアトミック操作を行います。
- グレースフルデグラデーション(フェイルオープン): 万が一Redisが障害で停止した場合、正常なユーザーを巻き込んで遮断しないよう、一時的にリクエストを通す設計を検討します。
- 違反ログの監視: 429エラーのログを継続的にモニタリングし、攻撃パターンや適切な閾値の調整に役立てます。
まとめ#
レートリミティングは単なるセキュリティ防御策にとどまらず、システムの計算リソースを健全に管理するための基盤です。簡易的な用途には固定ウィンドウ、バースト防止にはスライディングウィンドウ、突発的なアクセスを柔軟にさばくにはトークンバケットが最適です。分散構成ではRedisを活用し、グローバル規模ではCloudflare Workersのエッジ制限を検討してください。システムの要件と規模に合わせた適切なアルゴリズムを選定しましょう。