Skip to content

AI 基础设施

Kinference 详解:懂你提示词的控制平面

Kinference 如何把每个 LLM 请求发给预测首 token 时间最短的副本,附 GKE 上与普通 Kubernetes Service 的基准测试对比。

Ivan Porta

Founder & Principal Engineer

16 分钟阅读
#kinference#inference#vllm#kubernetes#platform-engineering
Kinference 详解:懂你提示词的控制平面

对 LLM 推理来说,轮询这类标准的负载均衡方法抓不住要害。关键在于请求由哪个副本来处理。如果一条 8,000 token 的提示词被发到 KV 缓存已预热的副本上,首个 token 大约十分之一秒就会出现。如果落到冷副本上,就可能要一秒以上。

在 AI 优化型 IaaS 的支出中,推理如今已经超过了训练。在运行生成式 AI 模型的组织中,约 66% 把部分或全部推理工作负载放在 Kubernetes 上运行。Datadog 的 State of AI Engineering 报告指出,69% 的输入 token 是系统提示词,但只有 28% 的 LLM 调用用到了缓存。

单靠 Kubernetes 解决不了这个问题。Service 不知道提示词是什么,而 kube-proxy 是随机选择后端的,如果使用 IPVS 模式,则按顺序选择。有 3 个副本时,一个后续请求大约三次里只有一次能命中自己的缓存。

路由只是挑战的一部分。同一批 GPU 要处理来自不同团队的编程助手、批处理作业和智能体。总得有人来决定:队列变长时谁来等待,哪些请求可以改用更小的模型,哪些请求应该发往云提供商。这些选择必须针对每一个请求、在分派之前做出,而且不需要一支专家团队来管理。这正是 Kinference 派上用场的地方。

Kinference 到底是什么?

Kinference 是一个面向 Kubernetes 上 LLM 推理的开源控制平面,由 Buoyant 于 2026 年 11 月 4 日宣布推出。它不直接处理流量,而是由网关向 Kinference 询问每个请求该发往哪里,Kinference 则回以预计能最快返回首个 token 的那个副本。它利用来自 vLLM、SGLang 等服务引擎的指标和 KV 缓存事件来预测首 token 时间(TTFT),并应用你的策略做出决定。

Kinference 的资源

Kinference 围绕四个主要的 CRD 构建:

  • InferenceWorkerSet 定义一组完全相同的引擎副本、它们所在的位置,以及 Kinference 如何监控它们。
  • InferenceProvider 指定一个集群外的目标,在本地 Worker 处理不了所有请求时使用。
  • InferencePolicy 包含为每个请求在各个目标之间做选择的规则。
  • InferencePool 是路由所指向的对象。它列出请求可能去往的目标,以及在这些目标中做选择的策略。

下面逐一来看,重点关注最重要的字段。

InferenceWorkerSet

InferenceWorkerSet 包装的是一组完全相同的引擎 Pod 前面的 Service,这些 Pod 称为 Worker。其他字段告诉 Kinference 如何监控这些 Worker,这样它就能看到一条提示词有多少已经在每个 Worker 的 KV 缓存里,并预测该 Worker 的 TTFT。主要字段如下:

  • serviceRef:引擎 Pod 前面的 Service。Kinference 通过它找到这些 Pod。
  • kvEvents:引擎通过 ZeroMQ 发布 KV 缓存事件的位置。这个配置块是可选的,但没有它,Kinference 就看不到缓存。这样一来,预测 TTFT 的准确度会大幅下降,Kinference 只会根据负载来路由。
  • kvBlockSize:这些事件中每个块所含的 token 数。它必须与引擎发布的一致。
  • profile:调优用的 profile。它决定 Kinference 如何对提示词分词,在预测中如何为一个未缓存的块或一个排队中的请求计价,以及如何做出最终决定。
  • metricsPort:引擎提供 Prometheus 指标的端口,Kinference 从这些指标中读取每个 Worker 的负载。
  • modelDiscovery:Kinference 如何得知 Worker 提供哪些模型。在 Endpoint 模式(默认)下,它会定期查询每个 Worker 的 /v1/models 端点。在 Static 模式下,它只依赖 models 列表。
  • models:请求模型时可以使用的别名,例如 chat。
apiVersion: kinference.buoyant.io/v1alpha1
kind: InferenceWorkerSet
metadata:
  name: qwen-7b
  namespace: llm
spec:
  profile: default
  kvBlockSize: 16
  serviceRef:
    name: qwen-7b
    port: http
  kvEvents:
    port: kv-pub
  metricsPort: http
  modelDiscovery:
    mode: Endpoint
    interval: 30s
  models:
  - name: Qwen/Qwen2.5-7B-Instruct
    aliases:
    - chat

InferenceProvider

InferenceProvider 定义一个集群外的目标,比如 Claude 或 DeepSeek 这样的托管 API。它通常用在这样的策略中:把溢出的请求发往云端,而不是让它们在本地排队。

这个资源只包含 Kinference 选择提供商所需的信息:传输格式(api)、要调用的路径,以及模型,其中包括各模型的 contextWindow 和它们与本地模型共用的别名。URL 和 API 密钥保存在 GatewayBackend 中,这是 Buoyant Gateway 的一种资源,backendRef 指向它。这种设置把职责分开了:Kinference 返回后端的名称,网关负责解析这个名称、建立连接并添加凭据。Kinference 从不联系厂商,也从不读取密钥。这里的网关可以是任何实现了 Kinference API 的网关。目前 Buoyant Gateway 是唯一的一个,所以这里的后端是 GatewayBackend。

apiVersion: gateway.linkerd.io/v1alpha1
kind: GatewayBackend
metadata:
  name: cloud-fallback
  namespace: llm
spec:
  baseURL: https://api.deepseek.com
  auth:
    type: ApiKey
    apiKey:
      secretRef:
        name: deepseek-api-key
        key: api-key
---
apiVersion: kinference.buoyant.io/v1alpha1
kind: InferenceProvider
metadata:
  name: cloud-fallback
  namespace: llm
  labels:
    tier: fallback
spec:
  backendRef:
    group: gateway.linkerd.io
    kind: GatewayBackend
    name: cloud-fallback
    namespace: llm
  api: OpenAI
  path: /chat/completions
  models:
  - name: deepseek-flash
    aliases:
    - chat
    contextWindow: 1000000

InferencePolicy

InferencePolicy 决定由池中的哪个目标来处理请求。它使用一个有序的规则列表,第一条匹配的规则生效。规则可以匹配所请求的模型、租户(由网关从你选定的请求头中读取),以及提示词和回答的大小。接着,路由最多经过四个配置块:

  • consider:这个配置块构建候选集,默认情况下,候选集包含池中每个目标上所请求的模型。你可以把候选集收窄到本地 Worker 或提供商(type)、特定的目标(backends),或者某些模型。例如,你可以把敏感的提示词留在集群内部,第一条规则对 sandbox 租户就是这么做的。如果各个组带有权重,Kinference 会根据这些权重为每个请求选出一个组,只有这个组提供候选项。第二条规则的作用类似金丝雀:每十个请求中有九个只使用本地 Worker,第十个还可以使用托管模型。

  • exclude:这个配置块根据候选项的状态把它们移除,例如排队中的提示词数量(queuedPrompts)、最近 30 秒内平均的 KV 缓存填充程度(kvCacheUsage)、预测 TTFT(predictedTTFT)和上下文窗口(contextWindow)。你可以用 if 条件把排除限定在某些请求上。

  • select:这个配置块把剩下的候选项分层排序。第一个有候选项的层会被选中。每一层按 PredictedTTFT(针对本地 Worker)、EstimatedTTFT(它借助网关观测到的 TTFT 把提供商也纳入进来)或固定顺序,为层内的候选项排序。tieBreak 用来打破平局:PreferLocal 优先选本地 Worker 而不是提供商,Random 则随机选择。如果没有 tieBreak,Kinference 按顺序选择第一个候选项。

  • onEmpty:这个配置块决定没有候选项剩下时会发生什么。默认的 Reject 会拒绝请求。FallThrough 则转到下一条匹配的规则。

在这个示例中,第三条规则只允许批处理作业和长请求使用有足够容量的 Worker。最后一条规则在本地处理其余所有请求,只有在没有可用的本地 Worker 时才使用提供商。如果一个请求不匹配任何规则,它就遵循 unmatched 策略,默认情况下,这个策略会把请求发给最快的本地 Worker。

apiVersion: kinference.buoyant.io/v1alpha1
kind: InferencePolicy
metadata:
  name: local-first
  namespace: llm
spec:
  unmatched: ServeLocal
  rules:
  - name: sandbox-stays-local
    matches:
    - model: chat
      tenant: sandbox
    route:
      consider:
      - name: local-qwen
        type: Local
        models:
          names:
          - Qwen/Qwen2.5-7B-Instruct
      select:
      - type: Local
        minimize: PredictedTTFT
      tieBreak:
      - Random
      onEmpty: Reject
  - name: beta-compares-local-and-hosted
    matches:
    - model: chat
      tenant:
      - beta
      - staff
    route:
      consider:
      - name: local-only
        weight: 90
        type: Local
        models:
          fromRequest: true
      - name: local-or-hosted
        weight: 10
        models:
          fromRequest: true
        backends:
          names:
          - qwen-7b
          - cloud-fallback
      exclude:
      - name: no-hosted-model-for-long-answers
        if:
          maxTokens:
            greaterThan: 4000
        drop:
          model:
            name: deepseek-flash
      - name: hosted-is-slow
        drop:
          backend:
            type: Provider
            observedTTFTP95:
              greaterThan: 5s
      select:
      - minimize: EstimatedTTFT
      tieBreak:
      - PreferLocal
      - Random
      onEmpty: FallThrough
  - name: heavy-requests-need-headroom
    matches:
    - qos:
      - batch
      - deferrable
    - inputTokens:
        greaterThan: 16000
    - maxTokens:
        greaterThan: 4000
    route:
      exclude:
      - name: queue-too-long
        drop:
          backend:
            type: Local
          queuedPrompts:
            greaterThan: 2
      - name: kv-cache-too-full
        drop:
          backend:
            type: Local
          kvCacheUsage:
            greaterThan: 0.7
      - name: cold-prompt-on-a-filling-cache
        drop:
          backend:
            type: Local
          kvCacheUsage:
            greaterThan: 0.5
          prefixCacheHitRatio:
            lessThan: 0.2
      select:
      - type: Local
        minimize: PredictedTTFT
  - name: everything-else
    route:
      exclude:
      - name: first-token-too-slow
        drop:
          backend:
            type: Local
          predictedTTFT:
            greaterThan: 30s
      - name: context-window-too-small
        drop:
          contextWindow:
            lessThan: 32768
      - name: worker-set-down-to-one-pod
        drop:
          backend:
            type: Local
            readyEndpoints:
              lessThan: 2
      - name: sandbox-never-leaves-the-cluster
        if:
          tenant: sandbox
        drop:
          backend:
            name: cloud-fallback
      select:
      - type: Local
        minimize: PredictedTTFT
      - backends:
          type: Provider
          selector:
            matchLabels:
              tier: fallback
        order:
        - cloud-fallback

InferencePool

InferencePool 把另外三个组件组合到一起。HTTPRoute 把它用作自己的后端。InferencePool 按名称或标签列出请求可能去往的目标,并指定在这些目标中做选择的策略。如果没有 policyRef,每个请求都会被发给预测 TTFT 最低的本地 Worker,请求不会离开集群。

apiVersion: kinference.buoyant.io/v1alpha1
kind: InferencePool
metadata:
  name: chat
  namespace: llm
spec:
  destinations:
  - group: kinference.buoyant.io
    kind: InferenceWorkerSet
    name: qwen-7b
    namespace: llm
  - group: kinference.buoyant.io
    kind: InferenceProvider
    namespace: llm
    selector:
      matchLabels:
        tier: fallback
  policyRef:
    group: kinference.buoyant.io
    kind: InferencePolicy
    name: local-first

Kinference 如何工作

Kinference 的大部分工作在任何请求到来之前就已完成。我们先看它在后台做了什么。然后,我们跟随一个请求,从它到来,一直看到 Kinference 如何预测它该去哪里。

Kinference 在带外做的事

在请求流之外,Kinference 监听它的四个 CRD,以及它们背后的 Services 和 EndpointSlices。它在内存中维护着一份整个机群的最新视图。

对每个 InferenceWorkerSet,Kinference 通过 serviceRef 找到 Service 背后已就绪的 Pod。每个 Pod 就是一个 Worker。Kinference 从每个 Worker 收集 Prometheus 指标,跟踪有多少请求正在运行、有多少在等待,以及 KV 缓存有多满。它还会查询 Worker 的 /v1/models 端点,了解这个 Worker 提供哪些模型。如果 Worker 集配置了 kvEvents,Kinference 就会订阅 Worker 的 ZeroMQ 套接字,每当有块存入 Worker 的 KV 缓存或从中移除时,它都会收到一个事件。Kinference 借助这些事件建立一个索引,记录哪些块在哪个 Worker 上,这个索引之后会帮助它区分热副本和冷副本。

注意:正如我们在《从 Ingress 到推理网关》中看到的,vLLM 默认不发布这些事件,因此引擎启动时必须开启 KV 事件发布。kvEvents 只是告诉 Kinference 到哪里去监听。

与此同时,Kinference 把每个 InferencePool 转换成一份目标列表,并把这个池使用的 InferencePolicy 准备好。这样,请求一到,规则就可以直接使用。

当请求到来时

一切都从一条路由开始。网关把请求匹配到一条 HTTPRoute,但这一次后端是 InferencePool,而不是 Service。因此,网关不自己选择端点,而是请 Kinference 来选。

apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata:
  name: chat
  namespace: llm
spec:
  parentRefs:
  - name: kinference-gw
    sectionName: http
  rules:
  - matches:
    - path:
        type: PathPrefix
        value: /v1/chat/completions
    backendRefs:
    - group: kinference.buoyant.io
      kind: InferencePool
      name: chat

此后,一次聊天补全会经过七个步骤:

  1. 接收请求。 客户端以流式方式传入请求体,并指明路由中的 InferencePool。Kinference 把请求体保存在内存中,默认每个请求最多 8 MiB,总计最多 256 MiB。如果请求太大,Kinference 会拒绝它。
  2. 查找模型。 Kinference 从请求体中读取 model 字段,并确定哪些目标可以提供这个模型。
  3. 测量缓存。 Kinference 对提示词分词,把 token 切分成大小为 kvBlockSize 的块,按与引擎相同的方式对这些块做哈希,然后在自己的索引中查找它们。
  4. 应用策略。 如果没有策略,任何提供该模型的 Worker 都是候选项。如果有策略,第一条匹配的规则会筛选候选项并排序。被选中的候选项甚至可能是另一个模型,或者是集群外的提供商。
  5. 预测并确定。 接着,Kinference 为每个候选项预测一个 TTFT,并选择值最低的那个。它把这个请求标记为在该 Worker 上进行中,这样即使引擎那边还没有更新,下一次预测也会把它算进去。
  6. 返回请求。 Kinference 回以端点和请求体。如果模型变了,它会先改写请求体,再把它发回。
  7. 上报首个和最后一个 token。 客户端上报它为首个 token 观测到的 TTFT,并在结束时上报包括已缓存 token 在内的 token 总数。Kinference 用这些信息更新它对进行中请求的跟踪,并查看自己的预测有多准。对提供商来说,这些上报是 Kinference 跟踪其健康状况和速度的唯一途径。

预测 TTFT

默认情况下,一个 Worker 的预测 TTFT 由四部分组成:

  • 基础项(base_ms)。 每个请求都要付出的固定开销。
  • 队列(queue_ms_per_entry)。 这是 Kinference 已经发给该 Worker、目前仍排在当前请求前面的预填充(prefill)工作,并按每个请求此刻应有的进度做了调整。Kinference 用下面的两个预填充字段为这部分工作计价,而对每个不是由它自己发出的等待中请求,则计入 queue_ms_per_entry。
  • 预填充(attention_uncached_block_ms、attention_uncached_per_every_block_ms)。 这是 Worker 尚未缓存的那些块的代价。第一个字段是每个未缓存块的代价。第二个字段是每个未缓存块针对提示词中每一个块的代价,因为每个新 token 都要对整条提示词做注意力计算。
  • 解码争用(forward_pass_ms)。 这是为该 Worker 上每个已经在生成的请求计入的一小笔代价。

另外还有两项惩罚,在 chart 中都设为零:

  • KV 缓存压力(cache_pressure_penalty_ms)。 这项代价随着 Worker 的 KV 缓存逐渐填满而增加。
  • 一两个运行中的请求(q_running_penalty_peak_ms)。 这是针对这样一种 Worker 的代价:它已经忙到新的预填充要去争抢 GPU,却还没有忙到让这次预填充能并入正在运行的批次。

Kinference 不会自动学习这些系数。你需要针对自己的模型和硬件对它们调优,而且把它们调对很重要。系统繁忙时,Kinference 会把热 Worker 队列中的等待时间与空闲的冷 Worker 上的预填充时间作比较。如果系数不对,它就可能做出错误的选择。此外,任何对 predictedTTFT 设置阈值的策略规则,都依赖于这个数字是对的。下面的基准测试展示了默认值与我们的硬件相比结果如何。

这些系数存放在一个具名的 profile 里,由 Worker 集来引用。下面是 chart 的 values 中的 default profile:

profiles:
  default:
    predictor:
      base_ms: 400.0
      queue_ms_per_entry: 0.2
      attention_uncached_block_ms: 2.3
      attention_uncached_per_every_block_ms: 0.03
      cache_pressure_penalty_ms: 0.0
      q_running_penalty_peak_ms: 0
      forward_pass_ms: 5
      expected_overlap_alpha: 1.0
    picker:
      top_k_min: 1
      top_k_fraction: 0.0
      inflight_tracking: true
      replication_threshold_pct: 10
      replication_warm_target: 2
      tie_tolerance_ms: 0
    tokenize:
      mode: render

另有两项改进用来应对突发流量,在突发流量下,单靠 KV 索引会误导预测:

  • 仍在计算中的前缀已经算数。 引擎只有在算完一个块之后才会发布它。如果十个带有同一条新系统提示词的请求在一秒内到达,索引会显示没有任何 Worker 拥有这个前缀,尽管已经有一个 Worker 正在计算它。为此,Kinference 自己记录着它刚刚发给每个 Worker 的内容。前缀中此刻应该已经算完的部分按已缓存计,其余部分按队列计。随着预填充的推进,这个 Worker 会成为后续请求的最佳选择,无需等待引擎的事件。
  • 只在单个 Worker 上的前缀会得到第二份拷贝。 如果只有一个 Worker 拥有某个前缀,所有带这个前缀的请求都会去往这个 Worker,使它成为热点。为了避免这种情况,当某个冷 Worker 的预测 TTFT 与热 Worker 的预测 TTFT 相差在 10% 以内(replication_threshold_pct)时,Kinference 会有意选择这个冷 Worker。这通常发生在热 Worker 繁忙或提示词较短的时候。第一个请求承担预填充的代价,此后两个 Worker 都拥有这个前缀(replication_warm_target)。

缓存感知路由值多少

为了衡量这个差异,我们在一个 GKE 集群上让同样的请求分别通过两套配置:一个普通的 Service,以及使用出厂默认 profile 的 Kinference。稍后,我们会用一个针对这个模型和 GPU 调优后的 profile 重复这项基准测试。集群使用一个带 NVIDIA RTX PRO 6000 的节点,HAMi 把这张卡的 96 GB 显存分给 3 个运行在 vLLM 0.31 上的 Qwen2.5-7B-Instruct 副本,每个副本得到 28,000 MiB。这让每个副本拥有约 166,000 个 token 的 KV 缓存。只用一张卡可以把成本压低,但由于 HAMi 限制的是显存而不是算力,一个副本上的冷预填充也会拖慢另外两个副本。

负载生成器发送三种流量,我们称之为工作负载。前两种会重复提示词的一部分,所以 KV 缓存能帮上忙,第三种则什么都不重复:

  • 共享前缀。 38 条各 8,000 token 的系统提示词,每条被访问 6 次,每次带一个新问题。它们合计的 token 数是单个副本的 KV 缓存所能容纳的 1.8 倍,所以没有哪个副本能独自让所有这些提示词保持热状态,但整个机群可以。
  • 多轮对话。 36 段对话,每段 8 轮,每一轮都带上完整的历史。
  • 对照组。 大小相同,但每条提示词都是唯一的,所以没有任何内容可以复用。

每个工作负载都从冷的机群开始,并保持 6 个请求同时运行。为了确保比较公平,负载生成器为每个请求打开一个新连接,这样 kube-proxy 每次都会选择一个副本。如果使用 keep-alive,每个客户端就会固定在一个副本上,让 Service 看起来比实际更好。

我们在客户端测量那些可能用到缓存的请求的 TTFT:对同一前缀在首次之后的每次访问,以及第一轮之后的每一轮。我们把基准测试运行了 5 次,每次都使用新的提示词,并由不同的入口先开始。下面的结果是 5 次运行各自中位数的平均值,每一行先列 Service,后列 Kinference:

共享前缀889 ms128 ms
多轮对话148 ms94 ms
对照组1.17 s1.23 s

下图展示了差异的来源:每个中位数旁边是来自缓存的提示词 token 占比,以及 5 次运行之间的波动范围。

预测有多准?

为了验证预测,Kinference 为每次选择记录了两个时间:它为所选副本预测的 TTFT,以及客户端实际看到的 TTFT。如果副本已经拥有提示词的至少 90%,这次选择就算作热选择;如果完全没有,就算作冷选择。

使用默认 profile 时,预测正确地把冷副本排在比热副本慢得多的位置。但预测出的时间有偏差:全部 3,720 次预测都偏高,偏高倍数的中位数为 7。下面是 5 次运行的中位数,每一行先列观测到的时间,后列预测的时间:

2,209 次热选择98 ms557 ms
1,511 次冷选择1.2 s9.1 s

三次单独的选择可以说明这个数字是怎么构成的。同样先列观测到的时间,后列预测值,并把预测值拆成各项:

vllm-0 上的热选择:500 个块中有 495 个已缓存94 ms400 基础 + 86 预填充 + 5 解码 = 491 ms
vllm-1 上的冷选择:498 个块中有 0 个已缓存1,203 ms400 基础 + 8,586 预填充 + 10 解码 = 8,996 ms
vllm-2 上的冷选择,且需排队:502 个块中有 0 个已缓存,前面还有一条冷提示词1,723 ms400 基础 + 8,047 队列 + 8,715 预填充 + 15 解码 = 17,177 ms

问题出在 profile 上。默认系数是基于另一个机群得出的,而不是基于 RTX PRO 6000 上的 7B 模型。例如,基础项是 400 ms,是热请求在这里实际耗时的四倍。

这个误差是否要紧,取决于负载。Kinference 只在候选项之间相互比较。队列为空时,预填充时间是 Worker 之间唯一的差别,所以即使预测不准,顺序也是对的,Kinference 仍然会做出正确的选择。有负载时,Kinference 必须在排队时间和冷提示词的预填充时间之间权衡,所以系数需要准确。要在有负载的情况下做基准测试,先调优 profile,使它与这个模型和 GPU 相匹配,直到预测 TTFT 与观测到的 TTFT 接近为止。

调优后的 profile 改变了什么

我们对 profile 做了调优:更新其中的四个系数,使它与这个模型和 GPU 相匹配。这些值不是手工挑选的。对每次选择,Kinference 都会记录预测 TTFT、观测到的 TTFT,以及预测的输入,比如未缓存的块和排在前面的请求。一个脚本处理了这 3,720 次已记录的选择,针对许多组系数重新计算了预测,并保留了与观测到的 TTFT 最吻合的那一组。每一行先列默认值,后列调优后的值:

base_ms40055
attention_uncached_block_ms2.31.28
attention_uncached_per_every_block_ms0.030.002
forward_pass_ms517.4

在一个配置相同的新集群上,我们用每个 profile 把基准测试中 Kinference 的部分各运行了 3 次,使用相同的提示词。默认 profile 预测的 TTFT,按中位数计再次是观测值的 7.2 倍。调优后的 profile 预测的 TTFT 是观测到的 TTFT 的 1.02 倍,误差中位数为 27 ms,而默认 profile 为 519 ms。

性能保持不变,因为选择没有改变。在 2,232 个请求中,有 2,231 个在两个 profile 下得到了同一类型的选择(热或冷),所以每个工作负载的 TTFT 中位数都保持不变。当我们把共享前缀工作负载的负载加倍,达到 76 个前缀和 12 个进行中的请求时,情况依然如此。在这个负载下,调优后的 profile 让 Kinference 更频繁地等待繁忙的热副本:在 1,368 个请求中有 221 次,而默认 profile 为 173 次,但这不足以影响中位数。

调优后的 profile 改变最大的,是那些基于预测 TTFT 的规则。例如,策略可能会丢弃预测 TTFT 高于某个阈值的候选项。使用默认 profile 时,一个 5 秒的阈值本会对 36% 的请求丢弃所有本地副本,尽管实际上没有任何请求等待超过 2.3 秒。使用调优后的 profile 时,没有任何预测超过 5 秒。

运维现实

  • 网关必须会说 Kinference 的 API。 Kinference 并不限于某一个网关,但目前实现了它的 API 的是 Buoyant Gateway,而且它只处理 HTTPRoute。另外,要检查 Service 暴露了什么:默认情况下,它的类型是 LoadBalancer,在云提供商上,这会给你的模型一个公网地址。要把它留在集群内部,请在 Gateway 上使用注解 gateway.buoyant.io/service-type: ClusterIP。

  • 配置错误的引擎会让 Kinference 降级,却不会告诉你。 vLLM 需要带 ZeroMQ 发布器的 --kv-events-config,需要 --enable-prompt-tokens-details 来上报已缓存的 token,对 vLLM 0.31 还需要 --enable-scale-out,因为这个版本只有带上这个参数才提供 render 端点。在我们的第一次测试中,我们漏掉了最后这个参数。所有 Pod 都是 Ready,Worker 集和池都报告 Accepted,全部 744 个请求也都成功了,但 Kinference 无法对任何提示词分词,表现得就像一个普通的 Service。仅有的迹象是 kinference_score_degraded_total 计数器和日志里的一条警告。请为这个计数器设置告警。

  • kvBlockSize 必须与引擎发布的一致。 Kinference 无法自动检测块大小,而正确的值并不总是引擎的 --block-size 参数。如果两者不一致,Kinference 会在几次不匹配之后逐出这个 Worker,这可能让池中没有可用的 Worker。引擎或模型有任何变更之后,都要检查 Worker 集的 status.kvEvents、kinference_index_blocks 和 kinference_worker_evictions_total。

  • 默认 profile 出厂时带的是别人的数字。 使用默认 profile 时,我们集群上的每一次预测都偏高,偏高倍数的中位数为 7。原因只在于 profile 的系数:如前所示,profile 调优之后,同一个预测器的预测是观测到的 TTFT 的 1.02 倍。请开启观测事件,用你自己的流量对比一周的预测 TTFT 和观测到的 TTFT,并且先调优 profile,再去设置基于 predictedTTFT 的阈值,或者依赖有负载时的选择。

一条务实的建议

如果你在一个普通的 Service 后面运行着某个模型的多个副本,或者想对推理流量应用策略,把敏感查询留在本地模型上,或把突发的请求分流到外部推理服务以避免高延迟,那么本周就在一个非关键的池上试试 Kinference。然后,把你真实的提示词组合分别对这个池和 Service 重放一遍,比较 TTFT 的中位数和第 95 百分位(p95),以及引擎实际的前缀缓存命中率,而不只是 picker 的估计值。

在相信这些数字之前,先检查三件事。第一,kinference_score_degraded_total 应该一直保持为零。如果它增长了,说明 Kinference 无法对你的提示词分词,只是在根据负载路由。第二,Worker 集的 status.kvEvents 应该显示每个 Pod 都是 subscribed,而且 kinference_index_blocks 应该随流量增长。如果不是这样,可能是引擎没有发布 KV 事件,或者 kvBlockSize 不正确。第三,确保你的负载生成器为每个请求打开一个新连接。如果使用 keep-alive,kube-proxy 会把每个客户端固定到一个副本上,让 Service 看起来比实际更好。

试点跑完之后,先调整 profile,再创建策略。开启观测事件,然后把预测 TTFT 与你的流量中的实际 TTFT 进行比较。调整系数,直到两者吻合。在我们的测试中,调优并没有降低 TTFT,但它确实决定了 predictedTTFT 阈值是否会移除一个健康的副本。

如果你的提示词共享前缀,比如系统提示词、智能体循环或多轮对话,你在第一个小时内就会注意到差别。如果不共享,测试几个小时之后你也会发现这一点。在每年花费数十万美元的 GPU 节点上,重新计算一个已经由另一个副本持有的前缀,是在浪费你已经付过钱的容量。

FAQ

试点 Kinference 之前要弄清的四个问题。

只有一个 vLLM 副本,也需要 Kinference 吗?

不需要。只有一个副本时,没有什么可选的。有了多个副本、多个模型或多个租户,它才开始体现出价值。

它支持哪些推理引擎?

vLLM 和 SGLang。Kinference 会读取这两种引擎的指标和 KV 缓存事件,不过文档先讲的是 vLLM。

它能配合我们现有的网关使用吗?

只有当这个网关实现了 Kinference 的 gRPC API 时才可以。Buoyant Gateway 目前已经实现了。

Kinference 能把请求发给云提供商吗?

可以。InferenceProvider 声明一个外部 API,策略可以回退到它。由网关负责连接它,并保管凭据。