Skip to content

AIインフラ

Kinference解説:プロンプトを理解するコントロールプレーン

Kinference は、LLM の各リクエストを、最初のトークンまでの予測時間が最も短いレプリカへ送ります。その仕組みを、GKE 上で通常の Kubernetes Service と比較したベンチマークとともに解説します。

Ivan Porta

Founder & Principal Engineer

20 分で読了
#kinference#inference#vllm#kubernetes#platform-engineering
Kinference解説:プロンプトを理解するコントロールプレーン

LLM 推論では、ラウンドロビンのような標準的なロードバランシング手法は的を外します。鍵を握るのは、どのレプリカがリクエストを処理するかです。8,000 トークンのプロンプトが、温まった KV キャッシュを持つレプリカに届けば、最初のトークンはおよそ 10 分の 1 秒で現れます。コールドなレプリカに着地すると、1 秒を超えることがあります。

AI 最適化 IaaS への支出では、いまや推論が学習を上回っています。生成 AI モデルを運用している組織の約 66% が、推論ワークロードの一部またはすべてに Kubernetes を使っています。Datadog の State of AI Engineering レポートは、入力トークンの 69% がシステムプロンプトであるのに対し、何らかのキャッシュを利用している LLM 呼び出しは 28% にすぎないと指摘しています。

Kubernetes だけでは、この問題を解決できません。Service はプロンプトが何なのかを知りませんし、kube-proxy はバックエンドをランダムに選ぶか、IPVS モードを使っていれば順番に選びます。レプリカが 3 つあると、後続のリクエストが自分のキャッシュにヒットするのは、およそ 3 回に 1 回だけです。

ルーティングは課題の一部にすぎません。同じ GPU が、別々のチームのコーディングアシスタント、バッチジョブ、エージェントを処理します。キューが伸びたときに誰を待たせるのか、どのリクエストならより小さなモデルを使ってよいのか、どのリクエストをクラウドプロバイダーへ送るべきかを、誰かが決めなければなりません。こうした判断は、リクエストごとに、ディスパッチの前に、しかも管理のための専門家チームなしで下す必要があります。そこで役立つのが Kinference です。

Kinference とは、実際のところ何なのか?

Kinference は、Kubernetes 上の LLM 推論のためのオープンソースのコントロールプレーンで、Buoyant が 2026 年 11 月 4 日に発表しました。Kinference 自身はトラフィックを直接扱いません。代わりに、ゲートウェイが各リクエストをどこへ送るべきかを Kinference に問い合わせ、Kinference は最初のトークンを最も早く返すはずのレプリカを答えます。Kinference は、vLLM や SGLang といったサービングエンジンのメトリクスと KV キャッシュイベントを使って最初のトークンまでの時間(TTFT)を予測し、利用者が定めたポリシーを適用して判断を下します。

Kinference のリソース

Kinference は、4 つの主要な CRD を中心に構成されています:

  • InferenceWorkerSet は、同一のエンジンレプリカのグループと、そのレプリカがどこにあるか、そして Kinference がそれらをどう監視できるかを定義します。
  • InferenceProvider は、クラスター外の宛先を指定します。ローカルのワーカーだけではすべてのリクエストを処理しきれないときに使われます。
  • InferencePolicy は、リクエストごとに宛先の中から選ぶためのルールを含みます。
  • InferencePool は、ルートのターゲットです。リクエストが向かう可能性のある宛先と、その中から宛先を選ぶポリシーを記載します。

それぞれを順に確認し、最も重要なフィールドに注目していきましょう。

InferenceWorkerSet

InferenceWorkerSet は、同一のエンジン Pod のグループの前段にある Service をラップします。これらの Pod をワーカーと呼びます。そのほかのフィールドは、これらのワーカーをどう監視するかを Kinference に伝えます。それによって Kinference は、各ワーカーがプロンプトのうちどれだけをすでに KV キャッシュに持っているかを把握し、そのワーカーの TTFT を予測できます。主なフィールドは次のとおりです:

  • serviceRef:エンジン Pod の前段にある Service です。Kinference は、この Service を通じて Pod を見つけます。
  • kvEvents:エンジンが ZeroMQ 経由で KV キャッシュイベントを発行する場所です。このブロックは省略できますが、指定しないと Kinference はキャッシュを見ることができません。その結果、予測 TTFT の精度は大きく下がり、Kinference は負荷だけにもとづいてルーティングするようになります。
  • kvBlockSize:それらのイベントの各ブロックに含まれるトークン数です。エンジンが発行するものと一致していなければなりません。
  • profile:チューニング用のプロファイルです。Kinference がプロンプトをどうトークン化するか、キャッシュされていないブロックやキューに入ったリクエストを予測の中でどう評価するか、そして最終的な判断をどう下すかを定めます。
  • metricsPort:エンジンが Prometheus メトリクスを公開するポートです。Kinference は、ここから各ワーカーの負荷を読み取ります。
  • modelDiscovery:ワーカーがどのモデルを提供しているかを Kinference が把握する方法です。Endpoint モード(デフォルト)では、各ワーカーの /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 キーは、Buoyant Gateway のリソースである GatewayBackend に保存され、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 は、プール内のどの宛先がリクエストを処理するかを決めます。ルールの順序付きリストを使い、最初にマッチしたルールが適用されます。ルールでは、リクエストされたモデル、テナント(利用者が選んだヘッダーからゲートウェイが読み取ります)、プロンプトと応答のサイズをマッチ条件にできます。続いて、ルートは最大 4 つのブロックを順に通ります:

  • consider:このブロックは候補の集合を組み立てます。デフォルトでは、プール内のすべての宛先にある、リクエストされたモデルが含まれます。この集合は、ローカルのワーカーまたはプロバイダー(type)、特定の宛先(backends)、あるいは特定のモデルに絞り込めます。たとえば、sandbox テナントに対する最初のルールが示すように、機密性の高いプロンプトをクラスター内にとどめておけます。グループに重みがある場合、Kinference はその重みにもとづいてリクエストごとにグループを 1 つ選び、そのグループだけが候補を出します。2 番目のルールはカナリアのように働きます。10 件中 9 件のリクエストはローカルのワーカーだけを使い、残りの 1 件はホスト型のモデルも使えます。

  • exclude:このブロックは、候補の状態にもとづいて候補を取り除きます。たとえば、キューに入っているプロンプトの数(queuedPrompts)、直近 30 秒間で平均した KV キャッシュの埋まり具合(kvCacheUsage)、予測 TTFT(predictedTTFT)、コンテキストウィンドウ(contextWindow)といった状態です。if 条件を使うと、除外を特定のリクエストに限定できます。

  • select:このブロックは、残った候補をティアに分けて順位付けします。候補のある最初のティアが選ばれます。各ティアは、自身の候補を PredictedTTFT(ローカルのワーカー向け)、EstimatedTTFT(ゲートウェイが観測した TTFT を使うことで、プロバイダーも対象に含みます)、または固定の順序で順位付けします。tieBreak は同点を解消します。PreferLocal はプロバイダーよりもローカルのワーカーを選び、Random はランダムに選びます。tieBreak がなければ、Kinference は順番が最初の候補を選びます。

  • onEmpty:このブロックは、候補が残らなかった場合に何が起きるかを決めます。デフォルトの Reject は、リクエストを拒否します。FallThrough は、次にマッチするルールへ進みます。

この例では、3 番目のルールが、バッチジョブと長いリクエストを、十分な余力のあるワーカーにだけ許可しています。最後のルールは、それ以外のすべてのリクエストをローカルで処理し、利用できるローカルのワーカーがない場合にだけプロバイダーを使います。どのルールにもマッチしないリクエストは unmatched ポリシーに従い、デフォルトでは最も速いローカルのワーカーへ送られます。

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 は、ほかの 3 つのコンポーネントを束ねます。HTTPRoute は、これをバックエンドとして使います。InferencePool は、リクエストが向かう可能性のある宛先を名前またはラベルで列挙し、その中から宛先を選ぶポリシーを指定します。policyRef がない場合、各リクエストは予測 TTFT が最も低いローカルのワーカーへ送られ、リクエストがクラスターの外へ出ることはありません。

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 が帯域外でやっていること

リクエストフローの外側で、Kinference は 4 つの CRD と、その背後にある Services と EndpointSlices を監視します。そして、フリートの最新の状態をメモリ上に保持します。

Kinference は InferenceWorkerSet ごとに、serviceRef を使って Service の背後にある Ready 状態の Pod を見つけます。それぞれの Pod がワーカーです。Kinference は各ワーカーから Prometheus メトリクスを収集し、実行中のリクエスト数、待機中のリクエスト数、KV キャッシュの埋まり具合を追跡します。また、ワーカーの /v1/models エンドポイントを確認して、どのモデルを提供しているかを調べます。ワーカーセットに kvEvents がある場合、Kinference はワーカーの ZeroMQ ソケットを購読し、ワーカーの KV キャッシュにブロックが保存されたり、そこから削除されたりするたびにイベントを受け取ります。これらのイベントをもとに、Kinference はどのブロックがどのワーカーにあるかを示すインデックスを構築します。このインデックスが、あとでウォームなレプリカとコールドなレプリカを見分ける助けになります。

注: 「Ingress から推論ゲートウェイへ」で見たとおり、vLLM はデフォルトではこれらのイベントを発行しません。そのため、KV イベントの発行を有効にしてエンジンを起動する必要があります。kvEvents は、どこをリッスンすればよいかを Kinference に伝えるだけです。

同時に、Kinference は各 InferencePool を宛先のリストに変換し、そのプールが使う InferencePolicy を準備します。こうしておくことで、リクエストが届いたらすぐにルールを使えます。

リクエストが届いたとき

すべてはルートから始まります。ゲートウェイはリクエストを HTTPRoute にマッチさせますが、今回のバックエンドは Service ではなく InferencePool です。そのためゲートウェイは、自分ではエンドポイントを選ばず、代わりに 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

その後、チャット補完のリクエストは 7 つのステップをたどります:

  1. リクエストの受信。 クライアントはリクエストボディをストリーミングで送り、ルートが示す InferencePool を指定します。Kinference はボディをメモリに保持します。デフォルトでは、リクエストあたり最大 8 MiB、合計で最大 256 MiB です。リクエストが大きすぎる場合、Kinference はそのリクエストを拒否します。
  2. モデルの特定。 Kinference はリクエストボディの model フィールドを読み取り、どの宛先がそのモデルを提供できるかを割り出します。
  3. キャッシュの計測。 Kinference はプロンプトをトークン化し、トークンを kvBlockSize 個ずつのブロックに分割し、エンジンと同じ方法でハッシュ化して、それらのブロックを自身のインデックスで調べます。
  4. ポリシーの適用。 ポリシーがない場合は、そのモデルを提供するワーカーがすべて候補になります。ポリシーがある場合は、最初にマッチしたルールが候補を絞り込み、順位付けします。選ばれる候補が、別のモデルやクラスター外のプロバイダーになることさえあります。
  5. 予測と確定。 続いて Kinference は、候補ごとに TTFT を予測し、その値が最も低い候補を選びます。そして、そのリクエストをそのワーカーで処理中のリクエストとして記録します。こうすることで、エンジン側がまだ更新されていなくても、次の予測はこのリクエストを考慮に入れます。
  6. リクエストの返却。 Kinference は、エンドポイントとリクエストボディを返します。モデルが変わった場合は、送り返す前にボディを書き換えます。
  7. 最初と最後のトークンの報告。 クライアントは、最初のトークンについて観測した TTFT を報告し、最後に、キャッシュされたトークンを含むトークン数の合計を報告します。Kinference はこの情報を使って、処理中のリクエストの追跡を更新し、予測がどれだけ正確だったかを確認します。プロバイダーの場合、Kinference がその健全性と速度を追跡する手段は、これらの報告しかありません。

TTFT の予測

デフォルトでは、ワーカーの予測 TTFT は 4 つの部分から成ります:

  • ベース(base_ms)。 すべてのリクエストが支払う固定のオーバーヘッドです。
  • キュー(queue_ms_per_entry)。 Kinference がすでにそのワーカーへ送ったプリフィル処理のうち、現在のリクエストの前にまだ残っている分です。各リクエストがどこまで進んでいるはずかに応じて調整されます。Kinference は、下記の 2 つのプリフィル用フィールドを使ってこの処理のコストを算出し、自身が送っていない待機中のリクエストには、1 件ごとに queue_ms_per_entry を課します。
  • プリフィル(attention_uncached_block_ms、attention_uncached_per_every_block_ms)。 ワーカーがキャッシュしていないブロックにかかるコストです。1 つ目のフィールドは、キャッシュされていないブロック 1 つあたりのコストです。2 つ目は、キャッシュされていないブロック 1 つにつき、プロンプト内のブロック 1 つごとにかかるコストです。新しいトークンはそれぞれ、プロンプト全体に対してアテンションを計算するためです。
  • デコードの競合(forward_pass_ms)。 そのワーカーですでに生成中のリクエスト 1 件ごとにかかる、小さなコストです。

ペナルティはさらに 2 つあり、どちらも Helm チャートではゼロに設定されています:

  • KV キャッシュの逼迫(cache_pressure_penalty_ms)。 ワーカーの KV キャッシュが埋まるにつれて増えるコストです。
  • 実行中のリクエストが 1 件か 2 件(q_running_penalty_peak_ms)。 新しいプリフィルが GPU を奪い合う程度には忙しいものの、そのプリフィルが実行中のバッチに合流できるほどには忙しくないワーカーにかかるコストです。

Kinference がこれらの係数を自動で学習することはありません。自分たちのモデルとハードウェアに合わせてチューニングする必要があり、正しい値にすることが重要です。システムが混雑しているとき、Kinference は、ウォームなワーカーのキューでの待ち時間と、コールドでアイドル状態のワーカーでのプリフィル時間を比較します。係数が間違っていると、Kinference は誤った選択をするおそれがあります。また、predictedTTFT をしきい値とともに使うポリシールールはどれも、この数値が正しいことを前提にしています。以下のベンチマークでは、デフォルト値が私たちのハードウェアにどの程度合っていたかを示します。

係数は、ワーカーセットが参照する名前付きのプロファイルに置かれます。次は、チャートの values にある default プロファイルです:

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 インデックスだけでは予測を誤らせてしまうバーストは、2 つの改良でカバーしています:

  • まだ計算中のプレフィックスも、すでに数に入ります。 エンジンは、ブロックの計算を終えてからでないと、そのブロックを発行しません。同じ新しいシステムプロンプトを持つリクエストが 1 秒間に 10 件届くと、1 つのワーカーがすでにそのプレフィックスに取りかかっていても、インデックスは、どのワーカーもそのプレフィックスを持っていないと示します。これに対処するため、Kinference は、各ワーカーへ送ったばかりのものを自前で記録しています。プレフィックスのうち、現時点までに計算が済んでいるはずの部分はキャッシュ済みとして数え、残りはキューとして数えます。プリフィルが進むにつれて、エンジンのイベントを待たなくても、そのワーカーが次のリクエストにとって最良の選択肢になります。
  • 1 つのワーカーにしかないプレフィックスには、2 つ目のコピーが作られます。 あるプレフィックスを持つワーカーが 1 つだけだと、そのプレフィックスを持つリクエストはすべてそのワーカーへ向かい、そのワーカーがホットスポットになります。これを避けるため、コールドなワーカーの予測 TTFT と、ウォームなワーカーの予測 TTFT との差が 10% 以内(replication_threshold_pct)のとき、Kinference はあえてコールドなワーカーを選びます。これが起きるのはたいてい、ウォームなワーカーが忙しいときか、プロンプトが短いときです。最初のリクエストがプリフィルのコストを負担し、それ以降は両方のワーカーがそのプレフィックスを持ちます(replication_warm_target)。

キャッシュを意識したルーティングの価値

違いを測るため、GKE クラスター上で、同じリクエストを 2 つの構成に通しました。通常の Service と、出荷時のままのデフォルトプロファイルを使った Kinference です。後ほど、このモデルと GPU に合わせてチューニングしたプロファイルを使って、ベンチマークを繰り返します。クラスターは NVIDIA RTX PRO 6000 を搭載したノードを 1 台使い、HAMi がその 96 GB のメモリを、vLLM 0.31 上の 3 つの Qwen2.5-7B-Instruct レプリカに分け、それぞれに 28,000 MiB を割り当てます。これにより、各レプリカは約 166,000 トークン分の KV キャッシュを持ちます。カードを 1 枚にすればコストは低く抑えられますが、HAMi が制限するのはメモリであって計算能力ではないため、1 つのレプリカでのコールドなプリフィルは、ほかの 2 つのレプリカも遅くします。

ロードジェネレーターは 3 種類のトラフィックを送ります。ここではこれをワークロードと呼びます。最初の 2 つはプロンプトの一部を繰り返すので KV キャッシュが役に立ちますが、3 つ目は何も繰り返しません:

  • 共有プレフィックス。 8,000 トークンのシステムプロンプトが 38 個あり、それぞれを、毎回新しい質問を付けて 6 回ずつ訪問します。合わせると、1 つのレプリカの KV キャッシュが保持できるトークン数の 1.8 倍になります。そのため、単一のレプリカではすべてをウォームに保てませんが、フリート全体なら保てます。
  • マルチターン。 8 ターンの会話が 36 個あり、どのターンも履歴全体を含みます。
  • コントロール。 サイズは同じですが、すべてのプロンプトが一意なので、再利用できるものが何もありません。

各ワークロードはコールドなフリートから始まり、同時に 6 件のリクエストを実行し続けます。比較を公平にするため、ロードジェネレーターはリクエストごとに新しい接続を開くので、kube-proxy は毎回レプリカを選びます。keep-alive を使っていたら、各クライアントが 1 つのレプリカに張り付き、Service が実際よりも良く見えてしまいます。

TTFT は、キャッシュを利用できる可能性のあったリクエストについて、クライアント側で計測しています。対象は、あるプレフィックスへの 2 回目以降のすべての訪問と、2 ターン目以降のすべてのターンです。ベンチマークは 5 回実行し、毎回、新しいプロンプトを使い、先に開始する入口を変えました。以下の結果は、5 回の実行それぞれの中央値を平均したもので、各行では Service を先に、Kinference を後に示しています:

共有プレフィックス889 ms128 ms
マルチターン148 ms94 ms
コントロール1.17 s1.23 s

次の図は、この差がどこから来るのかを示しています。それぞれの中央値の横に、プロンプトトークンのうちキャッシュから得られた割合と、5 回の実行でのばらつきを載せています。

予測はどれくらい正確だったか?

予測を検証するため、Kinference は選択ごとに 2 つの時間をログに記録しました。選んだレプリカについて予測した TTFT と、クライアントが実際に観測した TTFT です。選択は、レプリカがすでにプロンプトの 90% 以上を持っていればウォーム、まったく持っていなければコールドとみなします。

デフォルトプロファイルでの予測は、コールドなレプリカをウォームなレプリカよりはるかに遅いものとして、正しく順位付けしました。しかし、予測された時間は外れていました。3,720 件の予測はすべて高すぎ、その倍率は中央値で 7 倍でした。以下は 5 回の実行の中央値で、各行では観測された時間を先に、予測された時間を後に示しています:

ウォームな選択 2,209 件98 ms557 ms
コールドな選択 1,511 件1.2 s9.1 s

個別の選択を 3 つ見ると、この数値がどう組み上がるかが分かります。ここでも観測された時間が先、予測が後で、予測は項ごとに分けて示しています:

vllm-0 でウォーム:500 ブロック中 495 がキャッシュ済み94 msベース 400 + プリフィル 86 + デコード 5 = 491 ms
vllm-1 でコールド:498 ブロック中 0 がキャッシュ済み1,203 msベース 400 + プリフィル 8,586 + デコード 10 = 8,996 ms
vllm-2 でコールドかつキュー待ち:502 ブロック中 0 がキャッシュ済み、前にコールドなプロンプトが 1 つ1,723 msベース 400 + キュー 8,047 + プリフィル 8,715 + デコード 15 = 17,177 ms

問題はプロファイルにあります。デフォルトの係数は別のフリートにもとづいたもので、RTX PRO 6000 上の 7B モデルにもとづいたものではありません。たとえばベースの項は 400 ms で、これは、ここでウォームなリクエストに実際にかかる時間の 4 倍です。

この誤差が問題になるかどうかは、負荷しだいです。Kinference は候補同士を比較するだけです。キューが空のときは、ワーカー間の違いはプリフィル時間だけなので、予測が不正確でも順序は正しく保たれ、Kinference はそれでも正しい選択をします。負荷がかかると、Kinference はキューでの待ち時間と、コールドなプロンプトのプリフィル時間とを天秤にかけなければならないため、係数が正確である必要があります。負荷をかけたベンチマークでは、まず、予測 TTFT と観測された TTFT が近づくまで、このモデルと GPU に合わせてプロファイルをチューニングしてください。

チューニングしたプロファイルで変わること

このモデルと GPU に合うように、係数のうち 4 つを更新してプロファイルをチューニングしました。値は手作業で選んだものではありません。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

同じ構成の新しいクラスターで、ベンチマークのうち Kinference の部分を、同じプロンプトを使って、プロファイルごとに 3 回実行しました。デフォルトプロファイルは今回も、中央値で、観測値の 7.2 倍の TTFT を予測しました。チューニングしたプロファイルの予測は、観測された TTFT の 1.02 倍でした。誤差の中央値は、デフォルトプロファイルの 519 ms に対して 27 ms でした。

選択が変わらなかったため、性能は同じままでした。2,232 件のリクエストのうち 2,231 件が、どちらのプロファイルでも同じ種類の選択(ウォームまたはコールド)を受けたため、各ワークロードの TTFT の中央値は変わりませんでした。このことは、共有プレフィックスのワークロードの負荷を 2 倍にして、プレフィックスを 76 個、処理中のリクエストを 12 件にしたときにも当てはまりました。この負荷では、チューニングしたプロファイルのほうが、Kinference が忙しいウォームなレプリカを待つ回数が多くなりました。1,368 件のリクエストのうち、173 回に対して 221 回です。ただし、中央値に影響するほどではありませんでした。

チューニングしたプロファイルで最も大きく変わるのは、予測 TTFT にもとづくルールです。たとえば、予測 TTFT が一定のしきい値を上回る候補を除外するポリシーが考えられます。デフォルトプロファイルでは、実際には 2.3 秒を超えて待ったリクエストが 1 件もなかったにもかかわらず、5 秒のしきい値はリクエストの 36% ですべてのローカルのレプリカを除外していたはずです。チューニングしたプロファイルでは、5 秒を超えた予測は 1 つもありませんでした。

運用の現実

  • ゲートウェイは Kinference の API を話せなければなりません。 Kinference は 1 つのゲートウェイに限定されていませんが、現時点でその API を実装しているのは Buoyant Gateway であり、Buoyant Gateway が扱うのは HTTPRoute だけです。また、Service が何を公開しているかも確認してください。デフォルトでは type が LoadBalancer で、クラウドプロバイダー上ではモデルにパブリックアドレスが割り当てられます。クラスター内にとどめるには、Gateway にアノテーション gateway.buoyant.io/service-type: ClusterIP を付けます。

  • 設定を誤ったエンジンは、何も知らせずに Kinference を劣化させます。 vLLM には、ZeroMQ パブリッシャーを指定した --kv-events-config、キャッシュされたトークンを報告するための --enable-prompt-tokens-details、そして vLLM 0.31 では --enable-scale-out が必要です。このバージョンは、このフラグを付けたときにしか render エンドポイントを提供しないためです。私たちは最初のテストで、この最後のフラグを見落としました。すべての Pod は Ready で、ワーカーセットとプールは Accepted を報告し、744 件のリクエストはすべて成功しました。しかし Kinference はプロンプトを 1 つもトークン化できず、通常の Service のように振る舞いました。兆候は、kinference_score_degraded_total カウンターと、ログに出た 1 件の警告だけでした。このカウンターにアラートを設定してください。

  • kvBlockSize は、エンジンが発行するものと一致していなければなりません。 Kinference はブロックサイズを自動で検出できず、正しい値がエンジンの --block-size フラグの値だとは限りません。一致していないと、Kinference は数回の不一致のあとでワーカーを追い出すため、プールに利用可能なワーカーが残らなくなることがあります。エンジンやモデルを変更したあとは必ず、ワーカーセットの status.kvEvents、kinference_index_blocks、kinference_worker_evictions_total を確認してください。

  • デフォルトプロファイルは、他人の数値のまま出荷されています。 デフォルトプロファイルでは、私たちのクラスターでの予測はすべて高すぎ、その倍率は中央値で 7 倍でした。原因はプロファイルの係数だけでした。先に示したとおり、プロファイルをチューニングすると、同じ予測器の予測が、観測された TTFT の 1.02 倍になりました。観測イベントを有効にし、自分たちのトラフィックで 1 週間、予測 TTFT と観測された TTFT を比較してください。そして、predictedTTFT にもとづくしきい値を設定したり、負荷がかかった状態での選択に頼ったりする前に、プロファイルをチューニングしてください。

実践的な推奨

通常の Service の後ろで 1 つのモデルのレプリカを複数運用している場合、または、機密性の高いクエリをローカルのモデルにとどめたり、高いレイテンシーを避けるためにリクエストを外部の推論サービスへバーストさせたりして推論トラフィックにポリシーを適用したい場合は、今週のうちに、クリティカルでないプール 1 つで Kinference を試してみてください。そのうえで、実際のプロンプトの内訳を、そのプールと Service の両方に対してリプレイし、TTFT の中央値と 95 パーセンタイル(p95)を比較してください。あわせて、ピッカーの推定だけでなく、エンジンの実際のプレフィックスキャッシュヒット率も比較します。

数値を信頼する前に、3 つのことを確認してください。1 つ目に、kinference_score_degraded_total はゼロのままでなければなりません。増えている場合、Kinference はプロンプトをトークン化できておらず、負荷だけにもとづいてルーティングしています。2 つ目に、ワーカーセットの status.kvEvents がすべての Pod を subscribed と示し、kinference_index_blocks がトラフィックとともに増えていなければなりません。そうでない場合は、エンジンが KV イベントを発行していないか、kvBlockSize が誤っている可能性があります。3 つ目に、ロードジェネレーターがリクエストごとに新しい接続を開いていることを確かめてください。keep-alive を使うと、kube-proxy が各クライアントを 1 つのレプリカに固定してしまい、Service が実際よりも良く見えます。

パイロットを実行したら、ポリシーを作る前にプロファイルを調整してください。観測イベントを有効にし、予測 TTFT を、自分たちのトラフィックでの実際の TTFT と比較します。両者が一致するまで係数を調整してください。私たちのテストでは、チューニングしても TTFT は下がりませんでした。しかし、predictedTTFT のしきい値が健全なレプリカを取り除くかどうかは、チューニングで決まります。

システムプロンプト、エージェントループ、マルチターンのチャットのように、プロンプトがプレフィックスを共有しているなら、最初の 1 時間のうちに違いに気づくはずです。共有していないなら、数時間テストすればそのことが分かります。年間数十万ドルかかる GPU ノードで、別のレプリカがすでに持っているプレフィックスを計算し直すのは、すでに支払い済みのキャパシティの無駄遣いです。

FAQ

Kinference のパイロットを始める前に解決しておきたい 4 つの疑問。

vLLM のレプリカが 1 つだけでも Kinference は必要ですか?

いいえ。レプリカが 1 つなら、選ぶ対象がありません。効果が出始めるのは、複数のレプリカ、複数のモデル、あるいは複数のテナントがあるときです。

どの推論エンジンで動作しますか?

vLLM と SGLang です。Kinference は両方のエンジンのメトリクスと KV キャッシュイベントを読み取りますが、ドキュメントでは vLLM が先に扱われています。

既存のゲートウェイで動作しますか?

そのゲートウェイが Kinference の gRPC API を実装している場合に限ります。Buoyant Gateway は現時点で実装しています。

Kinference はリクエストをクラウドプロバイダーへ送れますか?

はい。InferenceProvider が外部の API を宣言し、ポリシーはそこへフォールバックできます。その API に接続し、認証情報を保持するのはゲートウェイです。