四个关键边界#

读这套方案时，先抓住四个边界：

1. UDP 只负责提前通知：它不取数据，不承载主鉴权，不影响正式请求兜底。
2. 收益上限由时间窗决定：最多省掉 min(预热提前量, 服务端可复用计算耗时)，命中率低时收益会很快被白算成本吃掉。
3. 服务端复用比发包更难：cache / inflight / fallback 三态必须统一，否则 UDP 到了也可能白算。
4. 安全不能靠客户端静态密钥：预热包要用短期 ticket、时间窗、nonce 去重和限流控制资源消耗。

安全：防伪造与防重放#

UDP 是无连接的，任何人都可以伪造源 IP 发包。预热包虽然不返回数据，不是典型的反射放大攻击，但恶意构造的包可以触发服务端计算，形成计算型 DoS / 资源消耗攻击。

更稳的做法是使用服务端通过已鉴权 TLS 主链路下发的短期 prewarm ticket，而不是把长期静态密钥硬编码在 App 里。ticket 可以绑定设备、登录态、场景和 AB 范围，过期后自动失效；UDP 包里只放不可逆的用户标识或服务端派生的 opaque key，不放用户 token、手机号、原始 userId 等敏感字段。

多容器部署时，ticket 查询、nonce 去重和 per-ticket 预算必须走共享状态层，或按 ticket / fp 一致性路由到同一安全分片。否则同一个重放包可能在不同容器上分别通过本地 nonce cache，继续触发计算。

type PrewarmTicket = {
  id: string;
  secret: string;
  expiresAtSec: number;
};

type PrewarmPacket = {
  version: 1;
  fp: string;
  params: FeedParams;
  timestampSec: number;
  nonce: string;
  ticketId: string;
  signature: string;
};

function safeEqualSignature(expectedHex: string, actualHex: string): boolean {
  const expected = decodeHex(expectedHex);
  const actual = decodeHex(actualHex);
  if (!expected || !actual || expected.byteLength !== actual.byteLength) return false;
  return timingSafeEqual(expected, actual);
}

// 客户端构造预热包时
function buildPrewarmPayload(params: FeedParams, ticket: PrewarmTicket): PrewarmPacket {
  const prewarmParams = pickPrewarmParams(params);
  if (!prewarmParams) throw new Error('invalid prewarm params');

  const timestampSec = Math.floor(Date.now() / 1000);
  const nonce = createNonce();
  const fp = fingerprint(prewarmParams);
  const paramsHash = sha256(canonicalize(prewarmParams));
  const signature = hmacSha256(
    ticket.secret,
    ['v1', fp, paramsHash, String(timestampSec), nonce, ticket.id].join('\n'),
  );
  return {
    version: 1,
    fp,
    params: prewarmParams,
    timestampSec,
    nonce,
    ticketId: ticket.id,
    signature,
  };
}

// 服务端校验
function verifyPrewarmPacket(packet: PrewarmPacket): boolean {
  const nowSec = Math.floor(Date.now() / 1000);
  if (packet.version !== 1) return false;
  if (Math.abs(nowSec - packet.timestampSec) > TIME_WINDOW_SEC) return false;

  const ticket = loadPrewarmTicket(packet.ticketId);
  if (!ticket || ticket.expiresAtSec < nowSec) return false;

  const prewarmParams = pickPrewarmParams(packet.params);
  if (!prewarmParams) return false;
  if (fingerprint(prewarmParams) !== packet.fp) return false;

  const paramsHash = sha256(canonicalize(prewarmParams));
  const expected = hmacSha256(
    ticket.secret,
    [
      'v1',
      packet.fp,
      paramsHash,
      String(packet.timestampSec),
      packet.nonce,
      packet.ticketId,
    ].join('\n'),
  );
  if (!safeEqualSignature(expected, packet.signature)) return false;
  if (!ticketAllows(ticket, prewarmParams)) return false;

  // 必须是原子操作，例如 Redis SET nonceKey 1 NX EX TIME_WINDOW_SEC。
  // 放在签名校验之后，避免非法包污染 nonce cache。
  return consumeNonce(ticket.id, packet.nonce, TIME_WINDOW_SEC);
}

要点：

• 不放用户 token 和原始用户标识：UDP 明文传输，token 泄露风险高；用户标识也应使用不可逆或短期派生值。
• ticket 只从主链路下发：ticket / secret 必须来自已鉴权的 HTTPS / QUIC 主请求，不能通过 UDP 自举，也不能让客户端长期持有同一 secret。
• 不要依赖长期静态密钥：App 内置密钥可被逆向，只能作为低价值开关；真正控制资源消耗应依赖短期 ticket、限流和预算。
• 时间窗：通常 ±30s，拒绝过期包，防止录制重放。
• nonce 去重：同一个 ticket 下的 nonce 只能使用一次，避免窗口内重放；多容器下必须用原子 consumeNonce，例如 Redis SET NX EX，或一致性路由到同一安全分片。
• 常量时间比较：实际实现时先把 hex / base64 签名解码为 bytes，再用 timingSafeEqual；不要直接比较字符串。
• ticket scope 校验：签名通过后仍要检查 viewerKey / scene / abVersion 等参数是否落在 ticket 绑定范围内，防止合法 ticket 被拿来签任意预热参数。
• 参数类型收窄：白名单字段只允许标量或标量数组；对象、嵌套结构、NaN、Infinity 直接拒绝预热，不要用 String() 降级成 "[object Object]"。
• 限流：即使签名合法，单 ticket / 单 fp / 单设备派生 key 都要有 QPS 和并发上限；单 IP 限流只能作为辅助，因为 UDP 源地址可能被伪造，也可能被 NAT 聚合放大误伤。
• 先拒绝再计算：服务端应先做包长、版本、ticket、时间窗、nonce、HMAC、fp 重算等廉价校验，再进入推荐计算队列。

核心逻辑（简化版）#

整个方案的服务端核心可以压缩成这几行——先查 cache，再查 inflight（正在计算的 Promise），都没有就自己算：

async function handleFeedRequest(fp: string, params: FeedParams) {
  const cached = cache.get(fp);
  if (cached !== undefined && canUsePrewarmArtifact(params, cached)) {
    return buildFeedFromArtifact(params, cached);
  }

  const pending = inflight.get(fp);
  if (pending) {
    const result = await waitFor(pending, MAX_WAIT_MS);
    if (result.ok && canUsePrewarmArtifact(params, result.value)) {
      return buildFeedFromArtifact(params, result.value);
    }
    return computeFinalFeed(params);
  }

  return computeMainPathAndPublishReusableArtifact(fp, params);
}

UDP 预热做的事情就是：在 HTTP 到达之前，提前把结果写进 cache 或把计算注册到 inflight。

完整实现#

下面是一个压缩版 TypeScript 示例，展示核心链路：规范化参数、生成 fp、UDP 触发预热、HTTP 复用 cache / inflight，等不到就兜底计算。

type FeedParams = Record<string, unknown>;
type Feed = unknown;
type PrewarmArtifact = unknown;
type WaitResult<T> = { ok: true; value: T } | { ok: false };
type PrewarmTicket = { id: string; secret: string; expiresAtSec: number };
type PrewarmPacket = {
  version: 1;
  fp: string;
  params: FeedParams;
  timestampSec: number;
  nonce: string;
  ticketId: string;
  signature: string;
};

// viewerKey 是服务端派生的 opaque key，不是原始 userId。
const PREWARM_FIELDS = ['viewerKey', 'scene', 'cursor', 'abVersion', 'lang'] as const;
const LOWERCASE_FIELDS = new Set(['scene', 'lang']);
type PrewarmScalar = string | number | boolean;
type PrewarmParamValue = PrewarmScalar | PrewarmScalar[];
type PrewarmParams = Partial<Record<string, PrewarmParamValue>>;
const CACHE_TTL_MS = 3000;
const MAX_WAIT_MS = 30; // 经验起点，应根据 P50 服务端计算耗时和主请求 SLA 调整（建议范围 10~50ms）
const PREWARM_COMPUTE_TIMEOUT_MS = 500;
const MAX_PREWARM_PACKET_BYTES = 1200;
const MAX_FINGERPRINT_LENGTH = 128;
const MAX_TICKET_ID_LENGTH = 128;
const MAX_NONCE_LENGTH = 64;
const MAX_SIGNATURE_LENGTH = 128;

// 单实例示例：多容器部署时，应替换为 Redis 等共享 cache/lock，
// 或确保 UDP / HTTP 按 fp 一致性路由到同一容器。
const cache = new TTLMap<string, PrewarmArtifact>();
const inflight = new Map<string, Promise<PrewarmArtifact>>();

declare function xxhash64(input: string): string;
declare function sleep(ms: number): Promise<void>;
declare function getCurrentPrewarmTicket(): PrewarmTicket | undefined;
declare function buildPrewarmPayload(params: FeedParams, ticket: PrewarmTicket): PrewarmPacket;
declare function verifyPrewarmPacket(packet: PrewarmPacket): boolean;
declare function decodePrewarm(msg: Uint8Array): unknown;
declare function computePrewarmArtifact(
  params: PrewarmParams,
  signal?: AbortSignal,
): Promise<PrewarmArtifact>;
declare function computeFinalFeed(params: FeedParams): Promise<Feed>;
declare function buildFeedFromArtifact(
  params: FeedParams,
  artifact: PrewarmArtifact,
): Promise<Feed>;

function isRecord(value: unknown): value is Record<string, unknown> {
  return typeof value === 'object' && value !== null && !Array.isArray(value);
}

function isPrewarmPacket(value: unknown): value is PrewarmPacket {
  if (!isRecord(value)) return false;
  if (value.version !== 1) return false;
  if (typeof value.fp !== 'string' || value.fp.length > MAX_FINGERPRINT_LENGTH) {
    return false;
  }
  if (!isRecord(value.params)) return false;
  if (!Number.isInteger(value.timestampSec)) return false;
  if (typeof value.nonce !== 'string' || value.nonce.length > MAX_NONCE_LENGTH) {
    return false;
  }
  if (typeof value.ticketId !== 'string' || value.ticketId.length > MAX_TICKET_ID_LENGTH) {
    return false;
  }
  if (typeof value.signature !== 'string' || value.signature.length > MAX_SIGNATURE_LENGTH) {
    return false;
  }
  return (
    value.fp.length > 0 &&
    value.nonce.length > 0 &&
    value.ticketId.length > 0 &&
    value.signature.length > 0
  );
}

function isPrewarmScalar(value: unknown): value is PrewarmScalar {
  if (typeof value === 'string') return value.trim() !== '';
  if (typeof value === 'number') return Number.isFinite(value);
  return typeof value === 'boolean';
}

function isPrewarmParamValue(value: unknown): value is PrewarmParamValue {
  if (isPrewarmScalar(value)) return true;
  return Array.isArray(value) && value.length > 0 && value.every(isPrewarmScalar);
}

function pickPrewarmParams(params: FeedParams): PrewarmParams | undefined {
  const picked: PrewarmParams = {};
  for (const key of PREWARM_FIELDS) {
    const value = params[key];
    if (value === undefined || value === null || value === '') continue;
    if (!isPrewarmParamValue(value)) return undefined;
    picked[key] = value;
  }

  // 实际项目应在这里检查 viewerKey / scene / AB 等业务必填字段。
  return Object.keys(picked).length > 0 ? picked : undefined;
}

function normalizePrewarmScalar(key: string, value: PrewarmScalar): string {
  if (typeof value === 'number') {
    return Number.isInteger(value) ? String(value) : value.toFixed(3);
  }
  if (typeof value === 'boolean') {
    return value ? '1' : '0';
  }

  const text = value.trim();
  return LOWERCASE_FIELDS.has(key) ? text.toLowerCase() : text;
}

function canonicalize(params: PrewarmParams): string {
  const normalized: Record<string, string> = {};

  for (const key of PREWARM_FIELDS) {
    const value = params[key];
    if (value === undefined) continue;

    if (Array.isArray(value)) {
      normalized[key] = JSON.stringify(
        value.map((item) => normalizePrewarmScalar(key, item)),
      );
    } else {
      normalized[key] = normalizePrewarmScalar(key, value);
    }
  }

  return PREWARM_FIELDS
    .filter((key) => key in normalized)
    .map((key) => `${key}=${encodeURIComponent(normalized[key])}`)
    .join('&');
}

function fingerprint(params: PrewarmParams): string {
  // 生产环境建议用 SHA-256 截断前 16 字节（128-bit）；xxhash64 仅适合内部低安全场景。
  return xxhash64(canonicalize(params));
}

function canUsePrewarmArtifact(
  _params: FeedParams,
  _artifact: PrewarmArtifact,
): boolean {
  // 占位实现，生产环境必须替换。
  // 需校验：用户身份（viewerKey 是否匹配）、AB 版本、过滤策略、freshness、近期用户行为等。
  // 任何一项不通过都应返回 false，让 HTTP 走正式计算。
  throw new Error('canUsePrewarmArtifact must be implemented before production use');
}

function canAttemptPrewarm(_params: FeedParams): boolean {
  // 实际落地时，客户端可基于低电量、省流量、后台判断；
  // 服务端可基于场景、AB、强一致要求或参数完整性判断。
  return true;
}

async function waitFor<T>(task: Promise<T>, ms: number): Promise<WaitResult<T>> {
  return Promise.race([
    task.then(
      (value) => ({ ok: true as const, value }),
      () => ({ ok: false as const }),
    ),
    sleep(ms).then(() => ({ ok: false as const })),
  ]);
}

async function runAbortablePrewarm<T>(
  run: (signal: AbortSignal) => Promise<T>,
  ms: number,
): Promise<T> {
  const controller = new AbortController();
  let timeoutId: ReturnType<typeof setTimeout> | undefined;
  const timeout = new Promise<never>((_, reject) => {
    timeoutId = setTimeout(() => {
      controller.abort();
      reject(new Error('prewarm compute timeout'));
    }, ms);
  });

  try {
    // computePrewarmArtifact 必须把 signal 继续传给可取消的 RPC / 队列任务；
    // 否则这里只能让调用方返回，不能真正停止下游计算。
    return await Promise.race([run(controller.signal), timeout]);
  } finally {
    if (timeoutId !== undefined) clearTimeout(timeoutId);
  }
}

function getOrComputePrewarmArtifact(
  fp: string,
  params: PrewarmParams,
  timeoutMs?: number,
): Promise<PrewarmArtifact> {
  const cached = cache.get(fp);
  if (cached !== undefined) return Promise.resolve(cached);

  const pending = inflight.get(fp);
  if (pending) return pending;

  const task = Promise.resolve()
    .then(() =>
      timeoutMs === undefined
        ? computePrewarmArtifact(params)
        : runAbortablePrewarm(
            (signal) => computePrewarmArtifact(params, signal),
            timeoutMs,
          ),
    )
    .then((artifact) => {
      cache.set(fp, artifact, { ttlMs: CACHE_TTL_MS });
      return artifact;
    })
    .finally(() => {
      if (inflight.get(fp) === task) inflight.delete(fp);
    });

  inflight.set(fp, task);
  return task;
}

async function computeMainPathAndPublishReusableArtifact(
  fp: string,
  params: FeedParams,
): Promise<Feed> {
  const prewarmParams = pickPrewarmParams(params);
  if (!prewarmParams) return computeFinalFeed(params);

  try {
    const artifact = await getOrComputePrewarmArtifact(fp, prewarmParams);
    if (canUsePrewarmArtifact(params, artifact)) {
      return buildFeedFromArtifact(params, artifact);
    }
  } catch {
    // 预热 artifact 失败不能影响主请求，继续走正式计算。
  }

  return computeFinalFeed(params);
}

客户端发送时，只发最小参数、fp 和短期 ticket 签名：

async function fetchFeedWithPrewarm(params: FeedParams): Promise<Feed> {
  const ticket = getCurrentPrewarmTicket();

  if (ticket && canAttemptPrewarm(params)) {
    try {
      const sent = udpClient.send(encodePrewarm(buildPrewarmPayload(params, ticket)));
      void Promise.resolve(sent).catch(() => {});
    } catch {
      // best-effort：UDP 发送失败不能影响正式 Feed 请求。
    }
  }

  return httpClient.get('/feed', { params });
}

服务端 UDP 和 HTTP 共享同一套 fp -> cache / inflight：

udpServer.on('message', (msg) => {
  if (msg.byteLength > MAX_PREWARM_PACKET_BYTES) return;

  let packet: unknown;
  try {
    packet = decodePrewarm(msg);
  } catch {
    return;
  }

  if (!isPrewarmPacket(packet)) return;
  if (!verifyPrewarmPacket(packet)) return;

  const prewarmParams = pickPrewarmParams(packet.params);
  if (!prewarmParams) return;

  getOrComputePrewarmArtifact(
    packet.fp,
    prewarmParams,
    PREWARM_COMPUTE_TIMEOUT_MS,
  ).catch(() => {});
});

http.get('/feed', async (req) => {
  if (!canAttemptPrewarm(req.params)) {
    return computeFinalFeed(req.params);
  }

  const prewarmParams = pickPrewarmParams(req.params);
  if (!prewarmParams) {
    return computeFinalFeed(req.params);
  }

  const fp = fingerprint(prewarmParams);

  const cached = cache.get(fp);
  if (cached !== undefined && canUsePrewarmArtifact(req.params, cached)) {
    return buildFeedFromArtifact(req.params, cached);
  }

  const pending = inflight.get(fp);
  if (pending) {
    const warmed = await waitFor(pending, MAX_WAIT_MS);
    if (warmed.ok && canUsePrewarmArtifact(req.params, warmed.value)) {
      return buildFeedFromArtifact(req.params, warmed.value);
    }
    return computeFinalFeed(req.params);
  }

  return computeMainPathAndPublishReusableArtifact(fp, req.params);
});

上面假设 computePrewarmArtifact() 产出的是主链路可复用的昂贵中间结果，buildFeedFromArtifact() 能在此基础上完成最终响应。

HTTP 在 cache miss 且无 inflight 时，通过 computeMainPathAndPublishReusableArtifact() 成为 owner，注册同一个可复用计算。如果已有 inflight 但短等失败、计算报错或最终校验不通过，就不再重新 join 同一个 pending，而是透明回退 computeFinalFeed()。

超时控制上，UDP 预热有独立的 PREWARM_COMPUTE_TIMEOUT_MS，预热计算必须主动响应 AbortSignal 或由队列 / worker budget 兜底取消。HTTP 主请求应由自己的 deadline / cancellation 控制，不要先等预热超时再重复算主链路。

如果主链路无法从中间 artifact 构建最终响应，就不要为了预热先算 artifact 再算正式结果。此时应把 inflight 改成更轻量的 owner / singleflight 标记，让 UDP 后到时退出，同时 HTTP 直接走正式计算。