Formas de despliegue
Cómo el mismo binario de Sypnia corre como tres funciones de AWS o como un proceso largo, qué crea la plantilla de AWS, cuánto cuesta cada forma con la aritmética a la vista, y las piezas que puedes cambiar, vistas desde el código.
El motor es un solo programa, sypnia. Se puede arrancar de dos maneras, y en las dos hace el mismo trabajo:
- como funciones en AWS, que despiertan con solicitudes, una cola y una programación;
- como un proceso largo, en Docker o en cualquier servidor.
Esta página muestra qué cambia entre las dos, qué es igual, cuánto cuesta cada una y dónde están los bordes del motor: las cuatro piezas que puedes reemplazar.
Un motor, dos maneras de despertarlo
| Funciones de AWS | Un proceso | |
|---|---|---|
| Lo arranca | La plantilla | sypnia serve |
| El búfer de la ingesta (1) (2) | Una cola: la ingesta envía, el worker escribe el segmento | Memoria: se escribe cada 2 s |
| La vía rápida corre | Cuando la cola entrega, y cada minuto | Cuando cae un segmento, y cada 30 s |
| La consolidación corre | En la marca del minuto, cuando pasaron 5 minutos | En el ciclo del worker, cuando pasaron 5 minutos |
| Escala con | Más copias de una función, por sí sola | Más procesos con --role, por tu cuenta |
| Costo sin tráfico | Casi nada | El servidor |
| Disposición del bucket y tablas | Las mismas | Las mismas |
Las dos arrancan en el mismo main. Fíjate en que hay un solo Engine::connect y en que todo lo que sigue solo decide qué despierta al motor.
#[tokio::main]
async fn main() -> ExitCode {
let config = match Config::from_env_and_file() {
Ok(config) => Arc::new(config),
Err(error) => return fail(3, &error), // un ajuste obligatorio que falta dice su nombre
};
// Bucket, Postgres, el proveedor de IA (o ninguno), las salidas de alertas. Se arma una vez y lo comparte todo.
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);
}
match Cli::parse().command {
Command::Serve(args) => exit(serve::run(engine, args).await), // el proceso largo
Command::Aggregate(args) => exit(aggregate::run(engine, args).await), // una pasada y termina
Command::Migrate(args) => exit(migrate::run(engine, args).await),
Command::Doctor => exit(doctor::run(engine).await),
other => exit(admin::run(engine, other).await), // project, key, token, sourcemaps, problems
}
}Como funciones de AWS
La plantilla corre una función por rol, los mismos tres roles que acepta sypnia serve --role.
| Función (rol) | La despierta | Hace | Memoria, límite de tiempo |
|---|---|---|---|
ingest (1) | La dirección (6), para /v1/ingest/* y /v1/otlp/* | Las siete puertas, y luego envía el lote validado a la cola. Escribe fragmentos de grabación, capturas y lotes de más de 192 KiB directo al Bucket | 256 MB, 10 s, máximo 40 copias |
worker (3) | La cola de entrada (2): hasta 10 segundos de mensajes | Escribe los segmentos, agrega las filas del registro y corre la vía rápida sobre ellos de inmediato | 1.024 MB, 15 min, máximo 2 copias |
| La programación, cada minuto (5) | Una pasada: lo que le quedó a la vía rápida y las fallas retenidas, alertas que ya debían salir, chequeos de disponibilidad, reintentos de webhooks, y la consolidación cuando pasaron 5 minutos | ||
| Ella misma, de forma asíncrona | Una tarea del agente: traducir la pila, analizar, liberar la alerta. Y las dos tareas largas que la pasada inicia cuando les toca: la diaria a las 02:30 UTC (Parquet, retención, particiones de los meses siguientes) y las sugerencias semanales el lunes a las 07:00 UTC | ||
api (4) | La dirección (6), para todo lo demás | La API, el servidor MCP en /mcp, la Consola en /console | 512 MB, 30 s, máximo 20 copias |
El worker distingue quién lo despertó por la forma del evento. Fíjate en que el caso de la cola y el búfer de un proceso terminan en las mismas dos llamadas: escribir segmentos y revisarlos.
/// Todo lo que puede despertar a la función worker.
#[derive(Deserialize)]
#[serde(untagged)]
enum WorkerEvent {
Queue(SqsEvent), // { "Records": [...] }: lotes de la función de ingesta
Job { job: Job }, // { "job": "pass" }: una programación, o el worker llamándose a sí mismo
}
#[derive(Deserialize)]
#[serde(rename_all = "snake_case")]
enum Job {
Pass,
Daily,
Suggestions,
Agent { problem: ProblemId },
}
async fn worker_event(engine: &Engine, event: WorkerEvent) -> Result<(), EngineError> {
match event {
WorkerEvent::Queue(batch) => {
// Los mismos dos pasos con los que termina el búfer en memoria.
let segments = intake::write_segments(engine, batch.into_lines()?).await?;
fast_path::scan(engine, &segments).await?;
}
WorkerEvent::Job { job: Job::Pass } => { engine.pass().await?; }
WorkerEvent::Job { job: Job::Daily } => daily::run(engine).await?,
WorkerEvent::Job { job: Job::Suggestions } => suggestions::run(engine).await?,
WorkerEvent::Job { job: Job::Agent { problem } } => agent::run_job(engine, &problem).await?,
}
Ok(()) // un error hace que la cola entregue de nuevo; todo paso se puede repetir sin daño
}
pub async fn run(engine: Arc<Engine>, role: Role) -> Result<(), lambda_runtime::Error> {
match role {
Role::Ingest => lambda_http::run(ingest::router(engine)).await, // el mismo router de axum que `serve`
Role::Api => lambda_http::run(api::router(engine)).await,
Role::Worker | Role::All => {
lambda_runtime::run(service_fn(move |event: LambdaEvent<WorkerEvent>| {
let engine = engine.clone();
async move { worker_event(&engine, event.payload).await }
}))
.await
}
}
}Por qué una cola, y solo una
La cola (2) existe por una razón: una función no tiene memoria entre solicitudes, así que no puede agrupar lotes en segmentos. La cola es esa memoria. También despierta al worker en el momento en que hay algo que revisar; por eso la forma de AWS crea un problema más rápido de lo que sugiere su programación de cada minuto.
Hay una cola y no cuatro. Las tareas del agente, la liberación de alertas y los reintentos de webhooks son filas en Postgres con una hora; la marca del minuto recoge lo que una llamada directa haya dejado pasar. La alternativa, una cola por tipo de trabajo, serían tres cosas más que crear, vigilar y pagar, para mover unas pocas filas por minuto.
Un mensaje que falla cinco entregas va a la cola de mensajes fallidos y dispara una alarma. Nada en el motor la lee por su cuenta: un lote que no se puede escribir cinco veces es un error que hay que mirar, y sypnia aggregate puede repetirlo.
Qué crea la plantilla
| Recurso | Notas |
|---|---|
| Un bucket privado | Sin acceso público. Una regla de ciclo de vida, para subidas sin terminar. La retención es la tarea diaria del motor |
| La cola de entrada y su cola de mensajes fallidos | Los mensajes se guardan 4 días; 5 entregas antes de pasar a la cola de fallidos |
| Tres funciones, arm64, con sus roles | ingest puede enviar a la cola y escribir objetos; api puede leer objetos y firmar enlaces; worker puede leer y escribir el bucket y llamarse a sí misma |
| Una dirección | Una distribución de entrega de contenido delante de las dos funciones HTTP, así el motor tiene una sola URL base. No guarda nada en caché salvo el archivo del SDK. CORS lo responde el motor, no la dirección |
| Una programación | Cada minuto. Las tareas diaria y semanal las inicia la pasada cuando les toca, así hay una programación que vigilar, no tres |
| Grupos de logs | Se conservan 30 días |
| Dos alarmas | Mensajes en la cola de fallidos; el worker fallando |
| Postgres, opcional | Una instancia pequeña, o ninguna si pasas SYPNIA_DATABASE_URL |
No crea un balanceador, un clúster de contenedores, una caché, un flujo ni un servicio de búsqueda. La guía paso a paso es Desplegar en AWS.
Arranques en frío, límites y conexiones
- Arranques en frío. El binario es código nativo, sin un entorno que arrancar ni nada que descargar. Presupuesto: 300 ms para que una función fría responda su primera solicitud, casi todo abriendo la conexión a Postgres. Para comparar, medido en el sistema del que sale esto: 0,4 s para que arrancara su agregador, y luego una descarga de 50 MB de una extensión en cada arranque en frío, que este diseño no tiene.
- La respuesta de 6 MB. Una función no puede responder más de 6 MB. Las mismas reglas de allá: una grabación se entrega como enlaces firmados a sus fragmentos, nunca a través de la función; el detalle de una sesión tiene un presupuesto de 4 MB con un orden fijo de qué dejar fuera.
- Conexiones a Postgres. Cada copia de una función tiene las suyas.
ingesttiene máximo una y la usa solo para llenar su caché;apimáximo dos; unworker, una por proyecto que esté consolidando más una. Pon un agrupador de conexiones delante de Postgres cuando corran muchas copias: el sistema del que sale esto agotó su agrupador una vez, con cada copia de una función que atendía solicitudes abriendo su propio grupo. - La caché de la ingesta. Una función
ingestfría le pregunta a Postgres por una llave la primera vez que la ve, y luego la guarda 60 segundos. Una tibia nunca pregunta.
Cuánto cuesta en AWS
Dos proyectos de ejemplo. Pequeño es el tamaño medido en el sistema del que sale este motor. Mediano es diez veces eso.
| Por mes | Pequeño | Mediano |
|---|---|---|
| Eventos | 4 millones (130.000 al día) | 40 millones |
| Sesiones | 30.000 (1.000 al día) | 300.000 |
| 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 |
Precios usados, por demanda, publicados para us-east-1 cuando se escribió esto: funciones en arm64, USD 0,0000133 por GB-segundo y USD 0,20 por millón de solicitudes; cola, USD 0,40 por millón de solicitudes; almacenamiento de objetos, USD 0,023 por GB-mes, USD 5 por millón de escrituras, USD 0,40 por millón de lecturas; logs, USD 0,50 por GB. Revísalos antes de confiar en un total.
| Línea | Aritmética (pequeño) | Pequeño | Mediano |
|---|---|---|---|
| La dirección | 1,0 M de solicitudes. Dentro de la cuota gratuita del proveedor, 10 millones de solicitudes al mes; cerca de USD 1 por millón después | 0,00 | 0,00 |
Solicitudes de ingest | 1,0 M × 0,20 | 0,20 | 2,00 |
Tiempo de ingest | 1,0 M × 0,05 s × 0,25 GB = 12.500 GB-s | 0,17 | 1,67 |
| Cola | 0,9 M de envíos + unos 0,6 M de recepciones y borrados = 1,5 M × 0,40 | 0,60 | 4,00 |
worker, despertado por la cola | Máximo una vez cada 10 s: 260.000 × 0,5 s × 1 GB = 130.000 GB-s (2 s cada una en el mediano) | 1,78 | 6,98 |
worker, marca del minuto | 43.200 × 1 s × 1 GB (2 s en el mediano) | 0,58 | 1,15 |
worker, consolidación | 8.640 corridas × 5 s × 1 GB (30 s en el mediano) | 0,58 | 3,46 |
| Escrituras de objetos | 260.000 segmentos + 60.000 archivos por sesión + 100.000 fragmentos = 0,42 M × 5 | 2,10 | 10,50 |
| Lecturas de objetos | La consolidación relee la hora abierta: máximo 3,1 M × 0,40 | 1,24 | 2,00 |
| Almacenamiento de objetos | 1,2 GB por millón de eventos; 90 días de eventos, 30 de grabaciones: unos 8 GB × 0,023 | 0,18 | 1,84 |
| Logs | Éxitos muestreados al 1 %: cerca de 1 GB | 0,50 | 2,00 |
| Motor, sin Postgres | ≈ USD 8 | ≈ USD 36 | |
| Postgres | La instancia administrada más pequeña, con 1 GB de memoria y 20 GB de disco; 2 a 4 GB de memoria en el mediano | ≈ 14 | 25 a 50 |
| Total | ≈ USD 22 | ≈ USD 60 a 85 |
Tres cosas que leer de la tabla:
- La base de datos es la línea más grande en tamaños pequeños. También es la que quizá ya tienes: sirve cualquier Postgres 15 o posterior.
- Escribir objetos cuesta más que todo lo guardado. Medido allá: de USD 3,81 de almacenamiento de objetos en 12 días, USD 2,73 fueron escrituras. Por eso los lotes se agrupan en segmentos y los fragmentos de grabación son de 200 KB y no más pequeños.
- Recibir es casi gratis. Aceptar un millón de lotes cuesta menos de 40 centavos.
La cuota gratuita de AWS para funciones, 400.000 GB-segundos y un millón de solicitudes al mes, cubre casi todas las líneas de funciones del proyecto pequeño. El total pequeño coincide con lo que cuesta el primer despliegue de este diseño, USD 15 a 25 al mes.
Fuera de la tabla: el modelo. Un análisis son unos miles de tokens de entrada y máximo dos mil de salida, máximo 100 al día por proyecto, al precio de tu proveedor. Y los datos que salen de AWS cuando ves grabaciones, que es el tamaño de la grabación.
Como un proceso largo
sypnia serve es el motor completo en un proceso: el servidor HTTP para la ingesta, la API, el servidor MCP y la Consola, y el worker.
| Tarea dentro del proceso | Hace | Cada |
|---|---|---|
| Servidor HTTP | Ingesta, OTLP, API, servidor MCP, Consola | Cada solicitud |
| Escritor del búfer | Cierra los segmentos abiertos, los escribe y deja en cola sus filas del registro | 2 s, o 4 MiB |
| Ciclo del worker | Engine::pass: vía rápida, alertas, disponibilidad, y la consolidación cuando toca | processing.interval_seconds, 30 s; de inmediato cuando cae un segmento |
| Tareas del agente | Una por trabajo, máximo 4 a la vez | Cuando la vía rápida deja una en cola |
| Refresco de la caché | Llaves, orígenes, límites, slow_down | 60 s |
| Tarea diaria | Parquet, retención, particiones | 02:30 UTC |
Fíjate en el extracto en que el ciclo del worker espera lo que ocurra primero, el temporizador o un segmento que cae, y en que al apagarse deja terminar el paso en curso.
pub async fn run(engine: Arc<Engine>, args: ServeArgs) -> Result<(), ServeError> {
let stop = CancellationToken::new();
let mut tasks = JoinSet::new();
if args.role.serves_http() {
let app = Router::new()
.merge(ingest::router(engine.clone())) // /v1/ingest/*, /v1/otlp/*
.merge(api::router(engine.clone())); // /v1/*, /mcp, /console, /healthz
let listener = TcpListener::bind(engine.config.listen).await?;
let stopping = stop.clone();
tasks.spawn(async move {
axum::serve(listener, app)
.with_graceful_shutdown(async move { stopping.cancelled().await })
.await
.map_err(ServeError::from)
});
}
if args.role.works() {
let (engine, stopping) = (engine.clone(), stop.clone());
tasks.spawn(async move {
let every = engine.config.processing.interval;
loop {
if let Err(error) = engine.pass().await {
tracing::error!(%error, "pass failed; the next one repeats it");
}
tokio::select! {
_ = tokio::time::sleep(every) => {}
_ = engine.segment_landed.notified() => {} // que una falla no espere 30 s
_ = stopping.cancelled() => return Ok(()),
}
}
});
}
shutdown_signal().await; // SIGTERM o Ctrl-C
stop.cancel(); // las solicitudes tienen 20 s; los segmentos abiertos se escriben; la pasada termina su paso
while let Some(done) = tasks.join_next().await {
done??;
}
Ok(())
}Tamaño. El proceso del motor necesita memoria para dos proyectos en consolidación (2 × 256 MB), el búfer de la ingesta (32 MiB) y la caché de source maps (200 MB): con 1 GB va cómodo, con 2 GB sobra espacio. Un núcleo de CPU alcanza para el proyecto pequeño de arriba; el trabajo es esperar al Bucket y a Postgres, no calcular. Con Postgres y el bucket en la misma máquina, calcula más: Escalado y costo tiene los tamaños.
Escalar. Corre varios procesos contra el mismo Bucket y el mismo Postgres, cada uno con un rol:
sypnia serve --role ingest --listen 0.0.0.0:8081 # los que necesites, detrás de tu balanceador
sypnia serve --role api --listen 0.0.0.0:8082
sypnia serve --role worker # dos workers no chocan: el registro decide quién hace quéCon la ingesta y el worker separados, un segmento que cae no puede despertar al worker directamente. El worker lo encuentra en el registro en su siguiente pasada, máximo 30 segundos después, que es el caso para el que se calcula el presupuesto de 2 minutos en Flujo de datos.
Costo. El precio del servidor, más Postgres y un bucket si no están en la misma máquina. El archivo de Docker Compose de Desplegar con Docker arranca juntos el motor, Postgres y un almacenamiento compatible con S3, para probarlo en una máquina.
Las piezas que puedes cambiar
El motor toca el mundo exterior en cuatro lugares. Cada uno es un trait en el código y una elección en la documentación. El despliegue por defecto usa la opción más pequeña de cada uno.
Los dos traits que no aparecen en otras páginas. Fíjate en que cada método del almacén recibe una llave armada por Keys, nunca un texto, y en que una salida recibe una alerta terminada y no puede cambiarla.
/// (1) Dónde viven los objetos. Implementado sobre el crate `object_store` para almacenes compatibles con S3,
/// y sobre una carpeta para pruebas y para `sypnia serve` en un portátil.
#[async_trait]
pub trait ObjectStore: Send + Sync {
async fn put(&self, key: &ObjectKey, body: Bytes, options: PutOptions) -> Result<(), StoreError>;
/// El objeto como líneas, descomprimidas a medida que se leen. Un segmento nunca está dos veces en memoria.
async fn read_lines(&self, key: &ObjectKey) -> Result<LineStream, StoreError>;
async fn get(&self, key: &ObjectKey) -> Result<Bytes, StoreError>;
/// Llaves bajo un prefijo, en orden. `after` continúa un listado sin releerlo.
async fn list(&self, prefix: &KeyPrefix, after: Option<&ObjectKey>) -> Result<Vec<ObjectMeta>, StoreError>;
async fn delete_prefix(&self, prefix: &KeyPrefix) -> Result<u64, StoreError>;
/// Un enlace que un navegador puede usar directamente: para reproducir un fragmento o subir un source map.
async fn sign(&self, key: &ObjectKey, method: SignedMethod, ttl: Duration) -> Result<Url, StoreError>;
}
/// (4) A dónde va una alerta liberada. El motor trae dos: el registro y el webhook.
#[async_trait]
pub trait AlertSink: Send + Sync {
fn name(&self) -> &str;
/// Se llama una vez por alerta liberada. Un error se reintenta con esperas crecientes y queda anotado como entrega.
async fn deliver(&self, alert: &ReleasedAlert) -> Result<Delivery, SinkError>;
}Database (2) es la misma idea con más métodos: uno por sentencia que corre el motor, agrupados por tabla, implementados una vez con sqlx para Postgres. Es un trait para que las pruebas puedan contar consultas y hacerlas fallar, no porque se planee otra base de datos. AiProvider (3) está en El proceso del agente.
Una pieza que eliges tú
Almacenamiento de objetos
Guarda los eventos crudos, los fragmentos de grabación, las capturas de página y los source maps.
- Despliegue por defecto
- El bucket que crea la plantilla, o el que nombres en SYPNIA_STORAGE_BUCKET.
- Sypnia Cloud usa
- Amazon S3.
Una pieza que eliges tú
Base de datos
Guarda los agregados, el índice de sesiones, los problemas y la configuración.
- Despliegue por defecto
- Una URL de Postgres que tú das, o la instancia que crea la plantilla.
- Sypnia Cloud usa
- Postgres.
Una pieza que eliges tú
Entrega de alertas
Lleva una alerta del motor a una persona.
- Despliegue por defecto
- Ninguna. Las alertas se registran, se muestran en la Consola y se envían a un webhook si pones uno.
- Sypnia Cloud usa
- Correo con Amazon SES y alertas dentro de la app.
Una pieza que eliges tú
Proveedor de IA
Corre el modelo detrás del análisis del agente y del prompt listo.
- Despliegue por defecto
- Apagado hasta que pongas una llave.
- Sypnia Cloud usa
- OpenRouter.
No hay salida de WhatsApp ni de Slack, ni en el motor ni en Sypnia Cloud. Un AlertSink para cualquiera de los dos son unas pocas decenas de líneas de tu lado del webhook, y el motor no necesita saberlo.
Qué forma elegir
| Si tú | Elige |
|---|---|
| Ya tienes cosas en AWS y quieres pagar por uso, no por un servidor sin tráfico | Funciones de AWS |
| Quieres todo en una máquina, o no estás en AWS | Un proceso |
| Quieres probar el motor en un portátil | Un proceso, con Docker Compose |
| Esperas tráfico en ráfagas | Funciones de AWS: aparecen más copias por sí solas |
| Necesitas que tus datos nunca salgan de tu red, incluido el modelo | Un proceso, con un endpoint compatible con OpenAI dentro de tu red |
Puedes cambiar de opinión. La disposición del Bucket y las tablas son las mismas, así que mudarse es apuntar la otra forma al mismo Bucket y al mismo Postgres.
Qué cambió frente al sistema del que sale
| Allá | Aquí | Por qué |
|---|---|---|
| Solo funciones, desplegadas con la app | Funciones, o un proceso | Brief §10.9: el mismo binario en las dos formas |
| Una función de ingesta, una de cada hora, una diaria y una semanal, cada una con su programación | Tres funciones por rol; el worker tiene una cola y una programación | Una función por rol coincide con --role, y un binario tiene una sola configuración |
| Un flujo de entrega administrado entre la ingesta y el bucket | Una cola en AWS, memoria en lo demás | Frescura, y objetos nombrados por proyecto |
| Solo x86_64, por un binario nativo | arm64, o cualquier destino para el que compile Rust | Ya no queda dependencia nativa |
| Cinco variables de entorno en la app para enviar datos del servidor | Una llave de ingesta y una URL | Su app llegó una vez a 3.924 de los 4.096 bytes que admite el entorno de una función |
Sigue
- La plantilla, paso a paso.
- Un proceso, con Postgres y un bucket al lado.
- Dónde vive cada una de estas piezas en el repositorio.