# Escalado y costo

> Cuánto cuesta al mes un motor con alojamiento propio para un proyecto pequeño y uno mediano, con la aritmética, qué mueve la factura, los primeros límites que encuentras, y cuándo pasar de un proceso a varios o a funciones.

Aplica a: el motor de Sypnia (código abierto, en tu propia infraestructura). Estado: al lanzar.  
Fuente: https://docs.sypnia.com/es/self-hosting/scaling-and-cost/

Para agentes: Costo y capacidad de un motor de Sypnia con alojamiento propio: qué mueve el costo y el ajuste que controla cada cosa, totales mensuales estimados para un proyecto pequeño (4 millones de eventos al mes, cerca de USD 22 en AWS) y uno mediano (40 millones, cerca de USD 60 a 85), tamaño del servidor para Docker, las señales de que un despliegue está en su límite, la aritmética de conexiones a la base de datos, cómo dividir un proceso en roles, y cuándo usar la forma de funciones en AWS. Todas las cifras son estimaciones o mediciones del sistema del que sale el motor, y lo dicen.

**\[Motor]** Esta página es para quien paga un motor con alojamiento propio, o tiene que decir cuánto va a costar antes de que exista. En Sypnia Cloud pagas un plan, y la capacidad es trabajo nuestro: ver [Planes y límites](https://docs.sypnia.com/es/cloud/plans-and-limits).

> **Advertencia: Estimaciones, no mediciones de este motor**
>
> El motor no está publicado, así que nada de aquí se midió en él. Cada cifra es una de tres cosas, y dice cuál: un **presupuesto** que el diseño debe cumplir, una **estimación** hecha con precios publicados y con su aritmética, o una cifra **medida en el sistema del que sale este motor**. Los precios son los de pago por uso publicados para `us-east-1` cuando se escribió esto. Rehaz las cuentas con los precios de hoy y con tu propio tráfico.

## Qué mueve la factura

En el orden en que lo vas a sentir:

| Factor                                  | Crece con                                                                                                                                                                                                                                  | Qué puedes cambiar                                                                                                                                                    |
| --------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **La base de datos**                    | Casi nada: es un precio fijo al mes, y en tamaños pequeños es la línea más grande.                                                                                                                                                         | Trae un Postgres que ya pagues. Sirve cualquier Postgres 15 o posterior, con una base de datos propia.                                                                |
| **Las escrituras al bucket**            | Las sesiones grabadas (una escritura por cada 10 segundos de grabación), las sesiones (sus archivos se vuelven a escribir mientras crecen) y los despliegues (una escritura por source map). No los eventos: esos se agrupan en segmentos. | `SYPNIA_REPLAY_SAMPLE_RATE` para los proyectos nuevos, o el `settings.replay.sample_rate` de cada proyecto. Sube source maps solo para los entornos que alguien mira. |
| **El almacenamiento en el bucket**      | Eventos × días guardados, y grabaciones × días guardados. Las grabaciones son cerca de tres cuartas partes.                                                                                                                                | `SYPNIA_RETENTION_REPLAYS_DAYS`, `SYPNIA_RETENTION_EVENTS_DAYS`.                                                                                                      |
| **El cómputo**                          | En AWS, las peticiones y los segundos del worker. En un servidor, nada hasta que el servidor se llena.                                                                                                                                     | La forma en que despliegas.                                                                                                                                           |
| **El modelo**                           | Los problemas que son nuevos, crecen o vuelven. No el tráfico.                                                                                                                                                                             | `SYPNIA_AI_MAX_ANALYSES_PER_DAY`, `SYPNIA_AI_WEEKLY_SUGGESTIONS`, y el modelo que elijas.                                                                             |
| **Los logs**                            | Las peticiones, si registras cada una.                                                                                                                                                                                                     | Deja `SYPNIA_LOG_LEVEL` en `info`.                                                                                                                                    |
| **Los datos que salen de tu proveedor** | Ver grabaciones: cada una la descarga el navegador que la reproduce.                                                                                                                                                                       | Nada que configurar. Es el tamaño de las grabaciones que ves.                                                                                                         |

Dos de estas vienen de la experiencia, medidas en el sistema del que sale este motor:

- **Las escrituras cuestan más que el almacenamiento.** De USD 3,81 de almacenamiento de objetos en 12 días, USD 2,73 fueron escrituras: 552 mil, la mayoría de source maps subidos en cada despliegue de un entorno de desarrollo. La misma cuenta guardaba 93 GB por cerca de USD 2 al mes.
- **Un despliegue de una app grande son 965 source maps y 109 MB.** Veinte despliegues al mes son 19.300 escrituras y 2 GB.

Para ponerle tope a lo que un proyecto te puede costar, envíe lo que envíe, configura `SYPNIA_QUOTA_EVENTS_PER_MONTH` y `SYPNIA_QUOTA_REPLAYS_PER_MONTH`. En el límite se les dice a los SDK que envíen solo fallas, se crea una alerta al 80 % y al 100 %, y nada se descarta en silencio. Ver [Muestreo y cuotas](https://docs.sypnia.com/es/sdks/sampling-and-quotas).

## Dos proyectos de ejemplo

| Al mes                                                                  | Pequeño                     | Mediano         |
| ----------------------------------------------------------------------- | --------------------------- | --------------- |
| Sesiones                                                                | 30.000 (1.000 al día)       | 300.000         |
| Eventos                                                                 | 4 millones (130.000 al día) | 40 millones     |
| Lotes enviados a la ingesta (30 por sesión)                             | 0,9 millones                | 9 millones      |
| Fragmentos de grabación (15 % de las sesiones grabadas × 22 fragmentos) | 0,1 millones                | 1 millón        |
| En el bucket cuando la retención ya se llenó                            | Cerca de 8 GB               | Cerca de 80 GB  |
| En Postgres                                                             | Cerca de 1,5 GB             | Cerca de 2,5 GB |

Pequeño es el tamaño medido en el sistema del que sale este motor: de 110 a 150 mil registros y cerca de mil sesiones al día. Mediano es diez veces eso. Los tamaños vienen de [Estructura del almacenamiento](https://docs.sypnia.com/es/self-hosting/storage-layout#qu%C3%A9-tan-grande-se-pone).

## En AWS

La aritmética línea por línea, con los precios usados, está en [Formas de despliegue](https://docs.sypnia.com/es/architecture/deployment-shapes). Sumada por tipo, en USD al mes:

|                                              | Pequeño  | Mediano       | Qué es                                                                                                           |
| -------------------------------------------- | -------- | ------------- | ---------------------------------------------------------------------------------------------------------------- |
| Funciones                                    | 3,31     | 15,26         | Las peticiones a `ingest`, y los segundos que corren `ingest` y `worker`                                         |
| Cola                                         | 0,60     | 4,00          | Un envío por lote, y las lecturas del worker                                                                     |
| Bucket: escrituras, lecturas, almacenamiento | 3,52     | 14,34         | Las escrituras son 2,10 y 10,50 de eso                                                                           |
| Logs                                         | 0,50     | 2,00          | Los éxitos muestreados al 1 %                                                                                    |
| La dirección                                 | 0,00     | 0,00          | Dentro de la franquicia gratuita del proveedor, de 10 millones de peticiones al mes                              |
| **El motor, sin Postgres**                   | **≈ 8**  | **≈ 36**      |                                                                                                                  |
| Postgres                                     | ≈ 14     | 25 a 50       | La instancia administrada más pequeña con 1 GB de memoria y 20 GB de disco; de 2 a 4 GB de memoria en el mediano |
| **Total**                                    | **≈ 22** | **≈ 60 a 85** |                                                                                                                  |

Tres cosas para leer ahí:

1. **En tamaños pequeños estás pagando una base de datos.** Si ya tienes un Postgres con espacio, el motor cuesta cerca de USD 8 al mes.
2. **Recibir es casi gratis.** Aceptar un millón de lotes cuesta menos de 40 centavos.
3. **Un motor sin tráfico no cuesta casi nada, salvo la base de datos.** Por eso esta forma le sirve bien a un motor de pruebas, o a un tráfico que llega por ráfagas.

La franquicia gratuita de AWS para funciones, 400.000 GB-segundo y un millón de peticiones al mes, cubre casi todas las líneas de funciones del proyecto pequeño.

Lo que no está en estos totales:

| Extra                                       | Cerca de                                                                                                                                                           | Cuándo                                                                                                                    |
| ------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------- |
| El modelo                                   | El precio de tu proveedor por unos pocos miles de tokens de entrada y máximo dos mil de salida, por análisis. Máximo 100 análisis al día por proyecto por defecto. | Cuando conectas uno. Medido en el sistema del que sale esto: una corrida semanal de sugerencias costó de USD 0,08 a 0,20. |
| Una dirección pública para la base de datos | USD 3,65 al mes (0,005 la hora × 730)                                                                                                                              | Cuando la plantilla crea la base de datos.                                                                                |
| Datos que salen de AWS                      | USD 0,09 por GB después de los primeros 100 GB al mes                                                                                                              | Cuando ves grabaciones o lees mucho por la API.                                                                           |
| Una puerta NAT                              | USD 33 al mes, más el tráfico                                                                                                                                      | Solo si tú mismo pasas las funciones a una red privada. La plantilla no lo hace.                                          |
| Un firewall web en la dirección             | Desde USD 6 al mes                                                                                                                                                 | Solo si agregas uno para [proteger la Consola](https://docs.sypnia.com/es/self-hosting/console#protegerla).               |

Como referencia, el diseño del sistema del que sale este motor estimó su propia factura en USD 15 a 25 al mes con un millón de eventos al día, con una base de datos que compartía con su app, así que la base de datos no está en ese número.

## En un servidor con Docker

Un servidor no tiene precio por petición. Pagas por su tamaño, y la pregunta es qué tamaño.

| Qué necesita memoria                                                                                            | Presupuesto                                                |
| --------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------- |
| El motor: dos proyectos en proceso (2 × 256 MB), el búfer de ingesta (32 MiB), la caché de source maps (200 MB) | 1 GB es cómodo, 2 GB deja margen                           |
| Postgres                                                                                                        | 1 GB para el proyecto pequeño, de 2 a 4 GB para el mediano |
| MinIO                                                                                                           | 1 GB                                                       |
| El sistema y Caddy                                                                                              | 0,5 GB                                                     |

Un núcleo de CPU le basta al motor en el tamaño pequeño: su trabajo es esperar al bucket y a la base de datos, no calcular.

|                                           | Pequeño                                                                                                | Mediano                                                               |
| ----------------------------------------- | ------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------- |
| Servidor                                  | 2 vCPU, 4 GB de memoria                                                                                | 4 vCPU, 8 GB de memoria                                               |
| Disco                                     | 40 GB: 8 GB de bucket, 1,5 GB de base de datos, source maps, espacio para crecer                       | 160 GB: 80 GB de bucket, 2,5 GB de base de datos, espacio para crecer |
| Precio de ejemplo, por uso en `us-east-1` | Una instancia arm64 de ese tamaño a USD 0,0336 la hora × 730 = 24,50, más 40 GB de disco × 0,08 = 3,20 | USD 0,0672 la hora × 730 = 49,10, más 160 GB × 0,08 = 12,80           |
| **Total**                                 | **≈ USD 28**                                                                                           | **≈ USD 62**                                                          |

Los proveedores que venden servidores a precio fijo suelen ser más baratos para el mismo tamaño; un compromiso de un año baja el precio por uso cerca de un tercio. Con un bucket alojado en vez de MinIO, toma la línea del bucket de la tabla de AWS (USD 3,52 o 14,34) y un disco más pequeño.

Un servidor es también un único punto de falla. Si se detiene, los SDK reintentan un rato corto y luego descartan lo que tienen, y nada te avisa, porque el motor que lo haría es el que se detuvo. Vigila `/healthz` desde otro lugar.

## Cuál forma cuesta menos

Por millón de eventos, las líneas del motor en AWS dan cerca de USD 2 en el tamaño pequeño (8 ÷ 4) y USD 0,90 en el mediano (36 ÷ 40), y se quedan cerca de eso cuando el tráfico crece. El costo por evento de un servidor baja hasta que el servidor se llena, y entonces salta al tamaño siguiente.

- **Tráfico pequeño o por ráfagas:** funciones. Pagas por lo que llega.
- **Tráfico grande y parejo:** servidores, con un bucket alojado.
- **En el medio:** los dos totales de arriba están a pocos dólares uno del otro. Elige por lo que prefieras operar, no por el precio.

No tenemos un punto de cruce medido. Se publicará aquí cuando el motor haya corrido en los dos tamaños.

## Los primeros límites que encuentras

Cada límite tiene una señal que puedes ver sin adivinar.

| Señal                                                                                          | Qué significa                                                                                                  | Qué hacer                                                                                                      |
| ---------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------- |
| La ingesta responde `503` con `Retry-After: 2`                                                 | Hay más de 32 MiB de eventos esperando a ser escritos: el bucket está lento, o al proceso no le queda CPU.     | Un disco más rápido bajo MinIO, o un bucket alojado. Luego [corre la ingesta aparte](#de-un-proceso-a-varios). |
| `data_through` en `GET /v1/summary` tiene más de 10 minutos, o hay una alerta «Motor fallando» | El worker no da abasto. Los problemas siguen apareciendo a tiempo por un rato; los números se atrasan primero. | Sube `SYPNIA_PROCESSING_CONCURRENCY` (cada paso necesita 256 MB más), o corre un segundo worker.               |
| La API responde `503` con `Retry-After`                                                        | La base de datos no tiene conexiones libres.                                                                   | Ver [Conexiones a la base de datos](#conexiones-a-la-base-de-datos).                                           |
| La hora de un proyecto queda marcada como fallida y nombrada en una alerta «Motor fallando»    | Un proyecto envía en una hora más de lo que una pasada puede tener en memoria.                                 | Dale más memoria al worker, o ponle una cuota a ese proyecto.                                                  |
| El disco se llena                                                                              | Las grabaciones, casi siempre.                                                                                 | `SYPNIA_RETENTION_REPLAYS_DAYS`, y luego `sypnia aggregate --task retention`.                                  |
| Todo se pone lento a las mismas horas cada día                                                 | El trabajo diario (Parquet, retención, particiones) de las 02:30 UTC comparte la máquina.                      | Más memoria, o un worker aparte.                                                                               |

Presupuestos que el diseño debe cumplir, no mediciones: una hora cargada de 60.000 eventos y 1.000 sesiones de un proyecto se procesa con cerca de 40 MB de memoria, y diez veces eso, 600.000 eventos y 10.000 sesiones, con cerca de 110 MB. La aritmética está en [Agregación](https://docs.sypnia.com/es/architecture/aggregation). En AWS, 40 copias de la función de ingesta a 50 ms por petición aceptan cerca de 800 lotes por segundo; el proyecto mediano envía 3,5 por segundo.

## Conexiones a la base de datos

Este es el límite que se encuentra primero con funciones, y el sistema del que sale este motor también lo encontró: 13 conexiones rechazadas en dos minutos, cuando cada copia de una función abría su propio grupo de conexiones.

El total es `SYPNIA_DATABASE_MAX_CONNECTIONS` por el número de procesos, o de copias de una función, que corren a la vez.

| Forma                 | Aritmética                                                            | Total     |
| --------------------- | --------------------------------------------------------------------- | --------- |
| Un proceso            | 10, el valor por defecto                                              | 10        |
| Tres procesos por rol | 3 × 10                                                                | 30        |
| La plantilla de AWS   | `ingest`: 40 copias × 1. `api`: 20 copias × 2. `worker`: 2 copias × 3 | Máximo 86 |

Un Postgres administrado con 1 GB de memoria acepta cerca de 100 conexiones, así que los valores por defecto de la plantilla caben en la instancia más pequeña con poco margen. Cuando la API empieza a responder `503`:

- dale más memoria a la base de datos, lo que sube su límite, o
- ponle delante un agrupador de conexiones (pooler), o
- baja el número de copias en la plantilla, si prefieres una API más lenta a una base de datos más grande.

Cuando la base de datos rechaza una conexión, el motor responde `503` con `Retry-After` de inmediato. No encola y no se cae.

## De un proceso a varios

**Al final tendrás:** la ingesta, la API y el worker como procesos separados contra la misma base de datos y el mismo bucket, para poder dimensionar y reiniciar cada uno por separado.

### 1. Deja de migrar al arrancar

Varios procesos no deben migrar en el mismo momento. Pon esto en todos, y corre `sypnia migrate` una vez en cada despliegue, antes de que arranquen.

```bash
SYPNIA_AUTO_MIGRATE=false
```

### 2. Arranca un proceso por rol

La misma imagen y la misma configuración, con un rol distinto cada uno:

```bash
sypnia serve --role ingest --listen 0.0.0.0:8081
sypnia serve --role api    --listen 0.0.0.0:8082
sypnia serve --role worker
```

**Deberías ver:**Cada proceso imprime su rol en la primera línea, como `sypnia 1.0.0  role=ingest  listen=0.0.0.0:8081`, y termina con `ready`.

### 3. Manda cada ruta a su proceso

En tu proxy, bajo la única URL base:

| Ruta                                       | Va a                  |
| ------------------------------------------ | --------------------- |
| `/v1/ingest/*`, `/v1/otlp/*`, `/v1/sdk.js` | Los procesos `ingest` |
| Todo lo demás: `/v1/*`, `/mcp`, `/console` | El proceso `api`      |

**Deberías ver:**`curl -i <tu URL base>/healthz` responde `200`, y `sypnia doctor` pasa cuando se corre junto a cualquiera de los procesos.

Qué cambia cuando divides:

- **Corre tantos procesos `ingest` como necesites.** No comparten nada más que el bucket.
- **Dos workers son seguros.** Nunca cuentan nada dos veces; el segundo sobre todo acorta la espera después de un reinicio.
- **Los límites de peticiones se cuentan por proceso**, así que el límite real es el ajuste por el número de procesos.
- **Los tiempos.** Con la ingesta y el worker separados, el worker encuentra un segmento nuevo en su siguiente pasada, máximo 30 segundos después, no de inmediato. Un problema nuevo sigue apareciendo en menos de 2 minutos, y los números en menos de 10.

## De procesos a funciones

Pasa a la [plantilla de AWS](https://docs.sypnia.com/es/self-hosting/deploy-aws) cuando el tráfico llega en ráfagas que un servidor dimensionado para el promedio no aguanta, cuando prefieres no parchar ni vigilar servidores, o cuando el motor no tiene nada que hacer la mayor parte del día.

Las dos formas leen la misma estructura del bucket y las mismas tablas, así que mudarse es apuntar la otra forma a los mismos datos: despliega la plantilla con `DatabaseUrl` apuntando a tu base de datos, [copia el bucket](https://docs.sypnia.com/es/self-hosting/storage-layout#pasar-a-otro-bucket) al que creó el stack, y luego cambia el registro DNS. El camino de vuelta es el mismo.

## Lo que todavía no se sabe

- Cuánto corren de verdad las funciones. Las líneas de funciones de arriba suponen 50 ms para una petición de ingesta y de 0,5 a 2 segundos para cada despertar del worker.
- Qué tan grandes son los archivos Parquet. Están presupuestados con el tamaño de los eventos crudos.
- Cuánto aguanta un solo proceso antes de que haya que dividirlo. Las señales de arriba te dicen cuándo; el número se publicará cuando esté medido.

## Relacionado
