Reduce RU costs with strategic indexing (CosmosDB)

RU/s consumption impacta directamente en el coste de tus workloads con CosmosDB. Queries que usen indices consumen RU/s proporcionalmente al result size, mientras que queries que hacen full scans consumen RU/s proporcionalmente al data size.

Analyze query patterns BEFORE deisgning indexes

Antes de diseñar indices hay que entender como la app hace query de los datos. Haz review de las queries e identifica que propiedades aparecen en los WHERE, ORDER BY y funciones agregadas.

  • Filter properties: ¿Que propiedades aparecen en el WHERE? ¿Son equalidad = o rangos >?
  • Sort properties: ¿Que propiedades aparecen en el ORDER BY y con que orden?
  • Property combination: Que propiedades aparecen juntas? Algunas filtran por una propiedad y luego ordenan por otra?
  • Access frequency: Con que frecuencia se ejecutan cada una? priorizar las más frecuentes

Usar query metrics para identificar que indices hacen falta

CosmosDB ofrece query metrics para ver como de eficientes son las queries al usar indices. Si hay queries que tienen una mala performance, las metricas pueden ayudar a identificarlas.

El SDK devuelve las siguientes metricas:

  • index utilization: porcentaje de la query que usa indexes vs scanning
  • retrieved document count: numero de documentos obtenidos del storage. Comparar los obtenidos del storage vs los devueltos. Una diferencia alta indica un filtrado ineficiente
  • output document count: Numero de documentos devueltos en los resultados

ejemplo que obtiene las métricas

from azure.cosmos import CosmosClient

client = CosmosClient(endpoint, credential)
database = client.get_database_client("documents-db")
container = database.get_container_client("documents")

query = "SELECT * FROM c WHERE c.documentType = @type ORDER BY c.uploadDate DESC"
parameters = [{"name": "@type", "value": "pdf"}]

# Use response_hook to capture query metrics from response headers
query_metrics_output = {}

def response_hook(headers, results):
    query_metrics_output["metrics"] = headers.get("x-ms-documentdb-query-metrics", "")
    query_metrics_output["request_charge"] = headers.get("x-ms-request-charge", "")

results = container.query_items(
    query=query,
    parameters=parameters,
    populate_query_metrics=True,
    response_hook=response_hook
)

# Process results (this triggers the query execution and response_hook callback)
items = list(results)

# Access captured query metrics
print(f"Query metrics: {query_metrics_output.get('metrics', '')}")
print(f"Request charge: {query_metrics_output.get('request_charge', '')} RUs")

Excluir properties no usadas en las queries

IMPORTANTE

Las propiedades que la app lee pero no se usan para filtrar NO. NECESITAN. INDICES. Excluir datos como large text fields, binary data o array embeddings que almacenamos y mostramos pero no filtramos por ellos.

/IMPORTANTE

Incluir partition key en el index

La partition key enruta queries a particiones específicas. Aún así las queries que filtran por partition keys también se benefician de range indexes dentro de cada partición.

CosmosDB no indexa la partition key automáticamente cuando usas exclude-by-default.

Design composite indexes for common query combinations

Composite indexes dan los mayores beneficios para queries usadas frecuentemente. Analizar que combinaciones de propiedades aparecen juntas y crear composite indexes para esos patrones.

Priorizar composite indexes por:

  • Query frequency: queries que se ejecutan miles de veces al dia tienen prioridad sobre otras que apenas se ejecutan
  • Data volume: Queries con large datasets consumen más RU/s según su tamaño
  • Filter complexity: Queries con multiples filtros con alta cardinalidad se benefician más

Cada composite index añade overhead a las write ops. Crear docenas de composite indexes para edge cases aumenta el coste de escritura y no tiene por que mejorar el de lectura. Hacer focus en los 5-10 patrones de queries que más impacto tengan

Write-heavy vs read-heavy workloads

No todas las apps se benefician de igual manera de los indices. Una app que escriba mucho y apenas lea le perjudica tener indices. En cambio una app que apenas escribe y solo lee puede ver util crear muchos composite index para todos los casos.

Monitor index transformation progress

Al crear un indice, este no toma efecto hasta que el proceso de transformation termina en background. Asi podemos monitorizar el progreso del transformation para saber cuanto lleva

# Check indexing progress through container properties
container_properties = container.read()
indexing_policy = container_properties.get("indexingPolicy", {})

# The Azure portal shows transformation progress as a percentage
# SDK access provides the policy but not real-time progress
# Use Azure portal or CLI for detailed progress monitoring