Balanza de latón que pesa pilas de módulos de servidor de distintos tamaños, representando la atribución de costos por tenant

Costo por tenant en SaaS: cómo diseñar la atribución de costos

•12 min de lectura

Conocer el costo por tenant en SaaS te permite definir tus planes con datos y no por intuición. Construir el software es sobre todo una inversión única (explicamos esos rangos de precio en nuestra guía sobre cuánto cuesta el software a la medida en 2026). Operarlo es distinto: es un gasto que regresa cada mes y crece con cada cliente que sumas. Este artículo trata del sistema que te dice qué clientes generan esa factura mensual. Eso incluye el modelo de datos, el pipeline, las reglas de asignación, los trade-offs entre enfoques y los puntos donde suele fallar.

Por qué es difícil calcular el costo por tenant en SaaS

El propio artículo de AWS sobre cómo calcular costos por tenant en entornos SaaS lo dice claro: en entornos single-tenant el cálculo es directo, pero en un modelo pooled, donde los tenants comparten recursos, la atribución se vuelve mucho más difícil. Si cada tenant tiene su propia cuenta o sus propios recursos etiquetados, basta con leer la factura. Si un solo clúster de base de datos, una cola y una flota de contenedores atienden a todos, la factura no tiene ninguna columna de tenant.

La mayoría de los productos reales son híbridos: pooled para la mayoría de los clientes y silos para unos pocos clientes grandes. El AWS Well-Architected SaaS Lens describe la solución general: correlacionar los datos de consumo de cada tenant con los costos de infraestructura y automatizarlo con datos del Cost and Usage Report. En la práctica eso te da un sistema con tres entradas y una salida:

  • Datos de costo: lo que cobró el proveedor de nube, por recurso y por día.
  • Datos de consumo: lo que cada tenant usó realmente, emitido por tu aplicación.
  • Reglas de asignación: cómo repartir los costos que no puedes medir por tenant.
  • Salida: un libro diario de costos por tenant que suma exactamente lo mismo que la factura.

Clasifica cada dólar en tres clases de costo

Antes de escribir código, decide a qué clase pertenece cada línea de la factura. Esa decisión define todo lo demás.

  1. Costo directo. El recurso pertenece a un solo tenant: una base de datos dedicada, un bucket por tenant, un silo enterprise. Se atribuye con una etiqueta (tag) o un ID de cuenta.
  2. Costo compartido medido. Un recurso compartido donde puedes medir la parte de cada tenant con un indicador: peticiones, milisegundos de CPU, bytes almacenados, mensajes procesados, tokens de LLM. El costo se reparte en proporción a esa métrica.
  3. Costo compartido no medido (overhead). NAT gateways, observabilidad, runners de CI, el plano de control. Nadie los "usa" por petición. Necesitas una política explícita, y las opciones comunes son el reparto equitativo, los pesos por plan o un modelo híbrido donde los costos directos se asignan directo y los compartidos siguen al uso (esta guía de SaaS multi-tenant en AWS enumera esas tres).

Hay una decisión de diseño que vale la pena: reporta el overhead como una línea visible por tenant en lugar de mezclarlo sin que se note con los costos medidos. Cuando alguien pregunte por qué un tenant pequeño sale caro, vas a querer ver cuánto de eso viene de la política y cuánto del uso real.

Arquitectura del pipeline de atribución de costos por tenant

Exportación de facturación (diaria) ───┐
                                       ├──> Job de asignación (diario, idempotente) ──> tenant_cost_daily
Medición de uso (eventos→acumulados) ──┘                ^
Registro de tenants + reglas versionadas ───────────────┘

La fuente de costos

En AWS, la fuente de verdad es el Cost and Usage Report. La documentación del CUR describe Data Exports con CUR 2.0 como la forma nueva y recomendada de recibir datos detallados de costo y uso. Según las preguntas frecuentes de Data Exports, defines las exportaciones con SQL básico sobre tablas que provee AWS y se entregan de forma recurrente. Para atribuir por tenant importan dos opciones:

  • Incluir los IDs de recurso, que además agrega la columna de tags que necesitas para leer tenant_id.
  • Split cost allocation data, que crea líneas por tarea de ECS o por pod de Kubernetes. La referencia de columnas split line item indica que está limitado a Amazon ECS (incluido Fargate), AWS Batch y Amazon EKS. Las preguntas frecuentes también señalan que estos datos no están disponibles por ahora en la exportación FOCUS 1.2, así que elige CUR 2.0 si los necesitas.

Otras nubes tienen exportaciones de facturación equivalentes. El diseño de abajo no depende del proveedor, solo de tener un archivo diario, a nivel de línea, en tu data warehouse.

Tags para costos directos

Los tags definidos por el usuario no sirven para facturación hasta que los activas. Según la documentación de AWS sobre la activación de cost allocation tags, los tags recién aplicados pueden tardar hasta 24 horas en aparecer para activarse, y hasta otras 24 horas en activarse. La API UpdateCostAllocationTagsStatus permite activar tags en lote. No dependas de que alguien se acuerde de etiquetar. Hazlo obligatorio en tu infraestructura como código:

# Terraform: todo recurso en el silo de un tenant hereda estos tags
provider "aws" {
  alias  = "tenant"
  region = var.region
  default_tags {
    tags = {
      tenant_id   = var.tenant_id   # ID opaco, nunca el nombre del cliente
      cost_class  = "direct"
      environment = var.environment
    }
  }
}

Medición para recursos compartidos

Emite el uso donde el contexto del tenant ya es conocido y confiable, que normalmente es justo después de la autenticación. No escribas una fila por petición en tu base de datos transaccional. Agrega en memoria y guarda acumulados.

// Middleware estilo Express; req.tenant sale del token de autenticación, nunca del body
app.use((req, res, next) => {
  const start = process.hrtime.bigint();
  res.on("finish", () => {
    const ms = Number(process.hrtime.bigint() - start) / 1e6;
    usage.add(req.tenant.id, "api.requests", 1);
    usage.add(req.tenant.id, "api.ms", ms);
  });
  next();
});

El buffer se vacía cada pocos segundos con una llave de idempotencia, para que los reintentos después de un timeout no cuenten doble:

INSERT INTO usage_rollup (instance_id, flush_id, tenant_id, meter, hour, qty)
VALUES ($1, $2, $3, $4, $5, $6)
ON CONFLICT (instance_id, flush_id, tenant_id, meter, hour) DO NOTHING;

Los jobs en segundo plano deben llevar tenant_id en su payload y medir su propio trabajo. En funciones con LLM, registra los tokens que el proveedor devuelve en cada respuesta, asociados al tenant.

Modelo de datos

CREATE TABLE cost_line (
  usage_date     date        NOT NULL,
  service        text        NOT NULL,
  resource_id    text        NOT NULL,
  tenant_tag     text,                    -- null si no tiene tag
  net_cost       numeric(18,6) NOT NULL,  -- nunca float
  currency       char(3)     NOT NULL,
  export_version text        NOT NULL,
  PRIMARY KEY (usage_date, service, resource_id, export_version)
);

CREATE TABLE allocation_rule (
  service    text NOT NULL,
  cost_class text NOT NULL CHECK (cost_class IN ('direct','metered','overhead')),
  meter      text,              -- para metered: qué métrica reparte el costo
  policy     text,              -- para overhead: equal | proportional | tier_weight
  valid_from date NOT NULL,
  valid_to   date
);

CREATE TABLE tenant_cost_daily (
  usage_date date NOT NULL,
  tenant_id  text NOT NULL,     -- incluye el pseudo-tenant 'unallocated'
  service    text NOT NULL,
  cost_class text NOT NULL,
  amount     numeric(18,6) NOT NULL,
  currency   char(3) NOT NULL,
  run_id     uuid NOT NULL,
  PRIMARY KEY (usage_date, tenant_id, service, cost_class)
);

El pseudo-tenant unallocated es importante. Ahí van los recursos sin tag y los servicios sin datos de uso, así el libro siempre suma lo mismo que la factura y la diferencia queda a la vista.

El job de asignación

para cada día D en la ventana de recálculo:
  iniciar transacción
  borrar de tenant_cost_daily donde usage_date = D
  para cada servicio S con costo en D:
    regla = regla_activa(S, D)
    si regla.clase == direct:
      para cada línea L: sumar(L.tenant_tag si tenant_valido(L.tenant_tag) si no 'unallocated', L.net_cost)
    si regla.clase == metered:
      partes = uso(regla.meter, D) / suma(uso(regla.meter, D))
      si no hay uso: sumar('unallocated', costo(S, D))
      si no: para cada tenant t: sumar(t, costo(S, D) * partes[t])
    si no:  # overhead, después de direct y metered
      repartir(costo(S, D), regla.policy)
  redondear con el método del mayor residuo para que los centavos cuadren
  verificar suma(tenant_cost_daily en D) == suma(cost_line en D)
  confirmar transacción

Tres propiedades hacen que este job se pueda ejecutar una y otra vez sin riesgo:

  • Borrar y reemplazar por día dentro de una transacción. Volver a ejecutarlo da el mismo resultado, sin filas duplicadas ni días a medias.
  • Una ventana de recálculo, no solo "ayer". La documentación del CUR indica que AWS sigue actualizando los reportes después de que empieza la entrega. Trata los días pasados como mutables y recalcúlalos en cada ejecución.
  • Una verificación de balance. Si el total asignado no coincide con el total de origen, que falle de forma visible. Un libro de costos que se desvía en silencio es peor que no tener ninguno.

Kubernetes y otro cómputo compartido

Un pod en un deployment compartido atiende a muchos tenants, así que el costo por pod sigue siendo un costo compartido medido. Necesitas dos capas. Primero, obtener el costo del workload. Después, repartirlo con las métricas de tu aplicación. Para la primera capa tienes dos opciones:

Si usas un namespace por tenant para clientes grandes, esos namespaces se vuelven costos directos y solo los compartidos necesitan métricas.

Modos de falla que debes contemplar

  • Recursos sin tag o con tag incorrecto. Valida los valores contra el registro de tenants. Los valores desconocidos van a unallocated. Pon una alerta cuando la parte sin asignar pase un umbral que tú definas.
  • Datos de uso perdidos. Si un deploy tira un buffer en memoria, los tenants de esa instancia quedan subcontados y la parte de todos los demás se infla. Vacía el buffer seguido y considera un outbox durable para las métricas con las que cobras.
  • Descuentos y compromisos. Asigna el costo neto o efectivo, no el precio de lista. En CUR 2.0, split_line_item_net_split_cost se define como el costo efectivo de una tarea o pod después de todos los descuentos.
  • Cambios de reglas. Versiona las reglas con valid_from/valid_to. Cambiar una política no debería reescribir en silencio los márgenes del trimestre pasado.
  • Varias monedas. Guarda la moneda por línea y convierte solo al generar reportes, con un tipo de cambio registrado.

Seguridad y privacidad

  • Los cost allocation tags son visibles para cualquiera con acceso a facturación. Usa IDs de tenant opacos, nunca nombres ni correos de clientes.
  • Los datos de costo por tenant son comercialmente sensibles. Restringe quién los puede leer. Si se los muestras a los tenants (showback), aplica row-level security en la base de datos en lugar de filtrar en la capa de API.
  • Obtén siempre el tenant_id de la medición a partir de la sesión autenticada. Si un cliente puede fijarlo, un cliente puede mover costos.

Trade-offs entre enfoques

  • Cuenta o silo por tenant. Es la atribución más limpia, porque la factura ya viene separada (Scale Factory señala que encaja con productos de pocos tenants grandes). La carga operativa crece con el número de tenants.
  • Pooled con medición. La infraestructura es eficiente, pero la atribución es tan buena como tus métricas y el indicador que elijas.
  • Comprar o construir. OpenCost o una herramienta comercial de costos te da visibilidad rápido. Construye tu propio pipeline cuando el costo por tenant alimente precios, cuotas o lógica de cobro, porque entonces necesitas control total de las reglas.
  • Diario u horario. El detalle diario basta para analizar márgenes. El horario ayuda a detectar noisy neighbors, pero multiplica el almacenamiento y el tiempo de recálculo.

Errores comunes

  • Repartir toda la factura por número de peticiones, de modo que un tenant con reportes pesados sale tan barato como uno que solo hace health checks.
  • Usar float para dinero y después perseguir diferencias de redondeo contra la factura.
  • Descartar los costos sin tag en lugar de mantenerlos en un bucket unallocated.
  • Ejecutar el job solo para ayer y no recoger nunca las correcciones de la factura.
  • Esconder el overhead dentro de los costos medidos, lo que hace que los tenants pequeños parezcan no rentables por la razón equivocada.

Checklist

  1. Clasifica cada servicio facturado como direct, metered u overhead.
  2. Habilita una exportación de facturación a nivel de línea (CUR 2.0 en AWS) con IDs de recurso, y split cost data si usas contenedores.
  3. Haz obligatorios los tags tenant_id en IaC y actívalos en facturación.
  4. Mide los recursos compartidos desde el contexto autenticado, con vaciados idempotentes.
  5. Guarda las reglas con fechas de vigencia y el dinero como numeric.
  6. Ejecuta un job diario idempotente sobre una ventana de recálculo, con verificación de balance.
  7. Monitorea unallocated como métrica y pon alertas.
  8. Restringe el acceso a los datos de costo por tenant.

Si estás planeando un producto multi-tenant y quieres que la atribución de costos venga incluida desde el primer sprint en lugar de agregarla después, ese es el tipo de arquitectura que diseña y construye nuestro equipo de desarrollo de software a la medida.

Preguntas frecuentes

¿Necesito el costo por tenant antes de tener muchos clientes?

No necesitas el pipeline completo desde el primer día. Sí necesitas tenant_id en tus tags, logs y eventos de uso desde el inicio, porque agregar el contexto de tenant después es mucho más difícil que calcular los costos después.

¿Basta con AWS Cost Explorer para ver el costo por tenant?

Para recursos en silo con tags activados, muestra directamente el gasto por tenant. Para recursos compartidos no alcanza, porque la factura no tiene la dimensión de tenant. Necesitas el CUR cruzado con tus propios datos de uso, y el desglose por pod solo está disponible en el CUR.

¿Cómo atribuyo a cada tenant los costos de APIs de LLM?

Trátalos como un costo compartido medido. Registra el uso de tokens que el proveedor devuelve en cada llamada, asociado al tenant que la originó, y reparte la factura del proveedor en proporción a esos tokens.

Comentarios

Todavía no hay comentarios. Sé el primero en compartir lo que piensas.

Deja un comentario

Nunca se publica.