# Alojamiento propio

> Qué corres cuando alojas tú mismo el motor de Sypnia, qué necesitas, cuánto cuesta y qué no tienes frente a Sypnia Cloud.

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

Para agentes: Resumen del alojamiento propio del motor de código abierto de Sypnia: las tres cosas que corres (el binario sypnia, Postgres 15+, un bucket compatible con S3), las dos formas de despliegue (plantilla de AWS, Docker Compose), requisitos, resumen de costos, qué debe estar corriendo para las comprobaciones de disponibilidad, y qué tiene solo Sypnia Cloud.

**\[Motor]** Esta sección es para quien va a correr el motor de código abierto en su propia infraestructura. Nada de aquí aplica a Sypnia Cloud, donde nosotros corremos el mismo motor por ti. Si solo quieres probar el motor en tu computador, empieza por el [inicio rápido con alojamiento propio](https://docs.sypnia.com/es/start/quickstart-self-host) y vuelve aquí antes de ponerle tráfico real.

> **En palabras simples**
>
> Alojamiento propio significa que Sypnia corre en servidores que tú pagas y cuidas. Tus datos nunca salen de ahí. A cambio, el trabajo que un servicio haría por ti es tuyo: instalar, actualizar, respaldar, y conectar las piezas que te mandan un correo o escriben la frase en palabras simples.

> **Nota: El motor todavía no está publicado**
>
> Estas páginas son el contrato del motor, escrito antes que su código. Los nombres que aparecen aquí (el binario `sypnia`, la imagen `ghcr.io/sypnia/sypnia:1`, la plantilla de AWS `sypnia-aws.yaml`) son los planeados. Los costos, tamaños y tiempos son estimaciones con su aritmética, o cifras medidas en el sistema del que sale este motor, y cada una dice cuál es.

## Qué corres

Tres cosas, y nada más:

| Pieza                          | Qué es                                                                                                                                                        | Qué guarda                                                                                                                      |
| ------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------- |
| **El motor**                   | Un programa, `sypnia`. Recibe eventos, los procesa, responde la API y el servidor MCP, y sirve la [Consola](https://docs.sypnia.com/es/self-hosting/console). | Nada. No guarda estado propio.                                                                                                  |
| **Un bucket**                  | Cualquier almacenamiento de objetos compatible con S3: Amazon S3, Cloudflare R2, MinIO.                                                                       | Eventos crudos, fragmentos de grabación, capturas de página, source maps.                                                       |
| **Una base de datos Postgres** | Versión 15 o posterior: Amazon RDS, Supabase, Neon o tu propio servidor.                                                                                      | Los problemas, el índice de sesiones, los números por hora y por día, los proyectos, las llaves, los tokens y la configuración. |

Qué más hay depende de la forma en que despliegues:

- **Como un solo proceso de larga duración** (Docker, o cualquier servidor): nada además del motor, Postgres y el bucket. Ni cola, ni caché, ni servidor de búsqueda.
- **Con la plantilla de AWS:** el motor corre como tres funciones, y la plantilla crea además una programación y una cola administrada entre la ingesta y el worker. No operas ninguna de las dos: no hay nada que parchar, dimensionar ni reiniciar.

Por qué bastan dos almacenes está en [Cómo está construido el motor](https://docs.sypnia.com/es/architecture), y las dos formas lado a lado están en [Formas de despliegue](https://docs.sypnia.com/es/architecture/deployment-shapes).

Cada pieza que depende de un proveedor la eliges tú. Dos de ellas, la entrega de alertas y el proveedor de IA, están apagadas hasta que las conectas, y el motor funciona sin ninguna de las dos:

| Pieza                     | Despliegue por defecto                                                                   | Alternativas que explica la documentación                                                                                      | Sypnia Cloud usa                                   |
| ------------------------- | ---------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------- |
| Almacenamiento de objetos | El bucket que crea la plantilla.                                                         | Cualquier almacenamiento compatible con S3: Amazon S3, Cloudflare R2, MinIO.                                                   | Amazon S3.                                         |
| Base de datos             | Una URL de Postgres que das tú, o la que crea la plantilla.                              | Amazon RDS, Supabase, Neon o tu propio servidor.                                                                               | Postgres.                                          |
| Entrega de alertas        | **Ninguna.** Las alertas quedan registradas, y se envían a un webhook si configuras uno. | Recetas: correo con Amazon SES, correo con cualquier servidor SMTP, o tu propia función sobre el webhook.                      | Correo con Amazon SES, y alertas dentro de la app. |
| Proveedor de IA           | **Apagado** hasta que pongas una llave.                                                  | OpenRouter, la API de OpenAI, la API de Anthropic, Google Gemini, o cualquier endpoint compatible con OpenAI, alojado o local. | OpenRouter.                                        |
| Pull requests             | No está en el motor.                                                                     | Usa el prompt o el servidor MCP con tu propio agente de código.                                                                | La Sypnia GitHub App.                              |

## Dos formas de desplegar

El mismo binario corre de dos formas. Elige según lo que ya operas.

|                             | [Desplegar en AWS](https://docs.sypnia.com/es/self-hosting/deploy-aws)                                                                                                                            | [Desplegar con Docker](https://docs.sypnia.com/es/self-hosting/deploy-docker)                                                                                              |
| --------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Qué corre                   | Tres funciones (ingesta, API, worker), una cola administrada, una programación, un bucket y una dirección por delante, todo creado por la plantilla. Postgres lo crea la plantilla o lo traes tú. | Un proceso de larga duración, `sypnia serve`, junto a un Postgres y un bucket.                                                                                             |
| Qué cuidas tú               | Casi nada entre una actualización y otra. No hay servidor que parchar.                                                                                                                            | Un servidor: su disco, sus actualizaciones, sus reinicios.                                                                                                                 |
| Sirve cuando                | El tráfico llega por ráfagas, o ya vives en AWS.                                                                                                                                                  | Tienes un servidor, quieres una factura que no se mueva, o no usas AWS.                                                                                                    |
| Montaje sensato más pequeño | Los valores por defecto de la plantilla.                                                                                                                                                          | 2 vCPU, 4 GB de memoria y 40 GB de disco para todo en una sola máquina (una estimación; ver [Escalado y costo](https://docs.sypnia.com/es/self-hosting/scaling-and-cost)). |
| Sypnia Cloud usa            | Esta forma, en `us-east-1`.                                                                                                                                                                       |                                                                                                                                                                            |

Puedes pasar de una a la otra más adelante: ambas leen la misma estructura del bucket y el mismo esquema de base de datos.

## Qué necesitas

- **Un dominio y HTTPS.** Los navegadores envían a la dirección del motor, y esa dirección queda escrita en tu app. Elígela una sola vez: `https://sypnia.example.com`.
- **Una cuenta con un proveedor de nube, o un servidor.** Para AWS, permiso para crear funciones, un bucket, una cola y roles. Para Docker, una máquina Linux con Docker y Compose.
- **Alguien que sepa restaurar un respaldo de Postgres.** La base de datos guarda lo que no se puede reconstruir: tus proyectos, llaves, tokens, y lo que las personas marcaron en los problemas. Ver [Actualizaciones, respaldos y retención](https://docs.sypnia.com/es/self-hosting/upgrades-backups-retention).
- **Cerca de una hora** para el primer despliegue, y unos minutos para cada actualización.
- **Una llave de modelo**, solo si quieres la frase en palabras simples. Sin ella el motor funciona, y los problemas conservan su título técnico. Ver [Modelos y qué se envía](https://docs.sypnia.com/es/agent/models-and-what-is-sent).

No necesitas una cuenta de Sypnia. Un motor con alojamiento propio nunca se comunica con Sypnia, la empresa: no hay verificación de licencia, ni reporte de uso, ni telemetría.

## Cuánto cuesta

El motor es gratis: no hay costo de licencia ni límite puesto por nosotros a los proyectos, eventos, grabaciones o retención. Le pagas a tu propio proveedor.

| Tamaño  | Tráfico                                                                                   | En AWS                                             | Un servidor con Docker      |
| ------- | ----------------------------------------------------------------------------------------- | -------------------------------------------------- | --------------------------- |
| Pequeño | Cerca de 1.000 sesiones y 130.000 eventos al día (4 millones de eventos al mes)           | Cerca de USD 22 al mes, casi todo la base de datos | Cerca de USD 25 a 30 al mes |
| Mediano | Cerca de 10.000 sesiones y 1,3 millones de eventos al día (40 millones de eventos al mes) | Cerca de USD 60 a 85 al mes                        | Cerca de USD 60 a 75 al mes |

Son estimaciones, no cotizaciones. La aritmética de cada número, qué lo mueve, y las cifras medidas en el sistema del que sale este motor están en [Escalado y costo](https://docs.sypnia.com/es/self-hosting/scaling-and-cost).

## Qué no tienes

El motor hace todo el trabajo de recibir, guardar y analizar. Lo que agrega Sypnia Cloud es todo lo que lo rodea. Si alojas tú, nada de esto existe a menos que lo construyas:

| Sypnia Cloud tiene                                                                                      | Un motor con alojamiento propio tiene                                                                                                                                                                                                                                                                  |
| ------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| La app completa: pantallas de rendimiento, disponibilidad y mapas de clics, búsqueda, el resumen diario | La [Consola](https://docs.sypnia.com/es/self-hosting/console): la lista de problemas y el visor de grabaciones de sesión. Todo lo demás son datos que lees por la [API](https://docs.sypnia.com/es/api), la [CLI](https://docs.sypnia.com/es/cli) o el [servidor MCP](https://docs.sypnia.com/es/mcp). |
| Usuarios, organizaciones y roles                                                                        | Proyectos, llaves de ingesta y tokens de API. Quien tiene un token, entra.                                                                                                                                                                                                                             |
| Alertas por correo y dentro de la app                                                                   | Alertas registradas, y enviadas a un webhook si configuras uno. El despliegue por defecto no envía correos. Receta: [Correos de alerta desde un motor con alojamiento propio](https://docs.sypnia.com/es/guides/alert-emails-self-hosted).                                                             |
| El resumen diario por correo                                                                            | No hay correo de resumen. `GET /v1/summary` devuelve lo que está fallando ahora.                                                                                                                                                                                                                       |
| El agente, con un modelo incluido                                                                       | El agente, apagado hasta que pongas tu propia llave de modelo.                                                                                                                                                                                                                                         |
| Pull requests abiertos por la Sypnia GitHub App                                                         | No hay pull requests. Usa [el prompt](https://docs.sypnia.com/es/agent/the-prompt) o el servidor MCP con tu propio agente de código.                                                                                                                                                                   |
| Comprobaciones de disponibilidad desde tres regiones                                                    | Comprobaciones de disponibilidad desde el único lugar donde corre tu worker.                                                                                                                                                                                                                           |
| Actualizaciones, respaldos y capacidad a cargo nuestro                                                  | A cargo tuyo.                                                                                                                                                                                                                                                                                          |
| Soporte por correo en los planes pagos                                                                  | Soporte de la comunidad, en el repositorio del motor.                                                                                                                                                                                                                                                  |

No hay integración con WhatsApp ni con Slack en ninguno de los dos.

## Qué debe estar corriendo para cada función

Un solo proceso iniciado con `sypnia serve` lo corre todo. Si divides el motor en roles, o lo corres como funciones, esto es lo que necesita cada función:

| Función                                                            | Necesita                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| ------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Recibir eventos, fragmentos de grabación y trazas de OpenTelemetry | El rol `ingest`, alcanzable desde los navegadores en tu URL base.                                                                                                                                                                                                                                                                                                                                                                           |
| Problemas nuevos, sesiones, números, alertas, webhooks, retención  | El rol `worker`, o `sypnia aggregate` ejecutado cada minuto por tu propio programador de tareas.                                                                                                                                                                                                                                                                                                                                            |
| **Comprobaciones de disponibilidad**                               | El rol `worker`, y `SYPNIA_UPTIME_ENABLED` en `true`. Las comprobaciones se hacen desde la máquina o la región donde corre el worker, así que ve tu app desde un solo lugar. Si el worker comparte servidor con la app que vigila, una caída de ese servidor detiene también las comprobaciones: córrelas desde otro lugar. Las direcciones privadas y de loopback se rechazan a menos que actives `SYPNIA_UPTIME_ALLOW_PRIVATE_ADDRESSES`. |
| La API, el servidor MCP y la Consola                               | El rol `api`.                                                                                                                                                                                                                                                                                                                                                                                                                               |
| La frase en palabras simples                                       | El rol `worker` y un proveedor de IA.                                                                                                                                                                                                                                                                                                                                                                                                       |

Los roles son una opción de [`sypnia serve`](https://docs.sypnia.com/es/cli/commands). El valor por defecto, `all`, es cada fila de esta tabla en un solo proceso.

## Las páginas de esta sección

- [Desplegar en AWS](/es/self-hosting/deploy-aws/): Despliega el motor de Sypnia en tu propia cuenta de AWS con una sola plantilla de CloudFormation, compruébalo, crea el primer proyecto, apúntale un dominio, actualízalo y elimínalo.
- [Desplegar con Docker](/es/self-hosting/deploy-docker/): Corre el motor de Sypnia en cualquier servidor con Docker Compose, junto a un Postgres y un almacenamiento compatible con S3, con HTTPS, un primer proyecto, sus llaves y una comprobación de salud.
- [Referencia de configuración](/es/self-hosting/configuration/): Cada ajuste del motor de Sypnia: su variable de entorno, su tipo, su valor por defecto y qué cambia, con las opciones de cada pieza que tú eliges.
- [Estructura del almacenamiento](/es/self-hosting/storage-layout/): Dónde guarda cada tipo de dato un motor con alojamiento propio, cuánto espacio ocupa, cómo medirlo, y qué reglas ponerle al bucket y cuáles evitar.
- [La Consola](/es/self-hosting/console/): Qué muestra la única página integrada del motor, cómo abrirla con un token de API, cómo protegerla o apagarla, y qué no hace frente a la app de Sypnia Cloud.
- [Actualizaciones, respaldos y retención](/es/self-hosting/upgrades-backups-retention/): Cómo actualizar un motor con alojamiento propio sin perder datos, qué respaldar y cómo restaurarlo, y cómo elegir cuánto tiempo se guarda cada tipo de dato.
- [Escalado y costo](/es/self-hosting/scaling-and-cost/): 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.
- [Lista de seguridad](/es/self-hosting/security-checklist/): Qué cerrar en un motor con alojamiento propio antes de que le llegue tráfico real, cada punto con el ajuste o el comando que lo hace y la comprobación que lo demuestra.

## El orden a seguir

### 1. Pruébalo en tu máquina

Sigue el [inicio rápido con alojamiento propio](https://docs.sypnia.com/es/start/quickstart-self-host). Toma unos quince minutos y te muestra cada pieza en movimiento.

### 2. Despliégalo donde va a vivir

[Desplegar en AWS](https://docs.sypnia.com/es/self-hosting/deploy-aws) o [Desplegar con Docker](https://docs.sypnia.com/es/self-hosting/deploy-docker). Ambos terminan con `sypnia doctor` en verde y un primer proyecto.

### 3. Recorre la lista de seguridad

La [lista de seguridad](https://docs.sypnia.com/es/self-hosting/security-checklist) es corta. Hazla antes de apuntar una app real al motor.

### 4. Configura los respaldos y luego decide la retención

[Actualizaciones, respaldos y retención](https://docs.sypnia.com/es/self-hosting/upgrades-backups-retention).

### 5. Conecta las piezas opcionales

Una llave de modelo para el agente, y un webhook para las alertas. Las dos están en la [referencia de configuración](https://docs.sypnia.com/es/self-hosting/configuration).
