基于Serverless与DynamoDB：用户UUID转整数ID的更优方案探讨

针对UUID转模碰撞、Lambda性能下降的问题，以下是几个适配Serverless架构和DynamoDB的可行方案：

1. DynamoDB分片自增序列（无热点、高可靠） #

原理 #

通过分片拆分31位ID空间（0~2147483647），用DynamoDB原子操作维护分片内的自增ID，避免单点热点问题：

• 将ID空间分成N个分片（比如100个），每个分片负责一段连续范围：分片i的起始ID = i * (2147483648 / N)
• 用专门的序列表存储每个分片的当前最大ID，通过UpdateItem的ADD操作原子递增，确保线程安全

实现示例（Python boto3） #

import boto3
import random

dynamodb = boto3.resource('dynamodb')
seq_table = dynamodb.Table('id_sequences')

def get_unique_number_id():
    shard_id = random.randint(0, 99)  # 100个分片
    # 原子递增分片ID
    response = seq_table.update_item(
        Key={'shard_id': shard_id},
        UpdateExpression='ADD current_id :incr',
        ExpressionAttributeValues={':incr': 1},
        ReturnValues='UPDATED_NEW'
    )
    new_id = response['Attributes']['current_id']
    # 检查分片ID是否耗尽
    max_shard_id = (shard_id + 1) * (2147483648 // 100) - 1
    if new_id > max_shard_id:
        return get_unique_number_id()  # 切换分片重试
    return new_id

优缺点 #

• 优点：绝对唯一，原子操作性能稳定，无碰撞风险，适配高并发
• 缺点：需要维护额外的序列表，分片耗尽时需扩展分片逻辑

2. 适配31位限制的雪花算法（无中心依赖） #

原理 #

压缩标准雪花算法结构到31位，利用时间戳、机器ID、序列号保证分布式唯一性：

0（符号位） + 20位时间戳（毫秒级，约19年有效期） + 5位机器ID（32个节点） + 6位序列号（每秒最多64个ID）

• 时间戳：从自定义起始时间（如2024-01-01）开始的毫秒数，取低20位
• 机器ID：用Lambda容器ID的哈希值取模32，确保不同容器/区域的ID唯一
• 序列号：同一毫秒内同一容器内递增，超过上限则等待下一毫秒

实现示例 #

import time
import os
import hashlib

START_TIMESTAMP = 1704067200000  # 2024-01-01 00:00:00

def get_machine_id():
    # 从Lambda环境变量获取容器标识
    log_stream = os.getenv('AWS_LAMBDA_LOG_STREAM_NAME', '')
    hash_val = hashlib.md5(log_stream.encode()).hexdigest()
    return int(hash_val[:8], 16) % 32

class Snowflake31:
    def __init__(self):
        self.machine_id = get_machine_id()
        self.last_ts = -1
        self.sequence = 0

    def generate_id(self):
        current_ts = int(time.time() * 1000) - START_TIMESTAMP
        if current_ts > (1 << 20) - 1:
            raise Exception("时间戳超出范围")
        
        if current_ts == self.last_ts:
            self.sequence = (self.sequence + 1) % (1 << 6)
            if self.sequence == 0:
                # 等待下一毫秒
                while int(time.time() * 1000) - START_TIMESTAMP == current_ts:
                    time.sleep(0.001)
                current_ts = int(time.time() * 1000) - START_TIMESTAMP
                self.sequence = 0
        else:
            self.sequence = 0
        
        self.last_ts = current_ts
        # 拼接31位ID
        return (current_ts << 11) | (self.machine_id << 6) | self.sequence

优缺点 #

• 优点：无中心依赖，生成速度快，分布式唯一，适配Lambda容器复用场景
• 缺点：时间戳溢出后需调整起始时间，机器ID重复概率极低

3. UUIDv1时间戳截取+条件写入（低复杂度） #

原理 #

提取UUIDv1的60位时间戳部分，转换为整数后取模31位最大值，结合节点ID增加随机性，最后用DynamoDB条件写入确保唯一性：

1. 从UUIDv1中提取时间戳，取模2147483647生成候选ID
2. 调用PutItem并添加条件attribute_not_exists(number_id)
3. 写入失败（ID碰撞）则重试

实现示例 #

import uuid
import boto3

dynamodb = boto3.resource('dynamodb')
user_table = dynamodb.Table('users')

def generate_candidate_id():
    u = uuid.uuid1()
    # 提取UUIDv1的时间戳部分
    timestamp = (u.time_low << 32) | (u.time_mid << 16) | u.time_hi_version
    return timestamp % 2147483647

def save_user(user_uuid, user_data):
    while True:
        number_id = generate_candidate_id()
        try:
            user_table.put_item(
                Item={
                    'user_uuid': user_uuid,
                    'number_id': number_id,
                    **user_data
                },
                ConditionExpression='attribute_not_exists(number_id)'
            )
            return number_id
        except dynamodb.meta.client.exceptions.ConditionalCheckFailedException:
            # 碰撞重试
            continue

优缺点 #

• 优点：实现简单，无需额外表，碰撞概率极低
• 缺点：极端高并发下可能出现重试，用户量接近2亿时碰撞概率上升

4. 随机ID+全局二级索引（简化版） #

若用户量短期内不会接近2亿，可直接生成随机31位整数，给number_id字段创建唯一全局二级索引（GSI）：

• 生成随机ID后调用PutItem，若因GSI唯一约束失败则重试

该方案实现最简单，适合中小用户量场景，碰撞概率在100万用户以内可忽略。

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