Arquitectura de costos

1) Principios y funciones

Cost as a Feature. Precio - parte de UX/producto y soluciones arquitectónicas.
Responsabilidad compartida. Ingenieros, plataforma/DevEx, finanzas, producto - un único bucle de retroalimentación.
Una sola fuente de verdad. Catálogo de etiquetas/etiquetas, diccionario de costos y orígenes de datos.
Bucle «Observar → Optimizar → Controlar». Dashboards integrados, gates automáticos y políticas.

Roles: Arquitecto de valor, FinOps analista, Propietario del producto, Equipo de plataforma.

2) Modelo de datos de valor

• Por API: '$/1000 consultas', '$/milisegundo CPU', '$/GB egress'.
• Para los datos: '$/GB-mes de almacenamiento', '$/solicitud a la DB', '$/millones de mensajes'.
• Para el usuario: 'CAC', 'ARPU/ARPPU', 'Gross Margin', 'LTV: CAC'.
• Por flujo: '$/transacción', '$/deboy', '$/prueba de ejecución'.

cost_record {
ts, provider, account, region, service, usage_qty, usage_unit,
list_price, net_price, discounts,
tags: { env, team, product, feature, tenant, cost_center, pii, tier },
resource_id, allocation_keys: {req_id?, tenant_id?, dataset?}
}

Etiquetas de oro (obligatorias): 'env', 'team', 'product', 'feature', 'cost _ center', 'owner', 'pii', 'tier (hot/warm/cold',' region '.

3) Atribución: showback/chargeback

Showback: informes transparentes por equipos/fichas sin tarificación de transferencias internas.
Chargeback: distribución por reglas: costos directos → propietario; recursos compartidos - por claves: RPS, CPU-segundos, reloj GB, volumen de eventos.

cluster_cost = sum(provider_cost where resource in "k8s-node:")
weights = { service: cpu_seconds(service)/total_cpu_seconds }
for service in services:
charge[service] = direct_cost(service) + cluster_cost weights[service]

4) Políticas y Getas de Valor (Policy as Code)

Reglas de presupuesto: límites por 'env/team/feature'; auto-alert/unidad de deploy cuando se proyecta un exceso.
Requisitos de etiqueta: recursos sin etiquetas obligatorias - deny en el controlador admission.
Límites de perfil: prohibición de grandes máquinas en 'dev', TTL en recursos ephemerales, reservas mínimas.

yaml policy: require-tags-and-limits deny_if_missing_tags: [team, product, env, cost_center, owner]
constraints:
env==dev:
max_instance_type: "c6i. large"
ttl_hours: 72

5) Computación: patrones de reducción de costos

Tamaño correcto (rightsizing): selección automática de vCPU/RAM basada en p95/p99, estacionalidad y headroom.
Auto-escalado: target-based (CPU/RPS/lag), función de paso; protección contra thrash a través de histéresis.
Selección del modelo de precios: on-demand vs spot/preemptible, Reserved Instances/Savings Plans; mezcla para críticos y fondos.
Transportadores de batch: ventanas de carga «barata», compresión de batch, colas prioritarias.
Caché y intercambio de consultas: reducción de las lecturas de fuentes caras.
Edge/optimización de red: HTTP/2/3, keep-alive, compresión, CDN.

if rps > target1. 2 for 3m: replicas += ceil(rps/target); cool_down 5m if rps < target0. 6 for 10m: replicas = max(min_replicas, replicas-1)

6) Almacenamiento y datos: caliente/caliente/frío

Tirar: datos calientes (acceso instantáneo), cálido (consultas raras), frío/archivo.
Formatos: columnas (Parquet/ORC) para análisis, compresión y envío por fecha/clave.
TTL/ILM: política de vida del conjunto: 'hot 7d → warm 90d → cold 365d → delete'.
Capa de caché: Redis/Memcached con request coalescing, protección contra miss-tormentas.
Cuotas y presupuestos de solicitudes: límites predecibles para los joins/scans caros.

yaml dataset: events_main lifecycle:
- phase: hot; duration: 7d; storage: nvme
- phase: warm; duration: 90d; storage: ssd; compress: zstd
- phase: cold; duration: 365d; storage: object; glacier: true
- phase: purge; duration: 0d

7) Red y egresos

Minimice el tráfico interregional: copias locales y agregación en el borde.
CDN y cachés: origin-shield, TTL razonable, validación/discapacidad.
Protocolos: binario (gRPC) para chatear, compresión sólo donde es rentable.
Dedoop de eventos y filtrado en el productor: «no llevamos basura».

8) Observabilidad y costo de los ERE

Las tarjetas de valor de telemetría son: '$/log-GB', '$/métrica-serie', '$/pista'.
Muestreo y agregación: sampling tail-based, métricas de descarga, retoque en importancia (métricas SLO - prioridad superior).
Dedup logs y «logs-health»: prohibición de PD, reducción de campos fantasma, límites al tamaño del evento.

9) CI/CD y entornos de prueba

Ephemeral-stands con auto-TTL, el entorno «por PR».
Perf-smoke en PR: pasos cortos para una estimación temprana del «costo de la consulta».
Caché/artefactos: reutilización de contenedores, compilaciones.
Gates: el bild/deploy se rechaza si el «precio de latencia »/RPS ha empeorado con respecto a la base> X%.

10) Predicciones, presupuestos y anomalías

Forecasts: estacionalidad/tendencia, eventos (campañas, lanzamientos), correlación «fichi → costo».
Presupuestos por nivel: team/product/feature/tenant; escalada al 80/90/100%.
Anomalías: picos repentinos en el servicio/región/cuenta; «bisecto» automático y reversión de la bandera.

if forecast(month_end_cost) > budget0. 9 and variance ↑:
alert(team_owner)
suggest: rightsizing + RI/SP coverage + ILM tighten

11) Contratación y comercio

Planes RI/Ahorro/Uso combinado: cubrir una base estable; Monitor la cobertura y los porcentajes «unutilizados».
Spot/Preemptible: tareas de fondo y tolerant-workflow; checkpointing y reinicio rápido.
Licencias y SaaS: matriz ROI, referencia de alternativas, «vendor fitness review» periódico.

12) Multiarrendamiento y facturación

Partitioning by tenant: separación lógica/física, límites y cuotas.
Tenant-aware limites/correcaps: previenen a un «vecino ruidoso».
Modelos de uso: facturación por eventos, RPS, volúmenes de datos; métricas transparentes para los clientes.

13) Seguridad y cumplimiento como factor de costo

Crypto y almacenamiento: FPE/llaves - costos de KMS/HSM; optimizar la frecuencia de las operaciones.
Copias regulatorias: separar los retoques «legales» de los operativos; el archivo es más barato que el almacenamiento «cálido eterno».
Minimización de datos: menos datos - menos cuentas y riesgos.

14) Anti-patrones de ingeniería (caro!)

API de chat sin batch ni caché.
Colas ilimitadas y paralelismo ilimitado: aumento de la latencia y la factura.
TTL cero y llaves calientes sin coalescencia.
«Todopoderosos» dashboards con millones de métricas de la serie.
Los recursos sin etiquetas → gasto «gris» sin propietario.
La ausencia de ILM/TTL → el crecimiento eterno del almacenamiento.

15) Herramientas y artefactos (vendor-neutral)

Directorio de etiquetas (schema + linter en CI).
Extractor de costo (agregación usage/billing, normalización en un solo formato).
Dashboards unit economics (valor API, valor dataset, valor tenant).
Correcciones de automóviles (rightsizer, recomendador RI/SP, encorvador ILM).
Pólizas de valor (admission/OPA/Kyverno) y «líneas rojas» del presupuesto.

16) Mini recetas

Fórmula de «precios de consulta» (HTTP)

request_cost = (cpu_ms $/cpu_ms) +
(mem_mb_s $/mb_s) +
(egress_mb $/mb) +
(db_calls $/call) +
(cache_ops $/op miss_penalty)

Auditoría rápida del

Los 3 mejores endpoints de viaje en $/1000 req.
Hit/miss caché y claves de «tormenta».
Listas de recursos sin etiquetas.
ILM y retiro de datasets.
Cobertura RI/SP (%).

Polisi Retry Economy

retry = min(3, floor(budget_ms / (base_timeout_ms 1. 5^attempt)))
jitter = uniform(0. 5..1. 5)

17) Check-list del arquitecto del valor

1. ¿Definidas las métricas de unidad ('$/req', '$/GB-month', '$/txn') y los propietarios?
2. ¿La política de etiquetas se enforcó? ¿Están bloqueados los recursos sin etiquetas?
3. ¿Se han implementado showback/chargeback e informes de productos/phichs?
4. Auto scale y rightsizing están configurados, headroom definido?
5. ¿Se están procesando los datos (hot/warm/cold), se están aplicando ILM/TTL?
6. ¿Se minimizan los flujos egresos e interregionales? ¿CDN/caché habilitado?
7. ¿Se ha optimizado la observabilidad (sampling, retention, downsampling)?
8. ¿Las puertas de CI/CD están activas para revertir el costo y los controles de políticas?
9. ¿Se automatizan las proyecciones/presupuestos/análisis de anomalías?
10. ¿La mezcla RI/SP/Spot cubre las cargas básicas?
11. ¿Hay cuotas, límites y métricas de uso transparentes para multi-tenant?
12. ¿Documentado por FinOps runbook y plan mensual de revisión de costos?

Conclusión

La arquitectura de valor no es «ahorrar a toda costa», sino gestionar el valor: cuánto cuesta cada milisegundo y qué ingresos genera. Al integrar el costo en la arquitectura, los procesos y las herramientas (etiquetas, políticas, gateways, dashboards, ILM, auto skale), se obtiene una plataforma donde las decisiones se toman en función de las métricas y la economía en lugar de la intuición. Esto acelera el producto, reduce los riesgos y hace que el negocio sea previsiblemente rentable.