# Lista de seguridad

> 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.

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

Para agentes: Lista para asegurar un motor de Sypnia con alojamiento propio antes de producción: el token raíz, HTTPS y el número de proxies, un bucket privado con una llave acotada y su regla CORS, una base de datos propia con TLS, tokens de API con los menos alcances posibles y vencimiento, orígenes permitidos y cuotas para las llaves de ingesta, la Consola y el servidor MCP, las llamadas salientes (comprobaciones de disponibilidad, webhooks, el proveedor de IA), respaldos, logs y actualizaciones. Cada punto nombra el ajuste o el comando exacto y cómo verificarlo.

**\[Motor]** Esta página es para quien está por apuntar una app real a un motor con alojamiento propio. Recórrela una vez antes de producción y otra después de cualquier cambio en el despliegue. En Sypnia Cloud esto es trabajo nuestro, y lo que hacemos está en [Prácticas de seguridad](https://docs.sypnia.com/es/privacy/security-practices).

Empieza por la comprobación del propio motor. La mayoría de los puntos de abajo aparecen ahí:

```bash
sypnia doctor
```

**Deberías ver:**`all checks passed`, con `0 unknown` en la configuración y ninguna línea de advertencia. Un webhook sin secreto, o una variable mal escrita, es una advertencia aquí.

> **Nota: Qué es esta lista y qué no**
>
> Cubre el motor y las piezas que lo rodean. Es una lista de prácticas, no una certificación: seguirla no hace que un despliegue cumpla con ninguna ley o estándar. Tu servidor, tu cuenta de nube y tu red tienen su propio endurecimiento, que no le corresponde a Sypnia describir.

## 1. El token raíz

El token raíz puede hacer todo en todos los proyectos, incluso eliminarlos.

| Haz esto                                                      | Cómo                                                                                                                | Comprobación                                                                                        |
| ------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------- |
| Que sea largo y aleatorio                                     | `openssl rand -hex 32`. El motor rechaza menos de 32 caracteres.                                                    | El motor arranca.                                                                                   |
| Mantenlo fuera de las apps, del CI y de los agentes de código | Úsalo para crear los proyectos y sus primeros tokens, y luego guárdalo. Todo lo demás funciona con un token de API. | Búscalo en los secretos de tu CI y en la configuración de tus agentes: no debería estar en ninguno. |
| Nunca lo pegues en un navegador                               | La [Consola](https://docs.sypnia.com/es/self-hosting/console) lo rechaza.                                           |                                                                                                     |
| Aprende a reemplazarlo                                        | Cambia `SYPNIA_ROOT_TOKEN` y reinicia. El viejo deja de funcionar de inmediato.                                     | `curl -i <tu URL base>/v1/whoami -H "Authorization: Bearer <el token viejo>"` responde `401`.       |

## 2. La dirección

| Haz esto                                      | Cómo                                                                                                                                                                                                                               | Comprobación                                                                      |
| --------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------- |
| Sirve todo por HTTPS                          | Un proxy o un balanceador de carga con TLS delante del motor. `SYPNIA_BASE_URL` empieza por `https://`.                                                                                                                            | La línea `address` de `sypnia doctor`.                                            |
| Deja privado el puerto del motor              | Solo el proxy llega al puerto 8080. En el archivo de Compose el servicio `sypnia` no tiene `ports`.                                                                                                                                | Desde fuera: `curl <dirección del servidor>:8080/healthz` no recibe respuesta.    |
| Dile al motor cuántos proxies tiene delante   | `SYPNIA_TRUSTED_PROXY_HOPS`: `1` detrás de un proxy, `0` sin ninguno. Si es muy bajo, todos los visitantes comparten un solo límite de peticiones. Si es muy alto, quien llama puede falsear su dirección para esquivar el límite. | Envía peticiones desde dos redes: cada una tiene su propio `RateLimit-Remaining`. |
| Deja la API de lectura cerrada a otros sitios | `SYPNIA_API_CORS_ORIGINS` vacío, salvo que una app web tuya llame a la API de lectura desde un navegador.                                                                                                                          |                                                                                   |

## 3. El bucket

| Haz esto                                                      | Cómo                                                                                                                                                                                        | Comprobación                                                         |
| ------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------- |
| Mantenlo privado                                              | Bloquea todo acceso público. Nada se lee jamás sin un enlace que firma el motor. La plantilla de AWS lo hace.                                                                               | Abre la dirección simple de cualquier objeto en un navegador: `403`. |
| Dale al motor una llave solo para este bucket                 | Una llave o un rol que pueda leer, escribir, listar y borrar en este único bucket. En AWS, deja las llaves vacías y que el motor use su rol.                                                | Con esa llave, listar otro bucket se rechaza.                        |
| Deja que solo tu dirección lea grabaciones desde un navegador | La regla CORS del bucket nombra tu URL base, no `*`. Ver [la regla](https://docs.sypnia.com/es/self-hosting/deploy-docker#dejar-que-los-navegadores-lean-grabaciones-de-un-bucket-alojado). |                                                                      |
| Que los enlaces firmados duren poco                           | `SYPNIA_STORAGE_PRESIGN_TTL_SECONDS` en su valor por defecto de 900, o menos.                                                                                                               |                                                                      |
| Cífralo en reposo                                             | El ajuste propio de tu almacenamiento. La plantilla de AWS lo enciende.                                                                                                                     |                                                                      |
| Deja el versionado apagado, o vence las versiones viejas      | Si no, los datos eliminados sobreviven en las versiones viejas. Ver [Estructura del almacenamiento](https://docs.sypnia.com/es/self-hosting/storage-layout#reglas-en-el-bucket).            |                                                                      |

## 4. La base de datos

| Haz esto                                             | Cómo                                                                                                                                                                                                                                                                       | Comprobación                                                   |
| ---------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------- |
| Dale a Sypnia una base de datos y un usuario propios | No la base de datos de tu app. El usuario necesita crear tablas en su propio esquema, nada más.                                                                                                                                                                            |                                                                |
| Cifra la conexión                                    | `?sslmode=require` al final de `SYPNIA_DATABASE_URL` siempre que la base de datos no esté en la misma máquina.                                                                                                                                                             | La línea `database` de `sypnia doctor`.                        |
| Limita quién puede llegar a ella                     | Una red privada o una lista de permitidos donde puedas. La base de datos que crea la plantilla de AWS se alcanza desde internet, con TLS y una contraseña generada; lee [por qué](https://docs.sypnia.com/es/self-hosting/deploy-aws#qu%C3%A9-crea-la-plantilla) y decide. |                                                                |
| Respáldala, y prueba una restauración                | [Respaldos](https://docs.sypnia.com/es/self-hosting/upgrades-backups-retention#respaldos).                                                                                                                                                                                 | Existe un volcado de anoche en un lugar que no es el servidor. |

## 5. Tokens de API

Un token de API lee tu proyecto. Con `replay` lee lo que tus usuarios vieron en sus pantallas. Con `admin` cambia la configuración y elimina datos.

| Haz esto                                          | Cómo                                                                                                                            | Comprobación                                                                         |
| ------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------ |
| Un token por persona y por herramienta            | `sypnia token create --name` dice quién o qué.                                                                                  | `sypnia token list --project shop` se lee como una lista de personas y herramientas. |
| Los menos alcances posibles                       | `read` para un agente de código. `read,replay` para una persona que ve grabaciones. `admin` solo para el CI y para ti.          |                                                                                      |
| Una fecha de vencimiento                          | `--expires 90d` para personas, `--expires 365d` para el CI.                                                                     | La columna `EXPIRES` no tiene ningún `never` que no puedas explicar.                 |
| Revoca lo que no se usa                           | `sypnia token revoke`. Se rechaza en menos de un minuto.                                                                        | La columna `LAST USED`.                                                              |
| Mantén los tokens fuera del código y de los chats | En los secretos de tu CI y en la configuración propia de tu agente. Nunca en un repositorio, un ticket o un mensaje de soporte. |                                                                                      |

## 6. Llaves de ingesta

Una llave de ingesta es pública por diseño: cualquiera que lea tu página puede enviar eventos con ella. Lo que te protege es lo que la llave no puede hacer, y tres límites que pones tú.

| Haz esto                                                | Cómo                                                                                                                                     | Comprobación                                                      |
| ------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------- |
| Lista los orígenes que pueden enviar desde un navegador | `PATCH /v1/projects/{project_ref}` con `{"settings": {"allowed_origins": ["https://shop.example.com"]}}`. Vacío acepta cualquier origen. | Una petición con otro `Origin` responde `403 origin_not_allowed`. |
| Una llave por app                                       | `sypnia key create --project shop --name "Checkout API"`, para poder revocar una sin detener las demás.                                  |                                                                   |
| Un límite de peticiones a la medida                     | `--rate-limit` en la llave, o `SYPNIA_RATE_LIMIT_INGEST_PER_MINUTE` para las llaves nuevas.                                              |                                                                   |
| Un techo a lo que puede guardar un proyecto             | `SYPNIA_QUOTA_EVENTS_PER_MONTH` y `SYPNIA_QUOTA_REPLAYS_PER_MONTH`. Protegen tu almacenamiento y tu factura de un bucle o de un abuso.   | `GET /v1/usage` muestra los límites.                              |

Los orígenes permitidos impiden que otros sitios web envíen con tu llave. No detienen a un script que falsea el encabezado; para eso están el límite de peticiones y la cuota.

## 7. La Consola y el servidor MCP

| Haz esto                                                               | Cómo                                                                                                                                                  | Comprobación                        |
| ---------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------- |
| Decide quién puede cargar la Consola                                   | Una regla del proxy sobre `/console`, o `SYPNIA_CONSOLE_ENABLED=false`. Ver [Protegerla](https://docs.sypnia.com/es/self-hosting/console#protegerla). |                                     |
| Decide si los agentes de código pueden marcar problemas como resueltos | `SYPNIA_MCP_READ_ONLY=true` quita la única herramienta de MCP que escribe. Ver [Seguridad de MCP](https://docs.sypnia.com/es/mcp/security).           |                                     |
| Apaga lo que no uses                                                   | `SYPNIA_MCP_ENABLED=false` quita el servidor MCP en `/mcp`.                                                                                           | `<tu URL base>/mcp` responde `404`. |

## 8. A qué llama el motor

El worker hace peticiones a direcciones que eligen las personas con un token `admin`. Deja los valores por defecto salvo que tengas un motivo.

| Haz esto                                                            | Cómo                                                                                                                                                                                                                                                                                                                                           |
| ------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Mantén las comprobaciones de disponibilidad lejos de tu red privada | `SYPNIA_UPTIME_ALLOW_PRIVATE_ADDRESSES` se queda en `false`. Si no, cualquiera con un token `admin` puede hacer que el motor sondee direcciones dentro de tu red.                                                                                                                                                                              |
| Mantén los webhooks en HTTPS y en direcciones públicas              | `SYPNIA_WEBHOOKS_ALLOW_HTTP` se queda en `false`.                                                                                                                                                                                                                                                                                              |
| Firma el webhook de alertas                                         | Configura `SYPNIA_ALERT_WEBHOOK_SECRET`, y comprueba la firma en tu receptor. Ver [la referencia de webhooks](https://docs.sypnia.com/es/api/webhooks).                                                                                                                                                                                        |
| Decide qué puede ver el proveedor de IA                             | Con un proveedor configurado, el agente le envía stacks, trazas y las líneas de código alrededor de la falla. `SYPNIA_AI_SEND_SOURCE=false` deja tu código fuera. Un endpoint compatible con OpenAI dentro de tu red deja todo adentro. La lista completa: [Modelos y qué se envía](https://docs.sypnia.com/es/agent/models-and-what-is-sent). |
| Ponle tope a la factura del modelo                                  | Deja `SYPNIA_AI_MAX_ANALYSES_PER_DAY` en 100 o menos, y pon un límite de gasto a la llave en tu proveedor.                                                                                                                                                                                                                                     |

## 9. Qué se graba

Asegurar el motor es la mitad. La otra mitad es lo que envía tu app.

| Haz esto                                                         | Cómo                                                                                                                                                                                |
| ---------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Mira una grabación de cada pantalla sensible antes de producción | Lo que se escribe siempre se enmascara. El texto que muestra la página se graba como se ve, salvo que lo enmascares. Ver [Enmascarado](https://docs.sypnia.com/es/privacy/masking). |
| Apaga la grabación donde no corresponde                          | `settings.replay.blocked_routes` en el proyecto, o `SYPNIA_REPLAY_ENABLED=false` para todo el motor.                                                                                |
| No publiques tus source maps                                     | `sypnia sourcemaps upload … --delete-after` los quita de lo que despliegas.                                                                                                         |
| Elige cuánto viven los datos personales                          | [Retención](https://docs.sypnia.com/es/self-hosting/upgrades-backups-retention#retenci%C3%B3n).                                                                                     |
| Aprende a eliminar a una persona                                 | [Eliminar datos](https://docs.sypnia.com/es/privacy/deleting-data).                                                                                                                 |

## 10. Secretos, logs y actualizaciones

| Haz esto                                   | Cómo                                                                                                                                                                                                                                                                 |
| ------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Mantén privado el archivo de configuración | `chmod 600 .env`, y fuera de cualquier repositorio. En AWS la configuración son variables de entorno de las funciones: cualquiera en la cuenta que pueda leer la configuración de una función puede leerlas, incluido el token raíz. Limita quién tiene ese permiso. |
| Deja el nivel de logs en `info`            | El motor nunca registra cuerpos, llaves ni tokens, en ningún nivel. `debug` registra una línea por petición, que es mucho para guardar.                                                                                                                              |
| Cuida los logs del proxy                   | Guardan direcciones IP, y la llave de ingesta cuando un navegador la envía como `?key=`. La llave de ingesta es pública; las direcciones son datos personales. Guarda esos logs el menor tiempo que puedas.                                                          |
| Sigue las publicaciones                    | Vigila el repositorio del motor para enterarte de las versiones nuevas. Los arreglos de seguridad van marcados en el [registro de cambios](https://docs.sypnia.com/es/reference/changelog).                                                                          |
| Actualiza en un tiempo razonable           | Las [actualizaciones](https://docs.sypnia.com/es/self-hosting/upgrades-backups-retention#actualizaciones) están hechas para ser aburridas: migrar, reemplazar, comprobar.                                                                                            |

## Si algo salió mal

| Qué pasó                                  | Primero, en minutos                                                                              | Después                                                                                                                                                       |
| ----------------------------------------- | ------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Se filtró un token de API                 | `sypnia token revoke <token_id>`                                                                 | Crea uno nuevo. Revisa `LAST USED` en los demás.                                                                                                              |
| Se filtró el token raíz                   | Cambia `SYPNIA_ROOT_TOKEN` y reinicia                                                            | `sypnia project list` y `sypnia token list` para cada proyecto: busca cualquier cosa que no hayas creado tú.                                                  |
| Están abusando de una llave de ingesta    | `sypnia key create`, despliega tu app con la llave nueva, y luego `sypnia key revoke` a la vieja | Configura orígenes permitidos y una cuota. Los eventos que ya se guardaron se quedan; un proyecto en el que ya no confías se puede eliminar y volver a crear. |
| Una grabación muestra algo que no debería | Enmascara el elemento y despliega                                                                | Elimina las sesiones que lo grabaron: [Eliminar datos](https://docs.sypnia.com/es/privacy/deleting-data).                                                     |
| Encontraste una falla en Sypnia mismo     | No la publiques                                                                                  | Escribe a la dirección que está en [Prácticas de seguridad](https://docs.sypnia.com/es/privacy/security-practices#reportar-un-problema-de-seguridad).         |

## Relacionado
