Amazon SP-API のレートリミット制約と、本番運用の 5 つの実装パターン

// 429 レスポンスのヘッダから現在のレートを読む
const rateLimit = parseFloat(
  response.headers.get("x-amzn-RateLimit-Limit") ?? "0"
)
// 例: "0.0167" → 約 60 秒に 1 トークン

async function retryWithBackoff<T>(fn: () => Promise<T>, maxAttempts = 5): Promise<T> {
  for (let attempt = 0; attempt < maxAttempts; attempt++) {
    try {
      return await fn()
    } catch (error) {
      if (!isRateLimitError(error) || attempt === maxAttempts - 1) throw error
      const baseMs = 1000 * 2 ** attempt     // 1s, 2s, 4s, 8s, 16s
      const jitter = Math.random() * baseMs  // 0〜baseMs のランダム幅
      await sleep(baseMs + jitter)
    }
  }
  throw new Error("unreachable")
}
 
function isRateLimitError(err: unknown): boolean {
  return (err as { statusCode?: number }).statusCode === 429
}
 
const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms))

async function throttledFetch(url: string, init?: RequestInit): Promise<Response> {
  const response = await fetch(url, init)
 
  const rateHeader = response.headers.get("x-amzn-RateLimit-Limit")
  if (rateHeader) {
    const ratePerSec = parseFloat(rateHeader)
    // 補充レートの逆数 = 最低限必要なリクエスト間隔(ms)
    const minIntervalMs = (1 / ratePerSec) * 1000
    // 安全マージン 10% を乗せて待機
    await sleep(minIntervalMs * 1.1)
  }
 
  return response
}

// Producer: 注文 ID を SQS に積むだけ
await sqs.sendMessageBatch({
  QueueUrl: ORDER_ITEMS_QUEUE_URL,
  Entries: orderIds.map((id, i) => ({
    Id: String(i),
    MessageBody: JSON.stringify({ orderId: id }),
  })),
})
 
// Consumer Lambda (Lambda Reserved Concurrency=1 で多重実行を防ぐ)
export const handler: SQSHandler = async (event) => {
  for (const record of event.Records) {
    const { orderId } = JSON.parse(record.body)
    await fetchAndSaveOrderItems(orderId)
    // Rate=0.5 のエンドポイントなら 2 秒に 1 件
    await sleep(2000)
  }
}

import { createClient } from "redis"
 
const redis = createClient({ url: process.env.REDIS_URL })
await redis.connect()
 
// 直近の発行時刻を見て、interval 以上空いていれば now を記録して 1 を返す Lua。
// GET と SET を 1 スクリプトに閉じることで、複数 Lambda が同時に呼んでも
// 「空キーを観測 → 全員が通過」という競合が起きず、スロット取得がアトミックになる。
const ACQUIRE_LUA = `
local last = redis.call('GET', KEYS[1])
local now = tonumber(ARGV[1])
local interval = tonumber(ARGV[2])
if (not last) or (now - tonumber(last) >= interval) then
  redis.call('SET', KEYS[1], now, 'PX', math.ceil(interval * 2))
  return 1
end
return 0
`
 
async function acquireToken(
  endpoint: string,
  ratePerSec: number,
  timeoutMs = 30_000
): Promise<void> {
  const key = `sp-api:rate:${endpoint}`
  const intervalMs = (1 / ratePerSec) * 1000
  const deadline = Date.now() + timeoutMs
 
  while (Date.now() < deadline) {
    // チェックと記録をアトミックに行う（get→set の間に他インスタンスが割り込めない）
    const acquired = await redis.eval(ACQUIRE_LUA, {
      keys: [key],
      arguments: [String(Date.now()), String(Math.ceil(intervalMs))],
    })
    if (acquired === 1) return // スロット取得成功
    await sleep(Math.min(intervalMs, Math.max(0, deadline - Date.now())))
  }
  throw new Error(`Rate limiter timeout for ${endpoint}`)
}
 
// 使い方
await acquireToken("getOrders", 0.0167)
const response = await ordersApi.getOrders(/* ... */)

// 1. レポート生成をリクエスト（リクエスト 1 回）
const { reportId } = await reportsApi.createReport({
  reportType: "GET_FLAT_FILE_ALL_ORDERS_DATA_BY_LAST_UPDATE_GENERAL",
  dataStartTime: new Date(Date.now() - 24 * 60 * 60 * 1000).toISOString(),
  dataEndTime: new Date().toISOString(),
  marketplaceIds: [process.env.MARKETPLACE_ID!],
})
 
// 2. 完了まで Exponential Backoff でポーリング（数分かかることがある）
async function waitForReport(reportId: string): Promise<string> {
  for (let attempt = 0; attempt < 10; attempt++) {
    const { processingStatus, reportDocumentId } = await reportsApi.getReport(reportId)
    if (processingStatus === "DONE" && reportDocumentId) return reportDocumentId
    if (processingStatus === "FATAL") throw new Error(`Report failed: ${reportId}`)
    await sleep(1000 * 2 ** attempt) // 指数バックオフでポーリング
  }
  throw new Error("Report timed out")
}
 
// 3. ドキュメント取得（S3 presigned URL から一括ダウンロード）
const { url } = await reportsApi.getReportDocument(await waitForReport(reportId))
const tsvContent = await fetch(url).then((r) => r.text())
// TSV をパースして OMS に取り込む