As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Cache KV e roteamento inteligente
<a name="sagemaker-hyperpod-model-deployment-caching-routing"></a>

O Amazon SageMaker HyperPod Inference fornece armazenamento gerenciado em camadas de chave-valor (KV) e roteamento inteligente para otimizar o desempenho de inferência para cargas de trabalho de modelo de linguagem grande (LLM). O cache KV salva vetores de valores-chave pré-computados após o processamento de tokens anteriores, eliminando recálculos redundantes. Por meio de uma arquitetura de cache de duas camadas, você pode configurar um cache L1 que usa memória de CPU para reutilização local de baixa latência e um cache L2 que utiliza o Redis ou o armazenamento hierárquico gerenciado para permitir o compartilhamento escalável de cache em nível de nó.

O roteamento inteligente analisa as solicitações recebidas e as direciona para a instância de inferência com maior probabilidade de ter pares de valores-chave em cache relevantes. O sistema examina a solicitação e a encaminha com base em uma das seguintes estratégias de roteamento:
+ `prefixaware`— Solicitações subsequentes com o mesmo prefixo de prompt são roteadas para a mesma instância.
+ `kvaware`— As solicitações recebidas são roteadas para a instância com a maior taxa de acerto do cache KV.
+ `session`— Solicitações da mesma sessão de usuário são roteadas para a mesma instância.
+ `roundrobin`— Distribui as solicitações uniformemente sem considerar o estado do cache KV.

O roteamento inteligente funciona com todos os métodos de implantação do Amazon SageMaker HyperPod Inference, incluindo SageMaker JumpStart implantações da Amazon (console e kubectl), implantações de armazenamento local NVMe e implantações do Amazon S3, Amazon FSx ou Hugging Face Hub. Você pode habilitar o armazenamento em cache e o roteamento, independentemente do método de implantação usado para servir seu modelo.

**nota**  
Atualmente, o cache KV e o roteamento inteligente suportam apenas contêineres de inferência v. LLM-based 

## Configure o cache KV e o roteamento inteligente
<a name="sagemaker-hyperpod-model-deployment-deploy-ftm-cache-route"></a>

1. Ative o cache KV configurando `enableL1Cache` e `enableL2Cache` para. `true` Em seguida, configure `l2CacheSpec` `l2CacheBackend` definindo como `redis` ou`tieredstorage`. Se você escolher`redis`, atualize `l2CacheLocalUrl` com a URL do cluster Redis.

   ```
     kvCacheSpec:
       enableL1Cache: true
       enableL2Cache: true
       l2CacheSpec:
         l2CacheBackend: <redis | tieredstorage>
         l2CacheLocalUrl: <Redis cluster URL if l2CacheBackend is redis >
   ```
**nota**  
Se o cluster Redis não estiver na mesma Amazon VPC que HyperPod o cluster, a criptografia dos dados em trânsito não é garantida.
**nota**  
Você não precisa `l2CacheLocalUrl` se `tieredstorage` estiver selecionado.

1. Ative o roteamento inteligente configurando como `enabled` `true` abaixo`intelligentRoutingSpec`. Você pode especificar em `routingStrategy` qual estratégia de roteamento usar. Se nenhuma estratégia de roteamento for especificada, o padrão será. `prefixaware`

   ```
   intelligentRoutingSpec:
       enabled: true
       routingStrategy: <routing strategy to use>
   ```

1. Ative as métricas do roteador e as métricas de armazenamento em cache definindo `enabled` como `true` abaixo`metrics`. O `port` valor precisa ser igual ao `containerPort` valor abaixo`modelInvocationPort`.

   ```
   metrics:
       enabled: true
       modelMetrics:
         port: <port value>
       ...
       modelInvocationPort:
         containerPort: <port value>
   ```

## KV-aware compatibilidade de roteamento
<a name="sagemaker-hyperpod-model-deployment-kv-routing-compatibility"></a>

A matriz de compatibilidade e as restrições de versão nesta seção se aplicam *somente à estratégia* de `kvaware` roteamento. A `kvaware` estratégia direciona as solicitações recebidas para a instância de inferência com a maior taxa de acerto do cache KV e, atualmente, oferece suporte apenas a LLM-based imagens v com a `/completions` API como endpoint de invocação.

**nota**  
Se você usar o `kvaware` roteamento, deverá `invocationEndpoint` configurá-lo `/completions` em seu manifesto de implantação. O `/v1/chat/completions` endpoint não é compatível com `kvaware` roteamento. Outras estratégias de roteamento (`prefixaware`,`session`,`roundrobin`) funcionam com qualquer endpoint de invocação.

**Imagens suportadas:**
+ [Imagem vLLM: hub.docker. com/r/vllm/vllm-openai](https://hub.docker.com/r/vllm/vllm-openai)
+ [Imagem LMCache: hub.docker. com/r/lmcache/vllm-openai](https://hub.docker.com/r/lmcache/vllm-openai/tags)
+ AWS Contêiner de aprendizado profundo: [gallery.ecr. aws/deep-aprendendo- containers/vllm](https://gallery.ecr.aws/deep-learning-containers/vllm)


| Versão do operador de inferência |  Add-on Versão Amazon EKS | Versão da imagem LMCache | Versão da imagem vLLM | 
| --- | --- | --- | --- | 
| >= v3.1.3 | >= v1.2.1-eksbuild.1 | >= v0.4.3 | >= v0.19.1 | 
| < v3.1.3 | < v1.2.1-eksbuild.1 | v0.3.9 postagem 2 | v0.11.1 | 

**nota**  
Recomendamos usar a versão v3.1.3 ou superior do operador de inferência com as versões correspondentes do LMCache e do vLLM mostradas na matriz de suporte. As versões mais recentes do LMCache oferecem suporte ao paralelismo de tensores, ao tratamento aprimorado de falhas e ao registro de trabalhadores de cache, que fornecem melhor robustez ao roteamento. KV-aware

### Validando o roteamento com reconhecimento de cache KV
<a name="sagemaker-hyperpod-model-deployment-kv-routing-validation"></a>

Depois de implantar um modelo com o KV-aware roteamento ativado, use as etapas a seguir para verificar se o roteamento está funcionando corretamente.

#### Verifique o registro do trabalhador
<a name="sagemaker-hyperpod-model-deployment-kv-routing-validation-registration"></a>

Verifique se os trabalhadores se registraram no roteador verificando os registros do roteador:

```
kubectl logs -n hyperpod-inference-system <router-pod> | grep -i "register"
```

Um registro saudável mostra:

```
INFO: Worker registered: lmcacheengineconfig_<hash>
```

#### Verifique os acessos ao cache nos registros do roteador
<a name="sagemaker-hyperpod-model-deployment-kv-routing-validation-cache-hits"></a>

Verifique se o roteador está usando KV-aware roteamento para direcionar solicitações:

```
kubectl logs -n hyperpod-inference-system <router-pod> | grep -i "kvaware\|Matched instance\|Lookup"
```

Quando o KV-aware roteamento está funcionando corretamente:

```
INFO: Routing request to lmcacheengineconfig_<hash> found by kvaware router
```

Quando o KV-aware roteamento não está funcionando (volta ao round-robin):

```
DEBUG: Matched instance url None
```

#### Verifique a inicialização do LMCache nos registros de trabalho
<a name="sagemaker-hyperpod-model-deployment-kv-routing-validation-lmcache"></a>

Verifique se o LMCache foi inicializado com êxito nos pods de trabalho:

```
kubectl logs -n <namespace> <worker-pod> | grep -i "LMCache"
```

Uma inicialização saudável mostra:

```
LMCache INFO: LMCacheManager initialized successfully
```

Se o LMCache falhar ao inicializar, você verá:

```
LMCache ERROR: Failed to initialize LMCacheManager components: . System will operate in degraded mode (recompute).
```

#### Verifique com as métricas da Grafana
<a name="sagemaker-hyperpod-model-deployment-kv-routing-validation-metrics"></a>

Com as métricas ativadas (`metrics.enabled: true`), as seguintes métricas do `/metrics` endpoint de trabalho do vLLM confirmam os acessos ao cache. Essas métricas devem mostrar valores altos quando o KV-aware roteamento está funcionando corretamente:


| Métrica | Description | 
| --- | --- | 
| vllm:prefix\_cache\_hits\_total / vllm:prefix\_cache\_queries\_total | Taxa de acerto do cache do prefixo da GPU (calculada como uma proporção) | 
| lmcache:num\_vllm\_hit\_tokens\_total | Número de tokens servidos pelo LMCache | 
| lmcache:num\_lookup\_hits\_total / lmcache:num\_lookup\_tokens\_total | Taxa de acerto de pesquisa do LMCache (calculada como uma proporção) | 
| lmcache:request\_cache\_hit\_rate | Per-request taxa de acerto do cache (histograma) |