AI 인프라
Kinference 해설: 프롬프트를 아는 컨트롤 플레인
Kinference가 각 LLM 요청을 첫 토큰까지의 예측 시간이 가장 짧은 레플리카로 보내는 방법과, GKE에서 일반 Kubernetes Service와 비교한 벤치마크를 다룹니다.
Ivan Porta
Founder & Principal Engineer

LLM 추론에서는 라운드 로빈 같은 표준 로드 밸런싱 방식이 제 역할을 하지 못합니다. 핵심은 어느 레플리카가 요청을 처리하느냐입니다. 8,000 토큰짜리 프롬프트가 데워진 KV 캐시를 가진 레플리카로 가면 첫 토큰은 약 0.1초 만에 나옵니다. 콜드 레플리카에 도착하면 1초 넘게 걸릴 수 있습니다.
AI 최적화 IaaS 지출에서 이제 추론이 학습을 앞섭니다. 생성형 AI 모델을 운영하는 조직의 약 66%가 추론 워크로드의 일부 또는 전부에 Kubernetes를 사용합니다. Datadog의 State of AI Engineering 보고서는 입력 토큰의 69%가 시스템 프롬프트인데도 캐시를 조금이라도 사용하는 LLM 호출은 28%뿐이라는 점을 짚습니다.
Kubernetes만으로는 이 문제를 해결할 수 없습니다. Service는 프롬프트가 무엇인지 모르고, kube-proxy는 백엔드를 무작위로 고르거나 IPVS 모드를 쓰는 경우에는 순서대로 고릅니다. 레플리카가 세 개라면 후속 요청이 자기 캐시에 적중하는 경우는 대략 세 번에 한 번뿐입니다.
라우팅은 과제의 일부일 뿐입니다. 같은 GPU가 여러 팀의 코딩 어시스턴트, 배치 작업, 에이전트를 처리합니다. 큐가 길어질 때 누가 기다릴지, 어떤 요청이 더 작은 모델을 써도 되는지, 어떤 요청을 클라우드 프로바이더로 보내야 하는지 누군가는 결정해야 합니다. 이런 결정은 요청마다, 디스패치 전에 내려져야 하고, 이를 관리하는 데 전문가 팀이 필요해서도 안 됩니다. Kinference가 도움이 되는 지점이 바로 여기입니다.
Kinference는 실제로 무엇인가?
Kinference는 Kubernetes에서 실행하는 LLM 추론을 위한 오픈소스 컨트롤 플레인으로, Buoyant가 2026년 11월 4일에 발표했습니다. Kinference는 트래픽을 직접 처리하지 않습니다. 대신 게이트웨이가 각 요청을 어디로 보낼지 Kinference에 묻고, Kinference는 첫 토큰을 가장 빨리 돌려줄 레플리카로 답합니다. Kinference는 vLLM, SGLang 같은 서빙 엔진의 메트릭과 KV 캐시 이벤트로 첫 토큰까지의 시간(TTFT)을 예측하고, 여러분이 정한 정책을 적용해 결정을 내립니다.
Kinference 리소스
Kinference는 네 가지 주요 CRD를 중심으로 구성됩니다:
InferenceWorkerSet은 동일한 엔진 레플리카의 그룹과 그 위치, 그리고 Kinference가 이들을 모니터링하는 방법을 정의합니다.InferenceProvider는 클러스터 외부의 대상을 지정하며, 로컬 워커가 모든 요청을 감당하지 못할 때 사용됩니다.InferencePolicy는 요청마다 여러 대상 가운데 하나를 고르는 규칙을 담습니다.InferencePool은 라우트가 가리키는 타깃입니다. 요청이 갈 수 있는 대상과 그중에서 선택하는 정책을 나열합니다.
하나씩 살펴보면서 가장 중요한 필드를 중심으로 짚어 보겠습니다.
InferenceWorkerSet
InferenceWorkerSet은 동일한 엔진 파드 그룹 앞에 있는 Service를 감싸며, 이 파드들을 워커라고 부릅니다. 나머지 필드는 Kinference가 이 워커들을 모니터링하는 방법을 알려 줍니다. 그 덕분에 Kinference는 각 워커가 프롬프트의 얼마만큼을 이미 KV 캐시에 갖고 있는지 보고 그 워커의 TTFT를 예측할 수 있습니다. 주요 필드는 다음과 같습니다:
serviceRef: 엔진 파드 앞에 있는 Service입니다. Kinference는 이 Service를 통해 파드를 찾습니다.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:
- chatInferenceProvider
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: 1000000InferencePolicy
InferencePolicy는 풀의 어느 대상이 요청을 처리할지 결정합니다. 순서가 있는 규칙 목록을 사용하며, 가장 먼저 매칭되는 규칙이 적용됩니다. 규칙은 요청된 모델, 테넌트(게이트웨이가 여러분이 정한 헤더에서 읽습니다), 그리고 프롬프트와 응답의 크기를 기준으로 매칭할 수 있습니다. 그런 다음 라우트는 최대 네 개의 블록을 거칩니다:
-
consider: 이 블록은 후보 집합을 만들며, 기본적으로는 풀의 모든 대상에 있는 요청된 모델이 여기에 들어갑니다. 이 집합은 로컬 워커나 프로바이더(type), 특정 대상(backends), 또는 특정 모델로 좁힐 수 있습니다. 예를 들어 sandbox 테넌트에 대한 첫 번째 규칙처럼 민감한 프롬프트를 클러스터 안에 머물게 할 수 있습니다. 그룹에 가중치가 있으면 Kinference는 요청마다 그 가중치에 따라 그룹 하나를 고르고, 그 그룹만 후보를 제공합니다. 두 번째 규칙은 카나리처럼 동작합니다. 요청 열 건 중 아홉 건은 로컬 워커만 사용하고, 열 번째 요청은 호스팅형 모델도 사용할 수 있습니다. -
exclude: 이 블록은 후보를 상태에 따라 제외합니다. 큐에 대기 중인 프롬프트 수(queuedPrompts), 최근 30초 동안 평균한 KV 캐시 사용률(kvCacheUsage), 예측 TTFT(predictedTTFT), 컨텍스트 윈도우(contextWindow) 같은 상태가 기준이 됩니다.if조건을 사용하면 제외를 특정 요청으로 한정할 수 있습니다. -
select: 이 블록은 남은 후보의 순위를 티어별로 매깁니다. 후보가 있는 첫 번째 티어가 선택됩니다. 각 티어는 자신에게 속한 후보의 순위를PredictedTTFT(로컬 워커용),EstimatedTTFT(게이트웨이가 관측한 TTFT를 사용해 프로바이더까지 포함), 또는 고정된 순서에 따라 매깁니다.tieBreak는 동점을 해소합니다.PreferLocal은 프로바이더보다 로컬 워커를 고르고,Random은 무작위로 고릅니다.tieBreak가 없으면 Kinference는 순서상 첫 번째 후보를 고릅니다. -
onEmpty: 이 블록은 후보가 하나도 남지 않았을 때 어떻게 할지 결정합니다. 기본값인Reject는 요청을 거부합니다.FallThrough는 매칭되는 다음 규칙으로 넘어갑니다.
예시에서 세 번째 규칙은 배치 작업과 긴 요청을 여유가 충분한 워커에만 허용합니다. 마지막 규칙은 나머지 모든 요청을 로컬에서 처리하고, 사용할 수 있는 로컬 워커가 없을 때만 프로바이더를 사용합니다. 요청이 어떤 규칙에도 매칭되지 않으면 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-fallbackInferencePool
InferencePool은 나머지 세 구성 요소를 하나로 묶습니다. 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-firstKinference는 어떻게 동작하는가
Kinference는 대부분의 일을 요청이 도착하기 전에 해 둡니다. 먼저 Kinference가 백그라운드에서 하는 일을 살펴보겠습니다. 그런 다음 요청 하나를 도착 시점부터 따라가며, Kinference가 그 요청이 어디로 가야 할지 예측하는 방법까지 살펴보겠습니다.
Kinference가 대역 외에서 하는 일
요청 흐름 밖에서 Kinference는 네 가지 CRD와 그 뒤에 있는 Services, EndpointSlices를 감시합니다. 그리고 플릿의 최신 상태를 메모리에 유지합니다.
Kinference는 InferenceWorkerSet마다 serviceRef를 사용해 Service 뒤에 있는 Ready 상태의 파드를 찾습니다. 각 파드가 하나의 워커입니다. 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그 뒤 chat completion 요청 하나는 일곱 단계를 거칩니다:
- 요청 수신. 클라이언트는 요청 본문을 스트리밍으로 전송하고 라우트의
InferencePool을 지정합니다. Kinference는 본문을 메모리에 보관하며, 기본값으로 요청당 최대 8 MiB, 전체 합계 최대 256 MiB까지 보관합니다. 요청이 너무 크면 Kinference는 그 요청을 거부합니다. - 모델 식별. Kinference는 본문에서
model필드를 읽고, 어느 대상이 그 모델을 서빙할 수 있는지 파악합니다. - 캐시 측정. Kinference는 프롬프트를 토큰화하고, 토큰을
kvBlockSize크기의 블록으로 나눈 뒤, 엔진과 같은 방식으로 해싱해 인덱스에서 그 블록들을 조회합니다. - 정책 적용. 정책이 없으면 그 모델을 서빙하는 모든 워커가 후보입니다. 정책이 있으면 가장 먼저 매칭되는 규칙이 후보를 좁히고 순위를 매깁니다. 선택된 후보는 심지어 다른 모델이거나 클러스터 외부의 프로바이더일 수도 있습니다.
- 예측 및 확정. 이어서 Kinference는 후보마다 TTFT를 예측하고 값이 가장 낮은 후보를 선택합니다. 그리고 이 요청을 그 워커에서 처리 중인 요청으로 표시해, 엔진의 상태가 아직 갱신되지 않았더라도 다음 예측에 이 요청이 반영되게 합니다.
- 요청 반환. Kinference는 엔드포인트와 본문으로 응답합니다. 모델이 바뀌었다면 본문을 재작성한 뒤 돌려보냅니다.
- 첫 토큰과 마지막 토큰 보고. 클라이언트는 첫 토큰에서 관측한 TTFT를 보고하고, 마지막에는 캐시된 토큰을 포함한 전체 토큰 수를 보고합니다. Kinference는 이 정보로 처리 중인 요청의 추적 상태를 갱신하고, 예측이 얼마나 정확했는지 확인합니다. 프로바이더의 경우에는 이 보고가 Kinference가 프로바이더의 상태와 속도를 추적할 수 있는 유일한 수단입니다.
TTFT 예측
기본적으로 워커의 예측 TTFT는 네 부분으로 구성됩니다:
- 베이스(
base_ms). 모든 요청이 치르는 고정 오버헤드입니다. - 큐(
queue_ms_per_entry). Kinference가 그 워커로 이미 보낸 프리필 작업 가운데 현재 요청보다 아직 앞에 있는 작업이며, 각 요청이 지금쯤 얼마나 진행되었을지를 반영해 조정한 값입니다. Kinference는 아래의 두 프리필 필드로 이 작업의 비용을 매기고, 자신이 보내지 않은 대기 중인 요청에는 건당queue_ms_per_entry를 부과합니다. - 프리필(
attention_uncached_block_ms,attention_uncached_per_every_block_ms). 워커가 캐시에 갖고 있지 않은 블록에 대한 비용입니다. 첫 번째 필드는 캐시되지 않은 블록 하나당 비용입니다. 두 번째 필드는 캐시되지 않은 블록 하나당, 프롬프트의 모든 블록 각각에 대해 붙는 비용입니다. 새 토큰 하나하나가 프롬프트 전체에 어텐션을 수행하기 때문입니다. - 디코드 경합(
forward_pass_ms). 워커에서 이미 생성 중인 요청마다 붙는 작은 비용입니다.
페널티가 두 가지 더 있는데, 차트에서는 둘 다 0으로 설정되어 있습니다:
- KV 캐시 압박(
cache_pressure_penalty_ms). 워커의 KV 캐시가 찰수록 커지는 비용입니다. - 실행 중인 요청 한두 개(
q_running_penalty_peak_ms). 새 프리필이 GPU를 두고 경쟁해야 할 만큼은 바쁘지만, 그 프리필이 실행 중인 배치에 합류할 만큼 바쁘지는 않은 워커에 붙는 비용입니다.
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: renderKV 인덱스만 보면 예측이 빗나가는 버스트 상황은 두 가지 보정으로 다룹니다:
- 아직 계산 중인 프리픽스도 이미 반영됩니다. 엔진은 블록 계산을 마친 뒤에야 그 블록을 발행합니다. 같은 새 시스템 프롬프트를 가진 요청 10개가 1초 안에 도착하면, 워커 하나가 이미 그 프리픽스를 계산하고 있는데도 인덱스에는 어떤 워커도 그 프리픽스를 갖고 있지 않은 것으로 나타납니다. 이를 처리하기 위해 Kinference는 각 워커에 방금 무엇을 보냈는지 자체적으로 기록해 둡니다. 프리픽스 가운데 지금쯤이면 계산이 끝났을 부분은 캐시된 것으로 간주하고, 나머지는 큐로 간주합니다. 프리필이 진행될수록 그 워커는 엔진의 이벤트를 기다리지 않고도 다음 요청들에 가장 좋은 선택이 됩니다.
- 워커 하나에만 있는 프리픽스는 두 번째 사본을 얻습니다. 프리픽스를 가진 워커가 하나뿐이면 그 프리픽스를 가진 모든 요청이 그 워커로 몰려, 그 워커가 핫스팟이 됩니다. 이를 피하기 위해 콜드 워커의 예측 TTFT가 웜 워커의 예측 TTFT와 10% 이내로 차이 날 때(
replication_threshold_pct) Kinference는 의도적으로 콜드 워커를 선택합니다. 이런 일은 보통 웜 워커가 바쁘거나 프롬프트가 짧을 때 일어납니다. 첫 번째 요청이 프리필 비용을 치르고, 그 뒤에는 두 워커 모두 그 프리픽스를 갖게 됩니다(replication_warm_target).
캐시 인지 라우팅의 가치
차이를 측정하기 위해 GKE 클러스터에서 같은 요청을 두 가지 구성으로 보냈습니다. 하나는 일반 Service이고, 다른 하나는 기본 프로파일을 제공된 그대로 사용한 Kinference입니다. 뒤에서는 이 모델과 GPU에 맞게 튜닝한 프로파일로 벤치마크를 반복합니다. 클러스터는 NVIDIA RTX PRO 6000이 장착된 노드 하나를 사용하고, HAMi가 그 96 GB 메모리를 vLLM 0.31에서 실행되는 Qwen2.5-7B-Instruct 레플리카 3개에 각각 28,000 MiB씩 나눠 줍니다. 그 결과 레플리카마다 약 166,000 토큰 분량의 KV 캐시를 갖습니다. 카드 한 장만 쓰면 비용이 낮게 유지되지만, HAMi는 연산이 아니라 메모리를 제한하므로 한 레플리카의 콜드 프리필이 나머지 두 레플리카까지 느리게 만듭니다.
부하 생성기는 세 종류의 트래픽을 보내며, 여기서는 이를 워크로드라고 부릅니다. 처음 두 워크로드는 프롬프트의 일부를 반복하므로 KV 캐시가 도움이 될 수 있고, 세 번째 워크로드는 아무것도 반복하지 않습니다:
- 공유 프리픽스. 8,000 토큰짜리 시스템 프롬프트 38개이며, 각 프롬프트를 매번 새 질문과 함께 6번씩 방문합니다. 이 프롬프트들을 모두 합치면 레플리카 하나의 KV 캐시가 담을 수 있는 토큰의 1.8배이므로, 어느 레플리카도 혼자서는 전부를 웜 상태로 유지할 수 없지만 플릿 전체로는 가능합니다.
- 멀티턴. 8턴짜리 대화 36개이며, 턴마다 전체 대화 이력을 함께 보냅니다.
- 대조군. 크기는 같지만 모든 프롬프트가 고유해서 재사용할 것이 없습니다.
각 워크로드는 콜드 상태의 플릿에서 시작하고, 요청 6개가 동시에 실행되는 상태를 유지합니다. 공정한 비교를 위해 부하 생성기는 요청마다 새 연결을 열고, 그래서 kube-proxy가 매번 레플리카를 선택합니다. keep-alive를 사용했다면 각 클라이언트가 레플리카 하나에 고정되어 Service가 실제보다 좋아 보였을 것입니다.
TTFT는 클라이언트에서 측정하며, 캐시를 사용할 수 있었던 요청을 대상으로 합니다. 즉 각 프리픽스에 대한 첫 방문 이후의 모든 방문과 첫 턴 이후의 모든 턴입니다. 벤치마크는 5회 실행했으며, 실행마다 새 프롬프트를 사용하고 먼저 시작하는 진입점을 달리했습니다. 아래 결과는 실행별 중앙값 5개의 평균이며, 각 행에서 Service가 첫 번째, Kinference가 두 번째입니다:
| TTFT 중앙값 | Kubernetes Service | Kinference |
|---|---|---|
| 공유 프리픽스 | 889 ms | 128 ms |
| 멀티턴 | 148 ms | 94 ms |
| 대조군 | 1.17 s | 1.23 s |
다음 그림은 이 차이가 어디에서 오는지 보여 줍니다. 각 중앙값 옆에 캐시에서 나온 프롬프트 토큰의 비율과 5회 실행 간의 변동 폭을 함께 표시했습니다.
예측은 얼마나 정확했나?
예측을 검증하기 위해 Kinference는 선택마다 두 가지 시간을 로그로 남겼습니다. 선택한 레플리카에 대해 예측한 TTFT와 클라이언트가 실제로 본 TTFT입니다. 레플리카가 이미 프롬프트의 90% 이상을 갖고 있었다면 웜 선택으로, 전혀 갖고 있지 않았다면 콜드 선택으로 봅니다.
기본 프로파일에서 예측은 콜드 레플리카가 웜 레플리카보다 훨씬 느리다는 순서를 올바르게 맞혔습니다. 하지만 예측한 시간 자체는 빗나갔습니다. 3,720건의 예측이 모두 실제보다 높았고, 중앙값 기준으로 7배였습니다. 아래는 5회 실행에서 나온 중앙값이며, 각 행에서 관측된 시간이 첫 번째, 예측한 시간이 두 번째입니다:
| 선택 | 관측 | 예측 |
|---|---|---|
| 웜 선택 2,209건 | 98 ms | 557 ms |
| 콜드 선택 1,511건 | 1.2 s | 9.1 s |
개별 선택 세 건을 보면 이 숫자가 어떻게 만들어지는지 알 수 있습니다. 이번에도 관측된 시간이 첫 번째이고, 예측이 두 번째이며 항별로 나누어 적었습니다:
| 선택 | 관측 | 예측 |
|---|---|---|
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인데, 이는 여기서 웜 요청이 실제로 걸리는 시간의 네 배입니다.
이 오차가 문제가 되는지는 부하에 달려 있습니다. Kinference는 후보들을 서로 비교할 뿐입니다. 큐가 비어 있을 때는 워커 사이의 차이가 프리필 시간뿐이므로, 예측이 부정확해도 순서는 올바르게 유지되고 Kinference는 여전히 올바른 선택을 합니다. 부하가 걸리면 Kinference는 큐 대기 시간과 콜드 프롬프트의 프리필 시간을 저울질해야 하므로, 계수가 정확해야 합니다. 부하 상태에서 벤치마크하려면, 먼저 예측 TTFT와 관측된 TTFT가 가까워질 때까지 프로파일을 이 모델과 GPU에 맞게 튜닝하세요.
튜닝한 프로파일이 바꾸는 것
프로파일의 계수 가운데 네 개를 이 모델과 GPU에 맞게 바꾸는 방식으로 프로파일을 튜닝했습니다. 값을 손으로 고른 것은 아닙니다. Kinference는 선택마다 예측 TTFT, 관측된 TTFT, 그리고 캐시되지 않은 블록 수나 앞에 있는 요청 수 같은 예측 입력값을 로그로 남깁니다. 스크립트가 로그에 남은 3,720건의 선택을 처리해 여러 계수 조합으로 예측을 다시 계산하고, 관측된 TTFT에 가장 잘 맞는 조합을 남겼습니다. 각 행에서 기본값이 첫 번째, 튜닝한 값이 두 번째입니다:
| 계수 | 기본값 | 튜닝한 값 |
|---|---|---|
base_ms | 400 | 55 |
attention_uncached_block_ms | 2.3 | 1.28 |
attention_uncached_per_every_block_ms | 0.03 | 0.002 |
forward_pass_ms | 5 | 17.4 |
같은 구성의 새 클러스터에서, 벤치마크 중 Kinference 부분을 같은 프롬프트로 프로파일마다 3회씩 실행했습니다. 기본 프로파일은 이번에도 중앙값 기준으로 관측된 TTFT보다 7.2배 높게 예측했습니다. 튜닝한 프로파일은 관측된 TTFT의 1.02배로 예측했고, 오차의 중앙값은 27 ms로 기본 프로파일의 519 ms와 대비됩니다.
선택이 바뀌지 않았기 때문에 성능은 그대로였습니다. 요청 2,232건 가운데 2,231건이 두 프로파일에서 같은 유형의 선택(웜 또는 콜드)을 받았고, 그래서 워크로드별 TTFT 중앙값은 변하지 않았습니다. 공유 프리픽스 워크로드의 부하를 두 배로, 즉 프리픽스 76개와 처리 중인 요청 12개로 늘렸을 때도 마찬가지였습니다. 이 부하에서는 튜닝한 프로파일을 쓸 때 Kinference가 바쁜 웜 레플리카를 기다리는 일이 더 잦았습니다. 요청 1,368건 가운데 221회 대 173회였지만, 중앙값에 영향을 줄 만큼은 아니었습니다.
튜닝한 프로파일이 가장 크게 바꾸는 것은 예측 TTFT에 기반한 규칙입니다. 예를 들어 정책은 예측 TTFT가 특정 임계값을 넘는 후보를 제외할 수 있습니다. 기본 프로파일에서는 5초 임계값이 요청의 36%에 대해 모든 로컬 레플리카를 제외했을 것입니다. 실제로는 2.3초 넘게 기다린 요청이 하나도 없었는데도 말입니다. 튜닝한 프로파일에서는 5초를 넘은 예측이 하나도 없었습니다.
운영 현실
-
게이트웨이가 Kinference의 API를 지원해야 합니다. Kinference는 특정 게이트웨이 하나에 묶여 있지 않지만, 현재 Kinference의 API를 구현한 게이트웨이는 Buoyant Gateway이며, Buoyant Gateway는
HTTPRoute만 처리합니다. 또한 Service가 무엇을 노출하는지도 확인하세요. 기본값은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 엔드포인트를 제공하기 때문입니다. 저희는 첫 테스트에서 마지막 플래그를 빠뜨렸습니다. 모든 파드가 Ready였고, 워커 세트와 풀은Accepted를 보고했으며, 요청 744건이 모두 성공했습니다. 하지만 Kinference는 프롬프트를 하나도 토큰화하지 못했고 일반 Service처럼 동작했습니다. 징후라고는kinference_score_degraded_total카운터와 로그의 경고 한 줄뿐이었습니다. 이 카운터에 알림을 설정해 두세요. -
kvBlockSize는 엔진이 발행하는 값과 일치해야 합니다. Kinference는 블록 크기를 자동으로 감지하지 못하며, 올바른 값이 항상 엔진의--block-size플래그 값인 것도 아닙니다. 값이 일치하지 않으면 Kinference는 불일치가 몇 번 발생한 뒤 워커를 축출하고, 그러면 풀에 사용 가능한 워커가 하나도 남지 않을 수 있습니다. 엔진이나 모델을 변경한 뒤에는 매번 워커 세트의status.kvEvents,kinference_index_blocks,kinference_worker_evictions_total을 확인하세요. -
기본 프로파일에는 남의 숫자가 들어 있습니다. 기본 프로파일에서는 저희 클러스터의 모든 예측이 실제보다 높았고, 중앙값 기준으로 7배였습니다. 원인은 오로지 프로파일의 계수였습니다. 앞에서 보았듯이, 프로파일을 튜닝하자 같은 예측기가 관측된 TTFT의 1.02배 수준이 되었습니다. 관측 이벤트를 켜고, 일주일 동안 여러분의 트래픽에서 예측 TTFT와 관측된 TTFT를 비교한 다음,
predictedTTFT기반 임계값을 설정하거나 부하 상태의 선택에 의존하기 전에 프로파일을 튜닝하세요.
실전 권장 사항
한 모델의 레플리카 여러 개를 일반 Service 뒤에 두고 있거나, 민감한 쿼리는 로컬 모델에만 보내거나 높은 지연을 피하려고 요청을 외부 추론 서비스로 버스팅하는 식으로 추론 트래픽에 정책을 적용하고 싶다면, 이번 주에 중요도가 낮은 풀 하나에서 Kinference를 시험해 보세요. 그런 다음 실제 프롬프트 믹스를 풀과 Service 양쪽에 재생해 TTFT의 중앙값과 95번째 백분위수(p95)를 비교하고, 피커의 추정치만이 아니라 엔진의 실제 프리픽스 캐시 적중률도 함께 비교하세요.
숫자를 믿기 전에 세 가지를 확인하세요. 첫째, kinference_score_degraded_total은 0을 유지해야 합니다. 이 값이 증가한다면 Kinference가 프롬프트를 토큰화하지 못해 부하만으로 라우팅하고 있다는 뜻입니다. 둘째, 워커 세트의 status.kvEvents에 모든 파드가 subscribed로 표시되어야 하고, kinference_index_blocks는 트래픽에 따라 증가해야 합니다. 그렇지 않다면 엔진이 KV 이벤트를 발행하지 않고 있거나 kvBlockSize가 잘못되었을 수 있습니다. 셋째, 부하 생성기가 요청마다 새 연결을 여는지 확인하세요. keep-alive를 사용하면 kube-proxy가 각 클라이언트를 레플리카 하나에 고정해, Service가 실제보다 좋아 보입니다.
파일럿을 실행한 뒤에는 정책을 만들기 전에 프로파일부터 조정하세요. 관측 이벤트를 켠 다음, 예측 TTFT를 여러분의 트래픽에서 나온 실제 TTFT와 비교하세요. 둘이 일치할 때까지 계수를 조정하세요. 저희 테스트에서 튜닝은 TTFT를 줄이지 않았지만, predictedTTFT 임계값이 정상적인 레플리카를 제외하는지 여부는 튜닝이 결정합니다.
시스템 프롬프트, 에이전트 루프, 멀티턴 채팅처럼 프롬프트가 프리픽스를 공유한다면 첫 한 시간 안에 차이를 느낄 것입니다. 그렇지 않다면 몇 시간 테스트해 보면 그 사실을 알게 됩니다. 1년에 수십만 달러가 드는 GPU 노드에서, 다른 레플리카가 이미 갖고 있는 프리픽스를 다시 계산하는 것은 이미 비용을 지불한 용량을 낭비하는 일입니다.
FAQ
Kinference를 파일럿하기 전에 정리해 둘 질문 네 가지.
vLLM 레플리카가 하나뿐이어도 Kinference가 필요한가요?
아니요. 레플리카가 하나면 고를 대상이 없습니다. 레플리카가 여러 개이거나, 모델이 여러 개이거나, 테넌트가 여럿일 때부터 효과가 나기 시작합니다.
어떤 추론 엔진과 함께 동작하나요?
vLLM과 SGLang입니다. Kinference는 두 엔진 모두의 메트릭과 KV 캐시 이벤트를 읽습니다. 다만 문서는 vLLM을 앞세워 설명합니다.
기존 게이트웨이와 함께 동작하나요?
그 게이트웨이가 Kinference의 gRPC API를 구현한 경우에만 그렇습니다. 현재는 Buoyant Gateway가 구현하고 있습니다.
Kinference가 요청을 클라우드 프로바이더로 보낼 수 있나요?
네. InferenceProvider가 외부 API를 선언하고, 정책이 그 API로 폴백할 수 있습니다. 그 API에 접속하고 자격 증명을 보관하는 것은 게이트웨이입니다.


