Una implementación de referencia en AWS, servicio por servicio
Cada servicio de AWS que usa el motor, qué hace, qué parte del motor corre en él y si esa parte es Rust o un servicio administrado; una solicitud seguida por los servicios reales; la plantilla; y el modelo de costos con su aritmética, hasta lo que cuesta un proyecto gratuito.
En esta página
- Los servicios
- Dónde está el Rust, y dónde está la lógica
- De crates a funciones a servicios
- Una solicitud por los servicios reales
- Límites y ajustes en un solo lugar
- La plantilla
- Postgres: cuál, y por qué
- El modelo de costos
- Precios usados
- Un despliegue en reposo
- Costos unitarios
- Dos ejemplos de alojamiento propio
- Un proyecto en el plan Free de Sypnia Cloud
- Preguntas que este modelo deja abiertas
- Qué cambió frente al sistema del que sale
- Sigue
Formas de despliegue dice que el motor puede correr como funciones en AWS. Esta página es ese despliegue con nombres propios: qué servicio de AWS hace qué, dónde corre el código en Rust, dónde vive la lógica del motor, a qué está limitado cada servicio y cuánto cuesta. Es el despliegue que crea la plantilla sypnia-aws.yaml, y el que corre Sypnia Cloud Nube.
Los servicios
Nueve servicios de AWS. Uno de ellos, Lambda, corre el código del motor, en tres funciones. La última columna responde «¿esto es Rust, o esto es Amazon?».
| Servicio de AWS | Qué hace aquí | Qué parte del motor | Código en Rust, o administrado |
|---|---|---|---|
| Amazon CloudFront | La única dirección HTTPS. Envía /v1/ingest/*, /v1/otlp/* y /v1/sdk.js a la función de ingesta y todo lo demás a la función de la API. Solo guarda en caché /v1/sdk.js | Ninguna. Reenvía | Administrado. Configuración: dos reglas de ruta |
AWS Lambda, función sypnia-ingest | Recibe lo que envían los SDK | Ingesta: las siete puertas, y luego el lote va a la cola; los fragmentos de grabación y las capturas van al Bucket | Rust: el binario sypnia con SYPNIA_ROLE=ingest |
AWS Lambda, función sypnia-worker | Hace todo el trabajo que no es una solicitud | El worker: escribir segmentos, la Vía rápida, la Consolidación, las tareas del agente, Alertas y webhooks, comprobaciones de disponibilidad, retención, Parquet | Rust: el mismo binario con SYPNIA_ROLE=worker |
AWS Lambda, función sypnia-api | Les responde a las personas y a los agentes de código | La API, el servidor MCP y la Consola | Rust: el mismo binario con SYPNIA_ROLE=api |
| Amazon SQS, la cola de entrada y su cola de mensajes fallidos | Guarda los lotes validados hasta que el worker los escribió; estaciona los que fallaron cinco veces | Ninguna. Es el búfer que una función no puede tener en memoria | Administrado. Configuración: retención, tiempo de invisibilidad, maxReceiveCount |
| Amazon EventBridge Scheduler | Despierta al worker cada minuto | Ninguna. El worker decide qué toca | Administrado. Configuración: rate(1 minute) |
| Amazon S3 | El Bucket: segmentos, archivos por sesión, fragmentos de grabación, capturas, source maps, Parquet | Ninguna. Las llaves las arma el motor; la retención es la tarea diaria del motor | Administrado. Configuración: privado, cifrado, una regla para cargas sin terminar, CORS para los enlaces de grabaciones |
| Amazon RDS para PostgreSQL | Postgres: el registro, los problemas, los números, el índice de sesiones, las alertas, las tareas | Ninguna. Sin procedimientos almacenados, sin disparadores, sin extensiones | Administrado. O cualquier Postgres 15 o posterior tuyo |
| AWS Secrets Manager | Guarda la contraseña generada de la base de datos que crea la plantilla | Ninguna | Administrado |
| Amazon CloudWatch | Un grupo de logs por función, guardados 30 días; tres alarmas | Ninguna. Las alarmas vigilan el motor desde afuera | Administrado. Configuración: tres umbrales |
| AWS IAM | Un rol por función, cada uno con lo mínimo que necesita | Ninguna | Administrado |
No se usan, a propósito: ni balanceador, ni API gateway, ni clúster de contenedores, ni NAT gateway, ni flujo de datos, ni caché, ni servicio de búsqueda, ni servicio de flujos de trabajo, ni una segunda base de datos.
| Motor de SypniaCódigo abierto, en tu propia infraestructura | Sypnia CloudServicio pago, con un plan gratis | |
|---|---|---|
| Correo | Ninguno. Las alertas se registran y se envían a tu webhook; las guías muestran cómo enviar correo desde ahí. | Amazon SES: los correos de alerta y el resumen diario. |
| Proveedor de IA | El tuyo, apagado hasta que pongas una llave. El worker lo llama por HTTPS. | OpenRouter, con ajustes que les prohíben a los proveedores guardar los datos o entrenar con ellos. |
| Cuentas, facturación, la app, la GitHub App | No están en el motor. | La app privada. Es un cliente de la API pública del motor, igual que tus propias herramientas; tiene su propia base de datos y no le agrega lógica al motor. |
Dónde está el Rust, y dónde está la lógica
Tres afirmaciones, y cada una la puedes comprobar en la plantilla y en el código:
- Todo lo que hay dentro de las tres funciones es el motor, y el motor es Rust. Las funciones corren el mismo archivo,
sypnia, compilado para arm64 y arrancado por Lambda como subootstrap. En el despliegue no hay un entorno de Node, Python ni Java, ni un segundo programa. - Los servicios de AWS mueven y guardan bytes. CloudFront reenvía una solicitud. SQS guarda un mensaje. S3 guarda un objeto. Postgres guarda filas. El programador envía un documento JSON fijo cada minuto. Ninguno mira dentro de un evento.
- Ninguna lógica vive en la configuración de un servicio. Lo que la plantilla configura son números y nombres: dos reglas de ruta, una retención, un tiempo de invisibilidad, el
5de la regla de mensajes fallidos, una frecuencia, tres umbrales de alarma, los roles. No hay plantillas que transformen solicitudes, ni reglas con filtros, ni código en el borde, ni notificaciones del bucket, ni procedimientos almacenados, ni disparadores, ni definiciones de flujos de trabajo. La retención ni siquiera es una regla de ciclo de vida del bucket: es la tarea diaria del motor, así que es igual en cualquier almacén compatible con S3.
Esa tercera afirmación es lo que hace portable al motor. Cambia SQS por memoria y Lambda por un proceso, y tienes la forma de un solo proceso, con el mismo código decidiendo las mismas cosas.
De crates a funciones a servicios
| Crate | Corre en | Alcanza |
|---|---|---|
sypnia (el binario): main, lambda, Engine | Las tres funciones | El entorno de Lambda |
sypnia-ingest | sypnia-ingest: las puertas y el envío. sypnia-worker: el otro extremo de la cola, que escribe segmentos | SQS, S3 |
sypnia-pipeline | sypnia-worker | S3, Postgres |
sypnia-agent | sypnia-worker: las tareas. sypnia-api: el prompt | S3, Postgres, el proveedor de IA |
sypnia-alerts | sypnia-worker | Postgres, tu webhook, las direcciones de tus comprobaciones de disponibilidad |
sypnia-api | sypnia-api | Postgres, S3 (leer, y firmar enlaces) |
sypnia-store, sypnia-db | Las tres | S3; Postgres |
sypnia-fingerprint, sypnia-core | Las tres | Nada: no hacen E/S |
Las funciones comparten un solo punto de entrada. Es el main de Formas de despliegue; estas son las líneas que importan aquí. Fíjate en que el rol es lo único que cambia entre las tres funciones, y en que se lee del entorno que pone la plantilla.
// Bucket, Postgres, el proveedor de IA (o ninguno), los destinos de alertas. Se arma una vez, lo comparten todos.
let engine = match Engine::connect(config.clone()).await {
Ok(engine) => Arc::new(engine),
Err(error) => return fail(4, &error),
};
// Dentro de AWS Lambda el entorno pone esta variable y no hay línea de comandos.
if std::env::var_os("AWS_LAMBDA_RUNTIME_API").is_some() {
return exit(lambda::run(engine, config.role).await); // SYPNIA_ROLE: ingest | worker | api
}Una solicitud por los servicios reales
El pago fallido del resumen, con el servicio que lleva cada paso, su presupuesto de tiempo, su límite y qué pasa cuando ese servicio falla. La columna de fallas es un resumen; Qué pasa cuando algo falla tiene todos los casos.
| # | Paso | Servicio | Presupuesto | El límite que aplica | Si falla |
|---|---|---|---|---|---|
| 1 | El navegador envía POST /v1/ingest/events | CloudFront → Lambda sypnia-ingest | 50 ms en caliente; 300 ms para una función fría | Cuerpo: 2 MiB descomprimido (el del motor), 6 MB (el de Lambda). 10 s. 40 copias; pasadas esas, la dirección responde 429 | El SDK conserva el lote y reintenta con el mismo batch_id |
| 2 | La Ingesta envía el lote validado | SQS SendMessage | 20 ms | 256 KiB por mensaje; un lote de más de 192 KiB comprimido va a S3 y el mensaje lo nombra | 503; el SDK reintenta |
| 3 | La Ingesta responde 200 | Lambda → CloudFront | — | — | — |
| 4 | La cola le entrega el lote al worker | SQS → Lambda sypnia-worker | Hasta 10 s | 500 mensajes o 6 MB por entrega. 2 copias. Invisibilidad de 15 min | Se entrega de nuevo a los 15 s, 1 min, 5 min, 15 min; luego la cola de mensajes fallidos |
| 5 | El worker escribe el segmento | S3 PutObject | 300 ms | 4 MiB por segmento, antes de comprimir | El mensaje no se borra; el paso 4 se repite |
| 6 | El worker escribe la fila del registro, revisa el segmento, escribe el problema, su alerta y su tarea | RDS para PostgreSQL, una transacción | 50 ms; 5 s para la revisión | 3 conexiones por copia del worker | El segmento queda reservado 2 minutos, y luego otro intento; 5 intentos, y luego cuarentena |
| 7 | El worker se llama a sí mismo con la tarea | Lambda Invoke, asíncrono | 100 ms | Reintentos propios de Lambda apagados: la fila de la tarea es el reintento | La marca del minuto encuentra la fila |
| 8 | El agente lee los mapas y la sesión, llama al modelo, escribe la frase | S3 GetObject; HTTPS al proveedor de IA; Postgres | 60 s | 15 min para la función; 3 intentos para la tarea | La alerta sale a tiempo sin la frase; analysis.status: failed |
| 9 | La alerta se libera hacia tu webhook | HTTPS desde el worker | 10 s | 7 intentos en 21 horas | La alerta queda registrada de todos modos |
| 10 | Cada minuto: una pasada | EventBridge Scheduler → Lambda sypnia-worker | 1 s en reposo | 2 copias compartidas con los pasos 4, 7 y 8 | La siguiente marca la hace |
| 11 | Tu agente de código llama la herramienta MCP problem | CloudFront → Lambda sypnia-api → Postgres | 300 ms | Respuesta: 6 MB (el de Lambda); 30 s; 20 copias; 2 conexiones por copia | 503 con Retry-After: 2 |
| 12 | Abres la grabación | sypnia-api firma enlaces; el navegador lee S3 directamente | 300 ms para los enlaces | Un enlace vive 15 minutos; los fragmentos nunca pasan por una función | 503; la lista de problemas sigue funcionando |
Límites y ajustes en un solo lugar
| Dónde | Ajuste | Valor | Por qué este valor |
|---|---|---|---|
sypnia-ingest | Memoria, tiempo límite, copias | 256 MB, 10 s, 40 | Solo revisa y reenvía. 40 copias a 50 ms aceptan unos 800 lotes por segundo |
sypnia-worker | Memoria, tiempo límite, copias | 1.024 MB, 15 min, 2 | Dos proyectos consolidándose a la vez (2 × 256 MB), la caché de source maps, holgura. La tarea diaria puede necesitar los 15 minutos |
sypnia-api | Memoria, tiempo límite, copias | 512 MB, 30 s, 20 | El detalle de una sesión se arma en memoria, dentro de un presupuesto de 4 MB |
| Todas las funciones | Arquitectura, entorno | arm64, provided.al2023 | Un binario nativo; no hay un entorno de lenguaje que arrancar |
| Todas las funciones | Variables de entorno | Menos de 4 KB en total | El límite de Lambda. El motor necesita unos 12 ajustes |
| Cola de entrada | Retención, invisibilidad, entregas | 4 días, 15 min, 5 | Ver Qué pasa cuando algo falla |
| Cola de mensajes fallidos | Retención | 14 días | Lo máximo que permite SQS |
| Cola → worker | Lote, ventana, respuesta | 500 mensajes o 6 MB, 10 s, fallas reportadas por mensaje | Un mensaje malo no devuelve a los demás |
| Programador | Frecuencia | Cada minuto | Una sola programación; el trabajo diario y semanal lo arranca la pasada cuando toca |
| Bucket | Cifrado, acceso | En reposo, privado | Las funciones llegan por sus roles; los navegadores, por enlaces firmados de 15 minutos |
| Postgres | Conexiones | Máximo 86: 40 × 1, 20 × 2, 2 × 3 | Caben en la instancia más pequeña, que acepta unas 100 |
| Alarmas | Tres | Cola de mensajes fallidos no vacía; mensaje más viejo de más de 120 s durante 3 minutos; worker fallando en 3 de 5 minutos | Funcionan cuando el motor no |
Las dos copias del worker las comparten las entregas de la cola, la marca del minuto y las tareas del agente. Cuando todas están ocupadas, una llamada nueva espera: un mensaje se queda en la cola, una llamada asíncrona la retiene Lambda. No se pierde nada; el trabajo sale más tarde. Este es el primer número que hay que subir cuando lag_seconds crece, junto con las conexiones de la base de datos.
La plantilla
Todo el despliegue es un archivo, sypnia-aws.yaml. Este extracto es la parte de la que habla esta página: las tres funciones, la cola con su regla de mensajes fallidos, la programación y una alarma. Quedan por fuera: la distribución, el bucket, la base de datos, las otras dos alarmas y las salidas. Cómo desplegarla está en Desplegar en AWS.
Transform: AWS::Serverless-2016-10-31
Globals:
Function:
Runtime: provided.al2023 # sin entorno de lenguaje: el paquete es el binario sypnia, con el nombre bootstrap
Handler: bootstrap
Architectures: [arm64]
CodeUri: { Bucket: !Ref CodeBucket, Key: !Sub "sypnia/${Version}/sypnia-lambda-arm64.zip" }
Environment:
Variables:
SYPNIA_ROOT_TOKEN: !Ref RootToken
SYPNIA_STORAGE_BUCKET: !Ref Bucket
SYPNIA_DATABASE_URL: !If [CreateDb, !Sub "postgres://sypnia:{{resolve:secretsmanager:${DatabaseSecret}:SecretString:password}}@${Database.Endpoint.Address}:5432/sypnia?sslmode=require", !Ref DatabaseUrl]
SYPNIA_INTAKE_QUEUE_URL: !Ref IntakeQueue # la cola ocupa el lugar del búfer en memoria
SYPNIA_INTAKE_DEAD_LETTER_QUEUE_URL: !Ref IntakeDeadLetterQueue # la leen /v1/engine/status y sypnia doctor
Resources:
IngestFunction:
Type: AWS::Serverless::Function
Properties:
FunctionName: sypnia-ingest
MemorySize: 256
Timeout: 10
ReservedConcurrentExecutions: 40
FunctionUrlConfig: { AuthType: NONE } # se llega por la distribución; el motor revisa cada llave por su cuenta
Environment: { Variables: { SYPNIA_ROLE: ingest, SYPNIA_DATABASE_MAX_CONNECTIONS: "1" } }
Policies:
- SQSSendMessagePolicy: { QueueName: !GetAtt IntakeQueue.QueueName }
- Statement: [{ Effect: Allow, Action: "s3:PutObject", Resource: !Sub "${Bucket.Arn}/*" }]
ApiFunction:
Type: AWS::Serverless::Function
Properties:
FunctionName: sypnia-api
MemorySize: 512
Timeout: 30
ReservedConcurrentExecutions: 20
FunctionUrlConfig: { AuthType: NONE }
Environment: { Variables: { SYPNIA_ROLE: api, SYPNIA_DATABASE_MAX_CONNECTIONS: "2" } }
Policies:
- S3ReadPolicy: { BucketName: !Ref Bucket } # leer, y firmar enlaces de lectura
WorkerFunction:
Type: AWS::Serverless::Function
Properties:
FunctionName: sypnia-worker
MemorySize: 1024
Timeout: 900
ReservedConcurrentExecutions: 2
Environment: { Variables: { SYPNIA_ROLE: worker, SYPNIA_DATABASE_MAX_CONNECTIONS: "3" } }
EventInvokeConfig: { MaximumRetryAttempts: 0 } # una tarea es una fila en Postgres: la fila es el reintento
Policies:
- S3CrudPolicy: { BucketName: !Ref Bucket }
- Statement:
- { Effect: Allow, Action: "lambda:InvokeFunction", Resource: !Sub "arn:aws:lambda:${AWS::Region}:${AWS::AccountId}:function:sypnia-worker" }
- { Effect: Allow, Action: "sqs:GetQueueAttributes", Resource: !GetAtt IntakeDeadLetterQueue.Arn }
Events:
Intake:
Type: SQS
Properties:
Queue: !GetAtt IntakeQueue.Arn
BatchSize: 500
MaximumBatchingWindowInSeconds: 10
FunctionResponseTypes: [ReportBatchItemFailures] # solo vuelven los mensajes que fallaron
ScalingConfig: { MaximumConcurrency: 2 }
EveryMinute:
Type: ScheduleV2
Properties:
ScheduleExpression: rate(1 minute)
Input: '{"job":"pass"}'
IntakeQueue:
Type: AWS::SQS::Queue
Properties:
VisibilityTimeout: 900 # no menor que el tiempo límite del worker
MessageRetentionPeriod: 345600 # 4 días
ReceiveMessageWaitTimeSeconds: 20
SqsManagedSseEnabled: true
RedrivePolicy:
deadLetterTargetArn: !GetAtt IntakeDeadLetterQueue.Arn
maxReceiveCount: 5 # la quinta entrega fallida es la última
IntakeDeadLetterQueue:
Type: AWS::SQS::Queue
Properties:
MessageRetentionPeriod: 1209600 # 14 días
SqsManagedSseEnabled: true
DeadLetterNotEmpty:
Type: AWS::CloudWatch::Alarm
Properties:
AlarmDescription: Batches were set aside. Look at one, fix the cause, redrive.
Namespace: AWS/SQS
MetricName: ApproximateNumberOfMessagesVisible
Dimensions: [{ Name: QueueName, Value: !GetAtt IntakeDeadLetterQueue.QueueName }]
Statistic: Maximum
Period: 60
EvaluationPeriods: 1
Threshold: 0
ComparisonOperator: GreaterThanThreshold
TreatMissingData: notBreachingQué despierta al worker se distingue por la forma del evento, en el worker_event de Formas de despliegue: { "Records": […] } es la cola, { "job": "pass" } es la programación, { "job": { "agent": { "problem": "prb_8f3k2m9x4q7w" } } } es el worker llamándose a sí mismo.
Postgres: cuál, y por qué
La referencia usa Amazon RDS para PostgreSQL, una instancia pequeña en una sola zona de disponibilidad: db.t4g.micro, Postgres 16, 20 GB, cifrada, respaldos guardados 7 días. Es lo que crea la plantilla cuando CreateDatabase es true.
| Opción | Costo en reposo al mes | Lo bueno | El precio que pagas |
|---|---|---|---|
RDS para PostgreSQL, db.t4g.micro (la referencia) | 11,68 + 2,30 de disco | El Postgres administrado más barato de AWS; una factura fija; Postgres sin adornos | Una zona: una falla de la instancia son minutos de «se recibe, pero no se puede leer». Unas 100 conexiones |
| RDS en dos zonas (Multi-AZ) | El doble de la instancia y del disco | Cambia de zona solo, en uno o dos minutos | El doble de precio por una base de datos que el Bucket puede reconstruir casi entera |
| Aurora Serverless v2 | Desde 43,80: 0,5 unidades de capacidad × 0,12 × 730, más almacenamiento y E/S | Crece y se encoge con la carga | Tres veces el costo en reposo. Escalar a cero no sirve: la marca del minuto la despertaría cada minuto |
| Un Postgres fuera de AWS (Supabase, Neon, el tuyo) | 0 a 25 | Quizá ya lo tienes | Cada consulta cruza internet; aplican sus límites de conexiones. Usa una conexión directa o en modo sesión, no un pooler en modo transacción |
Una sola cadena de conexión. El motor recibe un único SYPNIA_DATABASE_URL, para todos los roles. Debe ser una conexión directa o en modo sesión: el motor prepara sus sentencias y corre transacciones de varias sentencias, y un pooler en modo transacción las rompe. A cambio, las funciones mantienen el total pequeño: 1 conexión por copia de ingesta, 2 por copia de la API, 3 por copia del worker.
Secretos. La contraseña generada de la base de datos vive en Secrets Manager y se resuelve cuando se despliega el stack. El token raíz, la llave de IA y el secreto del webhook son parámetros de la plantilla que nunca se muestran, guardados como entorno de las funciones, que Lambda cifra en reposo. Quien pueda leer la configuración de una función los puede leer; restringe ese permiso igual que restringirías los secretos mismos.
El modelo de costos
Precios usados
USD, por demanda, us-east-1, tal como se asumen el 2026-11-15, sin ninguna cuota gratuita. Cada nombre enlaza a la lista de precios oficial.
| Servicio | Unidad | Precio |
|---|---|---|
| AWS Lambda, arm64 | Por GB-segundo; por millón de solicitudes | 0,0000133334; 0,20 |
| Amazon SQS, estándar | Por millón de solicitudes (cada 64 KB de un mensaje es una) | 0,40 |
| Amazon S3, Standard | Por GB-mes; por millón de escrituras o listados; por millón de lecturas | 0,023; 5,00; 0,40 |
| Amazon CloudFront | Por millón de solicitudes HTTPS; por GB enviado a la función; por GB enviado hacia afuera | 1,00; 0,02; 0,085 |
| Datos que salen de AWS desde S3 | Por GB | 0,09 |
| Amazon RDS para PostgreSQL | db.t4g.micro por hora; db.t4g.medium por hora; disco por GB-mes; una dirección pública por hora | 0,016; 0,065; 0,115; 0,005 |
| Amazon EventBridge Scheduler | Por millón de invocaciones | 1,00 |
| Amazon CloudWatch | Logs por GB; por alarma al mes | 0,50; 0,10 |
| AWS Secrets Manager | Por secreto al mes | 0,40 |
| Amazon SES Nube | Por 1.000 correos | 0,10 |
| NAT gateway (no está en la referencia) | Por hora; por GB | 0,045; 0,045 |
AWS le da a cada cuenta una cuota mensual que cubre las funciones de un despliegue pequeño (400.000 GB-segundos y un millón de solicitudes), su cola (un millón de solicitudes) y su dirección (10 millones de solicitudes). Los costos unitarios de abajo la ignoran, para que sigan siendo ciertos a cualquier tamaño.
Un despliegue en reposo
No llega nada. Lo que igual cuesta:
| Línea | Aritmética | Al mes |
|---|---|---|
| La marca del minuto | 43.200 llamadas × 1 s × 1 GB × 0,0000133334, más 43.200 × 0,20 ÷ 1.000.000 | 0,59 |
| La programación | 43.200 × 1,00 ÷ 1.000.000 | 0,04 |
| Las consultas vacías a la cola | Unas 15 por minuto: 648.000 × 0,40 ÷ 1.000.000 | 0,26 |
| Tres alarmas | 3 × 0,10 | 0,30 |
| Un secreto | 0,40 | |
| Logs | Cerca de 0,1 GB | 0,05 |
| Bucket, dirección, las otras dos funciones | No llega nada, no se cobra nada | 0,00 |
| El motor, en reposo | ≈ 1,64 | |
| Postgres, si lo crea la plantilla | 0,016 × 730 + 20 × 0,115 | 13,98 |
| Su dirección pública | 0,005 × 730 | 3,65 |
| Total, en reposo | ≈ 19,27 |
Con un Postgres que ya tengas, un motor en reposo cuesta menos de USD 2 al mes, y con la cuota gratuita son centavos.
Costos unitarios
Recibir, guardar y procesar eventos. La unidad que cuesta no es el evento: es el lote, y el segmento en el que cae.
| Paso, por 1.000 lotes | Servicio | Aritmética | USD |
|---|---|---|---|
| La dirección los recibe | CloudFront | 1.000 × 1,00 ÷ 1.000.000 | 0,00100 |
| Los cuerpos llegan a la función, 3 KB cada uno | CloudFront | 0,003 GB × 0,02 | 0,00006 |
Se llama a sypnia-ingest | Lambda | 1.000 × 0,20 ÷ 1.000.000 | 0,00020 |
| Corre 50 ms con 256 MB | Lambda | 12,5 GB-s × 0,0000133334 | 0,00017 |
| Los lotes se envían a la cola | SQS | 1.000 × 0,40 ÷ 1.000.000 | 0,00040 |
| El worker los recibe y los borra, en grupos | SQS | Unas 670 solicitudes × 0,40 ÷ 1.000.000 | 0,00027 |
| Recibir | 0,0021 | ||
| Segmentos escritos: máximo uno por lote | S3 | 1.000 × 5,00 ÷ 1.000.000 | 0,00500 |
| Cada uno leído una vez por la vía rápida y hasta 11 veces por la consolidación | S3 | 12.000 × 0,40 ÷ 1.000.000 | 0,00480 |
| El tiempo del worker para ellos, 20 ms cada uno con 1 GB | Lambda | 20 GB-s × 0,0000133334 | 0,00027 |
| Guardar y procesar, como máximo | 0,0101 | ||
| Total, como máximo | 0,0122 |
Los segmentos son la mitad más grande, y tienen tope: un proyecto y entorno recibe máximo un segmento por entrega de 10 segundos, 259.200 al mes, envíe lo que envíe. Por eso el costo de un millón de eventos depende de cómo llegan:
| Un millón de eventos | Lotes | Segmentos | Aritmética | USD |
|---|---|---|---|---|
| Un proyecto activo: el proyecto pequeño de Formas de despliegue, 4 millones de eventos al mes | 225.000 | 65.000 (el tope, repartido entre 4 millones) | 225 × 0,0021 + 65 × 0,0101 + 15.000 archivos por sesión × 5 ÷ 1.000.000 | ≈ 1,20 |
| Un proyecto tranquilo: cada lote solo en sus 10 segundos | 225.000 | 225.000 | 225 × 0,0122 + 0,08 | ≈ 2,80 |
| La peor forma: cada evento solo en un lote, dos eventos por sesión | 1.000.000 | 1.000.000 | 1.000 × 0,0122 + 1.000.000 de archivos por sesión × 5 ÷ 1.000.000 | ≈ 17,20 |
Medido en el sistema del que sale este motor: 4,4 eventos por lote y 30 lotes por sesión, de donde sale el 225.000. La peor forma es la que un techo debe asumir, y la que no tiene la app de nadie.
Guardar. USD 0,023 por GB-mes. Un GB son unos 8 millones de eventos en segmentos (125 MB por millón), o 2,7 millones con sus archivos por sesión y Parquet (375 MB por millón), o unas 1.330 grabaciones cortas.
Grabaciones. Una grabación es un objeto por cada 10 segundos, enviado por la dirección y sypnia-ingest, y leído por el navegador directamente de S3 cuando alguien la ve.
| Por 1.000 grabaciones | Una corta: 22 fragmentos, 0,75 MB (medido allá) | La más larga: 720 fragmentos, 144 MB, dos horas |
|---|---|---|
| Solicitudes por la dirección y la función | 22.000 × (1,00 + 0,20 + 0,33) ÷ 1.000.000 = 0,034 | 1,10 |
| Cuerpos hacia la función | 0,75 GB × 0,02 = 0,015 | 2,88 |
| Objetos escritos | 22.000 × 5 ÷ 1.000.000 = 0,110 | 3,60 |
| Guardadas | ≈ 0,16 | ≈ 7,58 |
| Conservadas, por mes de retención | 0,75 GB × 0,023 = 0,017 | 3,31 |
| Vistas una vez, cada una | 22.000 lecturas × 0,40 ÷ 1.000.000 + 0,75 GB × 0,09 = 0,076 | ≈ 13,25 |
Una grabación corta cuesta dos centésimas de centavo entre guardarla y verla. La más larga cuesta dos centavos, casi 90 veces más, y la mayor parte son los datos que salen de AWS cuando se ve.
Un análisis de IA. El motor cuenta tokens, no dinero; el precio es el de tu proveedor. La fórmula:
costo = llamadas × (tokens_entrada × precio_entrada + tokens_salida × precio_salida) ÷ 1.000.000| Tokens de entrada | Tokens de salida | Llamadas | |
|---|---|---|---|
| Un análisis usual | 8.000: unos 24.000 caracteres de contexto a 3 o 4 caracteres por token, más las instrucciones fijas | 700 | 1,15: se asume que una respuesta de cada siete no pasa la revisión y se pide de nuevo |
| El más grande que permite el motor | 9.000 | 2.000 (ai.max_output_tokens) | 3 |
| Precio del modelo, por millón de tokens de entrada / salida | Un análisis usual | El más grande |
|---|---|---|
| 0,15 / 0,60 | 0,0019 | 0,0077 |
| 0,40 / 1,60 | 0,0050 | 0,0204 |
| 3,00 / 15,00 | 0,040 | 0,171 |
Así que un análisis cuesta entre un quinto de centavo y cuatro centavos, según el modelo, y hasta 17 centavos en el peor caso con uno caro. Medido en el sistema del que sale este motor: USD 0,08 a 0,20 por una corrida semanal de 15 a 25 llamadas, cerca de medio centavo a un centavo por llamada. Aquí no se nombra ningún modelo porque no se promete ninguno.
Una comprobación de disponibilidad. Una solicitud por minuto, hecha dentro de la pasada que corre de todos modos: cerca de USD 0,02 al mes por sus 43.200 filas de resultados y su parte del tiempo del worker.
Dos ejemplos de alojamiento propio
Los dos proyectos de Formas de despliegue, sumados por servicio. La aritmética línea por línea está allá; las últimas filas agregan tres cosas fijas y pequeñas que esa tabla no incluye.
| USD al mes | Pequeño: 4 millones de eventos, 30.000 sesiones | Mediano: 40 millones de eventos, 300.000 sesiones |
|---|---|---|
| Lambda | 3,31 | 15,26 |
| SQS | 0,60 | 4,00 |
| S3: escrituras, lecturas, almacenamiento | 3,52 | 14,34 |
| Logs de CloudWatch | 0,50 | 2,00 |
| CloudFront | 0,00 (dentro de la cuota) | 0,00 |
| El motor | ≈ 8 | ≈ 36 |
| RDS para PostgreSQL | ≈ 14 (db.t4g.micro) | 25 a 50 (2 a 4 GB de memoria) |
| Total, como en las otras páginas | ≈ 22 | ≈ 60 a 85 |
| Tres alarmas, un secreto, la dirección pública de la base de datos | 0,30 + 0,40 + 3,65 = 4,35 | 4,35 |
| Todo lo que llega en la factura | ≈ 26 | ≈ 65 a 90 |
| Con las funciones en una red privada | + 32,85 por el NAT gateway, − 3,65 | Lo mismo |
No incluido: el modelo, al precio de tu proveedor (un proyecto que hace 200 análisis usuales al mes a 0,40 / 1,60 paga USD 1,00), y los datos que salen de AWS cuando ves grabaciones (0,09 por GB).
Un proyecto en el plan Free de Sypnia Cloud Nube
La regla del dueño: ningún proyecto del plan Free puede costarle a Sypnia más de USD 3 al mes, con todo incluido. Una regla así solo es cierta si cada línea de la factura tiene un límite. Por eso esta sección hace tres cosas: le pone precio a cada límite en su peor forma, muestra qué líneas no tienen límite hoy, y propone los límites que hacen cumplir la regla.
Costos fijos, compartidos. Sypnia Cloud es este mismo despliegue, dimensionado para muchos proyectos, y sus costos fijos los comparten todos:
| Fijo, al mes | Aritmética | USD |
|---|---|---|
Postgres: db.t4g.medium en dos zonas, 100 GB | 2 × 0,065 × 730 + 100 × 0,23 | 117,90 |
| Un NAT gateway, para que la base de datos no tenga dirección pública | 0,045 × 730 | 32,85 |
| La marca del minuto, presupuestada en 10 s por pasada | 43.200 × 10 GB-s × 0,0000133334 | 5,76 |
| Logs, alarmas, secretos | 10 GB × 0,50 + 0,30 + 1,20 | 6,50 |
| Fijo | ≈ 163 |
Supuesto, dicho de frente: 500 proyectos comparten un despliegue así, y cada uno carga USD 0,33. Con 130 proyectos la parte es USD 1,25 y el techo de abajo todavía se cumple; con menos, Sypnia paga el costo fijo sean cuales sean los planes, y el techo es una afirmación sobre cada proyecto adicional. El alojamiento propio de la app privada no está en este número.
El modelo. Para la aritmética del plan Free, el modelo de Sypnia Cloud se presupuesta en no más de USD 0,40 por millón de tokens de entrada y 1,60 de salida: un análisis usual es medio centavo, el más grande son dos centavos. Si se elige un modelo más caro, la fila crece en la misma proporción.
Un proyecto gratuito al 100 % de cada límite, en la peor forma:
| Límite (propuesto) | En el límite | Costo unitario, peor forma | USD al mes |
|---|---|---|---|
| Eventos recibidos: tope duro en 20.000, cuatro veces los 5.000 eventos contados | 20.000 lotes de un evento | 0,0122 por 1.000 lotes | 0,24 |
| …sus sesiones | 10.000 sesiones, dos archivos escritos por cada una | 5,00 por millón de escrituras | 0,10 |
| …sus consolidaciones | Una corrida en cada 5 minutos del mes: 8.640 × 0,3 GB-s | 0,0000133334 por GB-s | 0,04 |
| Grabaciones: 50 al mes, de máximo 30 minutos, guardadas 7 días | 50 × 180 fragmentos, 36 MB cada una; todas vistas una vez | 0,0021 por guardarla + 0,0033 por verla | 0,27 |
| Comprobaciones de disponibilidad: 1 | 43.200 revisiones | 0,02 | |
| Análisis: 50 al mes | 50 de los más grandes | 0,0204 | 1,02 |
| Correos de alerta: 100 al mes, más el resumen diario | 131 correos | 0,10 por 1.000 | 0,01 |
| Pull requests: ninguno | 0,00 | ||
| Parte de los costos fijos | 163 ÷ 500 | 0,33 | |
| Total | ≈ 2,03 |
El mismo proyecto en los mismos límites, con la forma que tienen las apps reales (4,4 eventos por lote, grabaciones cortas de las que se ve una de cada cinco, análisis usuales), cuesta cerca de USD 0,65, la mitad por la parte fija.
Frente a la propuesta de hoy. pricing.ts y Límites proponen para Free: 5.000 eventos, 50 grabaciones, 7 días, 1 comprobación de disponibilidad, 5 pull requests al mes y 20 análisis al día. Con los mismos precios:
| Línea | Propuesta de hoy | USD al mes, peor forma | Veredicto |
|---|---|---|---|
| Análisis | 20 al día, 620 al mes | 620 × 0,0204 = 12,65 | Cuatro veces el techo por sí sola. Incluso al tamaño usual son 3,10 |
| Pull requests | 5 al mes | 5 × 0,30 a 0,60 = 1,50 a 3,00 | De la mitad del techo a todo el techo. Ya decidido: no van en el plan Free |
| Eventos | 5.000 contados; los eventos que no cuentan y las fallas pasado el límite no tienen tope | Sin techo | Una página que dispara un evento propio en un ciclo, o un error en un ciclo, no tiene límite |
| Grabaciones | 50, de hasta dos horas cada una | 50 × (0,0084 + 0,0133) = 1,08 | Cabe solo si nada más está en su peor caso |
| Correos de alerta | Sin tope | Sin techo | Una comprobación de disponibilidad que sube y baja todo el mes son 43.200 correos: 4,32 |
| Total | Más de 15, con dos líneas que no tienen techo |
Los planes pagos al 100 % de los límites propuestos. A un plan pago se le pone precio con la forma que tienen las apps reales, y la peor forma se declara como el riesgo. Un pull request es el número menos seguro de esta página, porque su worker no está diseñado en detalle: se presupuesta en USD 0,30, y 0,60 en el peor caso, por unos 120.000 tokens de entrada y 8.000 de salida con un modelo apto para escribir código.
| USD al mes | Builder, 3 proyectos | Team, 10 proyectos |
|---|---|---|
| Eventos: se recibe el doble de los contados, 4,4 por lote | 0,29 | 3,12 |
| Grabaciones: cortas, se ve una de cada cinco | 0,10 | 1,13 |
| Comprobaciones de disponibilidad | 5 × 0,02 = 0,10 | 25 × 0,02 = 0,50 |
| Análisis, tamaño usual | 200 × 0,005 = 1,00 | 1.000 × 0,005 = 5,00 |
| Pull requests | 5 × 0,30 = 1,50 | 30 × 0,30 = 9,00 |
| Correo: resúmenes y alertas | 0,06 | 0,51 |
| Parte de los costos fijos | 3 × 0,33 = 0,99 | 10 × 0,33 = 3,30 |
| Pago con tarjeta: 2,9 % + 0,30 | 0,59 | 1,72 |
| Costo al 100 % de los límites | ≈ 4,63 | ≈ 24,28 |
| Margen | 5,37, 54 % | 24,72, 50 % |
| Los mismos límites en la peor forma | ≈ 24,50 | ≈ 233 |
| Con la propuesta de hoy para pull requests (50 y 300) | 18,13: una pérdida de 8,13 | 105,28: una pérdida de 56,28 |
Tres cosas que leer de aquí:
- Los pull requests y los análisis son la factura. El almacenamiento, los eventos y las grabaciones juntos son menos de un quinto del costo de cualquiera de los dos planes con formas reales. El modelo es más de la mitad.
- Los planes pagos no están a salvo en la peor forma, y la exposición es una sola línea: grabaciones largas que se ven todas. 5.000 grabaciones de dos horas son 720 GB escritos, guardados tres meses y descargados: cerca de USD 154 en un plan de USD 49. Una grabación máxima más corta en los planes pagos, o contar horas de grabación en vez de grabaciones, lo cerraría. Es una pregunta para el dueño, abajo.
- Los números de hoy para pull requests pierden plata en los dos planes pagos, con cualquier forma.
Preguntas que este modelo deja abiertas
- El nivel de precio del modelo de Sypnia Cloud. Todo lo anterior asume 0,40 / 1,60 por millón de tokens. Un modelo de 3,00 / 15,00 hace que los 50 análisis del plan Free cuesten hasta USD 8,55; el mismo techo entonces permite 5.
- El NAT gateway. USD 33 al mes para que la base de datos de Sypnia Cloud no tenga dirección pública. Está contado arriba; la referencia de alojamiento propio no lo usa.
- Las grabaciones en los planes pagos: un tope por grabación, u horas en vez de una cantidad.
- El costo de un pull request, cuando su worker exista y se pueda medir.
Qué cambió frente al sistema del que sale
| Allá | Aquí | Por qué |
|---|---|---|
| Una función de ingesta, una horaria, una diaria y una semanal, en TypeScript, con un motor de consultas nativo como un binding de 68 MB | Tres funciones por rol, un binario en Rust, sin dependencias nativas | Un solo programa que leer, arm64, arranques en frío de 300 ms |
| Un flujo de entrega administrado entre la ingesta y el bucket | SQS, con cola de mensajes fallidos y un comando de redrive | Frescura; objetos nombrados por proyecto; fallas que se pueden ver |
| La base de datos compartida de la app | Una base de datos propia del motor | La compartida se quedó sin memoria una vez |
| Retención con reglas de ciclo de vida del bucket y una extensión de cron en la base de datos | La tarea diaria del motor | Igual en cualquier almacén y cualquier Postgres |
| El costo estimado una vez, para una app | Un costo unitario por lote, grabación y análisis, y un techo por plan | Un servicio con plan gratuito debe saber cuánto cuesta un proyecto gratuito |
Sigue
- Cada salto de este despliegue con sus reintentos, su salida a mensajes fallidos y su comando para volver a procesar.
- La plantilla, paso a paso, en tu propia cuenta.
- Qué mueve la factura de un alojamiento propio, y los primeros límites que encuentras.