使用AWS SDK批量删Cognito用户遇TooManyRequestsException的最优解法

我之前在处理Cognito批量用户删除时也踩过这个限流的坑，结合AWS官方建议和实践经验，给你几个最优的处理方案：

1. 指数退避重试机制（官方推荐） #

固定1-2秒等待的重试方式效率偏低，AWS官方更建议用指数退避策略——每次重试的等待时间翻倍，同时加入随机抖动避免并发冲突，既尊重Cognito的限流阈值，又能最大化处理效率。

基于AWS SDK v3的实现示例 #

import { CognitoIdentityProviderClient, AdminDeleteUserCommand } from "@aws-sdk/client-cognito-identity-provider";
import { retry } from "@aws-sdk/util-retry";

const cognitoClient = new CognitoIdentityProviderClient({
  region: "你的区域",
  retryConfig: {
    maxRetries: 5, // 最多重试5次
    retryDelay: (attempt) => Math.pow(2, attempt) * 1000 + Math.random() * 500, // 指数退避+随机抖动
    retryableErrorCodes: ["TooManyRequestsException"] // 仅针对限流错误重试
  }
});

async function deleteSingleUser(userPoolId, username) {
  const command = new AdminDeleteUserCommand({
    UserPoolId: userPoolId,
    Username: username
  });
  return cognitoClient.send(command);
}

async function batchDeleteUsers(userPoolId, usernames) {
  for (const username of usernames) {
    try {
      await deleteSingleUser(userPoolId, username);
      console.log(`成功删除用户: ${username}`);
    } catch (err) {
      if (err.name === "TooManyRequestsException") {
        // 兜底手动重试（SDK自带重试失效时用）
        await retry(async () => deleteSingleUser(userPoolId, username), {
          maxRetries: 3,
          retryDelay: (attempt) => Math.pow(2, attempt) * 1000 + Math.random() * 500
        });
      } else {
        console.error(`删除用户${username}失败:`, err);
        throw err; // 非限流错误抛出处理
      }
    }
  }
}

基于AWS SDK v2的实现示例 #

const AWS = require('aws-sdk');
const cognito = new AWS.CognitoIdentityServiceProvider({
  region: '你的区域',
  maxRetries: 5,
  retryDelayOptions: { base: 1000 } // SDK自动处理指数退避
});

async function batchDeleteUsers(userPoolId, usernames) {
  for (const username of usernames) {
    try {
      await cognito.adminDeleteUser({
        UserPoolId: userPoolId,
        Username: username
      }).promise();
      console.log(`成功删除用户: ${username}`);
    } catch (err) {
      if (err.code === 'TooManyRequestsException') {
        // 手动添加随机抖动重试
        await new Promise(resolve => setTimeout(resolve, Math.random() * 2000 + 1000));
        await cognito.adminDeleteUser({ UserPoolId: userPoolId, Username: username }).promise();
      } else {
        console.error(`删除用户${username}失败:`, err);
        throw err;
      }
    }
  }
}

2. 分小批次并行处理 #

从根源上降低瞬间请求数，把25-30个用户拆成更小的批次（比如每10个一批），批次之间固定等待1-2秒，批次内并行处理用户。这样既提升处理速度，又减少触发限流的概率。

async function batchDeleteUsers(userPoolId, usernames, batchSize = 10, batchWait = 1000) {
  // 分割用户列表为小批次
  const batches = [];
  for (let i = 0; i < usernames.length; i += batchSize) {
    batches.push(usernames.slice(i, i + batchSize));
  }

  for (const batch of batches) {
    // 并行处理当前批次的用户
    await Promise.all(batch.map(async username => {
      try {
        await cognito.adminDeleteUser({ UserPoolId: userPoolId, Username: username }).promise();
        console.log(`成功删除用户: ${username}`);
      } catch (err) {
        if (err.code === 'TooManyRequestsException') {
          await new Promise(resolve => setTimeout(resolve, 2000));
          await cognito.adminDeleteUser({ UserPoolId: userPoolId, Username: username }).promise();
        } else {
          throw err;
        }
      }
    }));
    // 批次间等待
    await new Promise(resolve => setTimeout(resolve, batchWait));
  }
}

3. 结合监控动态调整策略 #

通过CloudWatch监控Cognito的ThrottledRequests指标，了解你的用户池实际限流阈值，再动态调整批次大小、重试次数和等待时间。比如如果发现15个请求就触发限流，就把批次大小降到10，或者增加批次间的等待时长。

最优组合方案 #

把指数退避重试和小批次并行处理结合起来：

• 用指数退避处理单个请求的限流，比固定等待更高效
• 分小批次并行处理，降低瞬间请求压力
• 加入随机抖动，避免多个重试请求同时发送导致二次限流

同时记得记录失败日志，避免用户删除遗漏，必要时添加告警通知。

内容的提问来源于stack exchange，提问作者Jayesh Dhandha