Implement caching strategies (Key Vault)

Understand Key Vault throttling limits

Key Vault tiene throttling limits para proteger el servicio. Cuando esto pasa se devuelve HTTP 429 (Too Many Requests).

Para secretos, Key Vault soporta hasta 4000 GET per vault en 10s.
Los write se llevan a un limite de 300 colectivo en 10 segundos.

Son limites grandes pero que se pueden alcanzar rápidamente si una app llama get_secret() con cada input request. Esto lo solucionamos mediante caching.

Implement a time-based in-memory cache

El método más simple es guardar el secreto en memoria con un TTL. Esto se puede usar para secretos que cambian infrecuentemente. Una ventana de 15-60 mins es aceptable.

# Code fragment - focus on time-based caching pattern
import time
from azure.identity import DefaultAzureCredential
from azure.keyvault.secrets import SecretClient

class SecretCache:
    def __init__(self, vault_url, cache_ttl_seconds=900):
        credential = DefaultAzureCredential()
        self._client = SecretClient(vault_url=vault_url, credential=credential)
        self._cache = {}
        self._cache_ttl = cache_ttl_seconds

    def get_secret(self, secret_name):
        cached = self._cache.get(secret_name)
        now = time.monotonic()

        if cached and (now - cached["timestamp"]) < self._cache_ttl:
            return cached["value"]

        secret = self._client.get_secret(secret_name)
        self._cache[secret_name] = {
            "value": secret.value,
            "timestamp": now
        }
        return secret.value

El param cache_ttl_seconds controla el tiempo en segundos.

Invalidar la cache con Azure Event Grid

Time-based caching introduce una ventana de tiempo donde la app puede usar la vieja credencial tras una rotacion.

Para ventanas más ajustadas podemos suscribirnos al evento del Key Vault SecretNewVersionCreated a través de Azure Event Grid. Cuando se crea una nueva version se lanza este evento.

Entonces invalidamos la cache local y obtenemos el nuevo.

Este métodos es útil porque la cache solo se recarga cuando realmente hay un cambio, en vez de en un timer fijo.

Choose the right cache scope

El scope de tu cache determina cuantas llamadas a Key Vault hace tu app de manera colectiva.

Per-process cache

Método más simple. Cada app instance mantiene su propia in-memory cache. Funciona muy bien para stateless services donde cada instancia gestiona de manera independiente las caches de secretos.

Shared distributed cache

Usamos un external store como Managed Redis como capa intermedia entre la app y el key vault. Un único proceso lee el secreto del Key Vault y lo escribe en la cache compartida. El resto de instancias leen de la cache.

Añade complejidad e introduce dependencias de la cache compartida. Tambien almacenamos los secretos en un store independiente fuera del Key Vault (la cache), lo cual requiere su propio control de acceso y encriptación.

Application startup preloading

Obtenemos todos los secretos en startup y los guardamos en memoria por el lifetime del proceso. Funciona muy bien para servicios contenerizados donde las instancias se reinician periodicamente, y para secretos que raramente cambian.

# Code fragment - focus on startup preloading pattern
class AppConfig:
    def __init__(self, vault_url, secret_names):
        credential = DefaultAzureCredential()
        client = SecretClient(vault_url=vault_url, credential=credential)

        self._secrets = {}
        for name in secret_names:
            secret = client.get_secret(name)
            self._secrets[name] = secret.value

    def get(self, secret_name):
        return self._secrets.get(secret_name)

# At application startup
config = AppConfig(
    vault_url="https://kv-ragpipeline-prod.vault.azure.net/",
    secret_names=["openai-api-key", "cosmosdb-connection-string",
                  "blob-storage-key"]
)

# During request processing - no vault calls
api_key = config.get("openai-api-key")

Balance cache lifetime with security requirements

El cache lifetime que decidamos depende de la frecuencia de rotacion y la ventana de tiempo que sea aceptable tener secretos caducados hasta que se renueven.

Para keys que rotan cada 90 dias, hasta 1h de TTL es aceptable.

Para keys que son criticas lo mejor es poner un TTL de 5 mins o usar event-driven invalidation a través de Event Grid.

  • High-rotation secrets (daily/weekly): 5-15 mins TTL combinado con Event Grid
  • Standard (monthly/quarterly): 30-60 min TTL. Event Grid es beneficioso pero no critico
  • Low-rotation (annual/static): Startup preloading with periodic refresh (every few hours)

Handle throttling gracefully

Cuando tu app recibe HTTP 429 como respuesta del Key Vault, implementamos exponential backoff antes de reintentar

# Code fragment - focus on logging throttling events for cache tuning
import logging

logger = logging.getLogger("keyvault")

def get_secret_with_monitoring(cache, secret_name):
    try:
        return cache.get_secret(secret_name)
    except HttpResponseError as e:
        if e.status_code == 429:
            logger.warning(
                "Key Vault throttled request for '%s'. "
                "Consider increasing cache TTL.", secret_name
            )
        raise