--- title: "Cómo Instalar FlowiseAI con Docker Compose (2026)" description: "Instala FlowiseAI con Docker Compose y Postgres en 2026: montaje fijado en 3.1.4, secretos, endurecimiento, y qué significa el fin de vida de Flowise para self-hosters." date: 2026-10-09 categories: ["ai"] tags: ["flowise","docker","self-hosted"] --- import Button from "@components/widgets/Button.astro"; import Notice from "@components/widgets/Notice.astro"; import ListCheck from "@components/widgets/ListCheck.astro"; import Accordion from "@components/widgets/Accordion.astro"; import Tabs from "@components/widgets/Tabs.astro"; import Tab from "@components/widgets/Tab.astro"; import YouTubeEmbed from "@components/widgets/YouTubeEmbed.astro"; import { Picture, Image } from "astro:assets"; import imag1 from "@assets/images/24/01/cloudflare-tunel-setup.png"; import imag2 from "@assets/images/24/03/flowise_flow.png"; import imag3 from "@assets/images/24/03/flowise-usechat.png"; import eolTimeline from "@assets/images/24/03/flowise-eol-timeline.svg"; import architecture from "@assets/images/24/03/flowise-docker-architecture.svg"; [FlowiseAI](https://flowiseai.com/) es un constructor open-source de arrastrar y soltar para chatflows IA y flujos de trabajo de agentes, con licencia Apache 2.0, construido sobre Node.js y React. Antes de instalar nada, un hecho dirige cada decisión de abajo: **Flowise está en fin de vida.** La release final es **3.1.4** (29 de julio de 2026), el repo de GitHub fue archivado en solo lectura el 13 de agosto de 2026, y no salen parches de seguridad tras el 31 de agosto de 2026. Si aún quieres instalar FlowiseAI con Docker Compose (porque ya lo corres y necesitas el montaje congelado correcto, o porque quieres una herramienta low-code autocontenida que nunca cambiará debajo de ti), esta guía es el despliegue fijado a 3.1.4, con las correcciones de auth, volumen y secretos que las versiones viejas de este artículo hacían mal. Vamos a usar [Dockge](/es/instalar-dockge/) para gestionar el archivo Docker Compose y Cloudflare Tunnels como reverse proxy, así tienes SSL sin exponer el host. Incluiré un servicio de backup opcional con [Docker DB Backup](https://github.com/tiredofit/docker-db-backup) para tener volcados SQL cuando algo salga mal. El mismo archivo Compose funciona con `docker compose` a pelo y el reverse proxy que ya corras. > Si te interesa ver algunas apps self-hosted open source gratuitas y chulas puedes mirar la [sección self-hosted de toolhunt.net](https://toolhunt.net/sh/). ## Estado de Flowise: fin de vida (lee esto primero) Flowise detuvo el desarrollo activo el 29 de julio de 2026, el repo de GitHub fue archivado el 13 de agosto de 2026, y el proyecto pasó a fin de vida desde el 31 de agosto de 2026. No habrá parches de seguridad, nunca. Fuentes: el [anuncio de sunset en flowiseai.com](https://flowiseai.com/sunset) y el [hilo de discusión oficial](https://github.com/FlowiseAI/Flowise/discussions/6727). Cronología del fin de vida de Flowise 2026: congelación de código y release final 3.1.4 el 29 de julio, repo de GitHub archivado en solo lectura el 13 de agosto, fin de vida sin parches de seguridad el 31 de agosto Esta es la cronología tal como ocurrió: 1. **29 de julio de 2026**: Congelación de código. El desarrollo activo de features se detuvo y `flowise@3.1.4` salió como la release final. 2. **13 de agosto de 2026**: El [repositorio de GitHub](https://github.com/FlowiseAI/Flowise) pasó a archivo público (solo lectura). Issues y PRs bloqueados. El paquete npm y las imágenes Docker fueron marcados como deprecated. 3. **31 de agosto de 2026**: Fin de vida. El equipo núcleo dejó Discord y GitHub. Sin parches de seguridad desde esta fecha. Qué sigue funcionando: el código permanece disponible bajo Apache 2.0, y las imágenes Docker siguen descargables a fecha de esta actualización (octubre de 2026). Los forks están permitidos por la licencia, pero no existía ningún fork comunitario con tracción significativa al escribir esto; los más grandes tienen un puñado de estrellas. No apostaría un despliegue a que aparezca un fork. Tampoco hay presencia oficial en Discord, así que el soporte comunitario es lo que indexen los buscadores. La razón declarada del equipo para el sunset es un giro hacia los agentes de codificación y lejos de constructores de flujos low-code rígidos. Es contexto útil para la [sección de alternativas](#alternativas-a-flowise-n8n-langflow-y-agentes-de-codificación) al final. Una cosa más antes de decidir: las releases 3.1.2 a 3.1.4 fueron casi enteramente correcciones de seguridad (una fuga de datos de credenciales, un IDOR en `PUT /api/v1/user`, filtrado entre workspaces, una allowlist de stdio MCP, una corrección de clickjacking). Si corres algo más viejo que 3.1.4, actualiza a 3.1.4 primero y luego congela. Correr algo más viejo es correr código con vulnerabilidades conocidas. Ahora la decisión: ¿cuál de estas eres tú? **Quédatelo, pero bloquéalo.** Fija `flowiseai/flowise:3.1.4` (no te quedes en `:latest` ni nada más viejo), migra el volumen y la auth como cubre [Actualizar una instalación Flowise existente](#actualizar-una-instalación-flowise-existente-migración-de-volumen-y-auth), y reduce la exposición (Cloudflare Access delante del tunnel, o solo LAN/tailnet). Luego planea una salida en tu propio calendario en vez de durante un incidente. La [sección de endurecimiento](#endurecer-una-instancia-flowise-congelada) cubre el resto. **Considera seriamente algo mantenido primero.** Mi elección por defecto para amplitud de automatización de flujos es n8n. Puedes [self-hostear n8n en 2026 con Docker](/n8n-self-host-workflow-automation/). Si quieres específicamente el modelo low-code de chatflows, Langflow es el equivalente mantenido más cercano. Empezar un proyecto nuevo sobre software congelado significa que posees cada problema de seguridad futuro tú solo. Si aún quieres Flowise, la guía de instalación de abajo es correcta, solo entra sabiendo eso. **No empieces aquí.** No hay upstream contra el que evaluar, ni hoja de ruta, ni proceso de respuesta de seguridad. Navega los [top AI GitHub repos](/top-ai-github-repos/) para herramientas mantenidas activamente en su lugar. Vuelve a esta página solo cuando necesites operar una instancia existente. Software EOL en un hostname público es un riesgo real. La [sección de endurecimiento](#endurecer-una-instancia-flowise-congelada) de abajo cubre cómo reducirlo. ## Cómo instalar FlowiseAI con Docker y Docker Compose Si has decidido continuar (instalación existente, o aceptas la congelación), aquí está el montaje 3.1.4 actual y correcto: Docker Compose con un sidecar Postgres, secretos de sesión generados, un arranque bloqueado por healthcheck, y SSL a través de Cloudflare Tunnels. El vídeo de arriba se grabó en marzo de 2024 contra Flowise 1.x. Las bases de arrastrar y soltar siguen aplicando, pero la interfaz y el flujo de login han cambiado desde entonces (y el modelo de auth actual es distinto; mira el paso 6). El archivo Compose y los secretos de este artículo están actuales para 3.1.4. > En caso de que te interese monitorizar recursos del servidor como CPU, memoria, espacio en disco puedes mirar: [How To Monitor Server and Docker Resources](/sever-monitoring/) ### 1. Prerequisitos Antes de empezar, asegúrate de tener lo siguiente en su sitio: Versiones que fijaremos en esta guía: `flowiseai/flowise:3.1.4` (la release final) y `postgres:17-alpine` para instalaciones nuevas. Postgres 18 también funciona. Si ya tienes un volumen de base de datos, mantén el major que corre (mira la sección de actualización). _Los precios de VPS saltaron en bloque en 2026. Si estás replanteándote una máquina alquilada, mira [qué cambió y cuándo gana un mini PC](/vps-price-increases/)._ > También puedes usar Traefik como reverse proxy para tus apps. He creado un tutorial completo con instalación de Dockge también para gestionar tus contenedores: [How to Use Traefik as A Reverse Proxy in Docker](/traefik-proxy-docker/) ### 2. Crea el archivo Docker Compose (fijado a 3.1.4) Este es el stack que despliegas: Flowise en 3.1.4, Postgres detrás de una puerta de healthcheck, un sidecar de backup opcional, y un Cloudflare Tunnel delante. Arquitectura Docker Compose de FlowiseAI: Cloudflare Tunnel enruta HTTPS al contenedor flowise en el puerto 5023 con el volumen /home/node/.flowise, que depende del contenedor postgres 17-alpine flowise-db pasando su healthcheck pg_isready, con un sidecar tiredofit/db-backup opcional volcando a ./backups y un recordatorio de respaldar tanto la base de datos como la clave de cifrado .flowise Con el proyecto archivado, fijar es higiene de operador obligatoria. No llegan más correcciones, y un tag flotante no te protege de nada mientras te expone a re-apuntado o retirada de tags. Usa `flowiseai/flowise:3.1.4` y déjalo ahí. Crea un `docker-compose.yml` con el siguiente contenido: ```yaml services: flowise-db: image: postgres:17-alpine hostname: flowise-db environment: POSTGRES_DB: ${POSTGRES_DB} POSTGRES_USER: ${POSTGRES_USER} POSTGRES_PASSWORD: ${POSTGRES_PASSWORD} volumes: - ./flowise-db-data:/var/lib/postgresql/data restart: unless-stopped healthcheck: test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER} -d ${POSTGRES_DB}"] interval: 5s timeout: 5s retries: 5 flowise: image: flowiseai/flowise:3.1.4 # FINAL release: project archived Aug 2026, pin it container_name: flowiseai hostname: flowise healthcheck: test: ["CMD", "curl", "-f", "http://localhost:${PORT}/api/v1/ping"] interval: 10s timeout: 5s retries: 5 start_period: 30s ports: - 5023:${PORT} volumes: - ./flowiseai:/home/node/.flowise # non-root node user (uid 1000) since v3.0.11 environment: PORT: ${PORT} APP_URL: ${APP_URL} LOG_LEVEL: info LOG_PATH: /home/node/.flowise/logs DATABASE_TYPE: postgres DATABASE_PORT: 5432 DATABASE_HOST: flowise-db DATABASE_NAME: ${POSTGRES_DB} DATABASE_USER: ${POSTGRES_USER} DATABASE_PASSWORD: ${POSTGRES_PASSWORD} # session/cookie secrets: openssl rand -hex 32 JWT_AUTH_TOKEN_SECRET: ${JWT_AUTH_TOKEN_SECRET} JWT_REFRESH_TOKEN_SECRET: ${JWT_REFRESH_TOKEN_SECRET} EXPRESS_SESSION_SECRET: ${EXPRESS_SESSION_SECRET} TOKEN_HASH_SECRET: ${TOKEN_HASH_SECRET} SECURE_COOKIES: "true" # behind HTTPS (Cloudflare Tunnel) NUMBER_OF_PROXIES: 1 # ONLY if you must reach internal/localhost services (SSRF trade-off): # HTTP_SECURITY_CHECK: "false" # keep old basic auth ONLY to claim an upgraded legacy instance: # FLOWISE_USERNAME: ${FLOWISE_USERNAME} # FLOWISE_PASSWORD: ${FLOWISE_PASSWORD} restart: on-failure:5 depends_on: flowise-db: condition: service_healthy entrypoint: /bin/sh -c "sleep 3; flowise start" ``` Dos servicios hacen el trabajo: 1. `flowise-db`: PostgreSQL, con un healthcheck `pg_isready`. Flowise no arrancará hasta que pase, gracias a `depends_on: condition: service_healthy`. 2. `flowise`: la imagen Flowise fijada. El puerto del host es `5023` mapeado a `${PORT}` (default 3000) dentro del contenedor. El healthcheck usa `curl` contra `/api/v1/ping` (la imagen actual trae `curl`; montajes más viejos usaban `wget`). Nota la ruta del volumen: `./flowiseai:/home/node/.flowise`. Desde v3.0.11 el contenedor corre como usuario `node` sin root (uid 1000) y el directorio de datos se movió de `/root/.flowise` a `/home/node/.flowise`. Si montas en la ruta vieja, o el directorio del host es propiedad de root, el contenedor hará crashloop con errores de permisos. Si eso te acaba de morder, salta a [Troubleshooting](#troubleshooting-de-flowiseai-en-docker). El directorio `./flowiseai` contiene logs, pero también la clave de cifrado que Flowise usa para cifrar credenciales y claves API almacenadas (`SECRETKEY_PATH`). Eso importa para los backups en un segundo. Verificaremos todo esto tras `docker compose up -d` en el paso 4. No te pares en el YAML. Opcional: backups de base de datos. Si quieres volcados SQL programados, añade un tercer servicio: ```yaml flowise-db-backup: container_name: flowise-db-backup image: tiredofit/db-backup volumes: - ./backups:/backup environment: DB_TYPE: postgres DB_HOST: flowise-db DB_NAME: ${POSTGRES_DB} DB_USER: ${POSTGRES_USER} DB_PASS: ${POSTGRES_PASSWORD} DB_BACKUP_INTERVAL: 720 DB_CLEANUP_TIME: 72000 CHECKSUM: SHA1 COMPRESSION: GZ CONTAINER_ENABLE_MONITORING: false depends_on: flowise-db: condition: service_healthy restart: unless-stopped ``` `tiredofit/db-backup` sigue mantenido (último push septiembre de 2026) y este patrón sigue funcionando. Los volcados aterrizan en `./backups`, gzipados, cada 720 minutos. La base de datos guarda credenciales y claves API **cifradas**. La clave de cifrado vive en el volumen `.flowise` (`SECRETKEY_PATH`), no en Postgres. Haz backup de ambas rutas y restáuralas juntas, o te recibirá una base de datos restaurada llena de blobs indescifrables. Para un destino fuera de la máquina, empareja los volcados con [backups self-hosted con Restic y Rclone](/pluton-self-hosted-backup/). Si planeas correr varias apps IA en el mismo VPS y quieres compartir un contenedor Postgres en vez de apilar sidecars, mira cómo [correr múltiples bases de datos PostgreSQL en un servicio Docker](/es/multiples-bases-datos-postgres-docker/). ### 3. Crea el archivo .env con secretos Junto al archivo Compose, crea un `.env`: ```sh PORT=3000 APP_URL=https://flowise.example.com POSTGRES_USER=flowise POSTGRES_PASSWORD=a4f2c8e1b9d07a3c5e8f1a2b4c6d8e0f POSTGRES_DB=flowise JWT_AUTH_TOKEN_SECRET=7d3a9c1e5b8f0a2c4e6d8b0a2c4e6f8a1b3c5d7e9f0a2b4c6d8e8f0a1b3c5d7 JWT_REFRESH_TOKEN_SECRET=b2e4f6a8c0d2e4f6a8b0c2d4e6f8a0b2c4d6e8f0a2b4c6d8e8f0a1b3c5d7e9f0 EXPRESS_SESSION_SECRET=c3f5a7b9d1e3f5a7b9d1e3f5a7b9d1e3f5a7b9d1e3f5a7b9d1e3f5a7b9d1e3f5 TOKEN_HASH_SECRET=d4a6b8c0e2f4a6b8c0e2f4a6b8c0e2f4a6b8c0e2f4a6b8c0e2f4a6b8c0e2f4a6 ``` Genera cada secreto tú mismo y pega la **salida literal**: ```sh openssl rand -hex 32 ``` Córrelo una vez por secreto (y `openssl rand -hex 16` basta para `POSTGRES_PASSWORD`). Los valores mostrados arriba son falsos; genera unos frescos y nunca reutilices secretos de ejemplo de un post de blog. `POSTGRES_PASSWORD=$(openssl rand -hex 16)` **no** funciona como esperas. Docker Compose lee `.env` como pares key=value literales; no hay expansión de shell. Genera los valores en tu shell primero, luego pega los strings literales. Por qué importan los cuatro secretos: los docs de Flowise advierten que los secretos de sesión y JWT por defecto son falsificables. Si los dejas sin poner, las sesiones son más débiles de lo que parecen, y los logins se rompen entre reinicios de contenedor porque los tokens no son estables. Poner secretos fijos es un seguro barato. Ya que estás aquí, pon `APP_URL` a la URL pública exacta que servirás. Un desajuste entre `APP_URL` y lo que escriben los usuarios es un bug clásico de "el login funciona en localhost pero no en el dominio". `SECURE_COOKIES: "true"` en el archivo Compose es correcto detrás de un Cloudflare Tunnel HTTPS. Si estás probando sobre HTTP plano y la auth de repente se niega a funcionar, ese es el interruptor. No lo apagues en producción. Dos notas más sobre este archivo: - `FLOWISE_USERNAME` y `FLOWISE_PASSWORD` están **deprecated** (desde v3.0.1). Las instalaciones nuevas no los usan: la primera visita a la UI web muestra un formulario de registro de admin y la cuenta vive en Postgres. Mantén las variables viejas solo si reclamas una instancia heredada migrada (cubierto en la sección de actualización). - No toques `HTTP_SECURITY_CHECK` todavía. Desde 3.1.0 bloquea llamadas a `localhost` y direcciones internas por defecto (mitigación SSRF). Si el paso 4 o 6 falla al alcanzar un servicio interno, ese es el ajuste implicado. Detalles en [Troubleshooting](#troubleshooting-de-flowiseai-en-docker). ### 4. Despliega y verifica FlowiseAI Con el archivo Compose y el `.env` en su sitio: ```sh docker compose up -d ``` El primer pull son unos 1,5 GB comprimidos. En un disco VPS pequeño o una subida lenta, dale unos minutos antes de asumir que algo está roto. Luego verifica, en este orden: ```sh docker compose ps curl http://localhost:5023/api/v1/ping docker compose logs flowise --tail 50 docker compose exec flowise-db psql -U flowise -d flowise -c '\dt' ``` Lo que quieres ver: `docker ps` también funciona si quieres el one-liner amigable con Dockge. Buscas los mismos dos contenedores arriba, con el de Flowise healthy. Si algún paso falla, salta a [Troubleshooting](#troubleshooting-de-flowiseai-en-docker). Los modos de fallo de abajo mapean uno a uno con estas comprobaciones. ### 5. Configura Cloudflare Tunnels para SSL Para alcanzar FlowiseAI de forma segura sin abrir puertos en el servidor, usa Cloudflare Tunnels. Ve a **Access → Tunnels**, elige el tunnel que ya creaste para este host, y añade un hostname que mapee tu dominio o subdominio al servicio y puerto. Apunta el servicio a `http://flowise:3000` (el nombre dentro de la red y el puerto del contenedor) o a `http://localhost:5023` si enrutas a través del puerto publicado del host. Verifica que funciona de extremo a extremo: ```sh curl -I https://flowise.yourdomain.com ``` Quieres un `200` o `302`, y el certificado debería ser emitido por Cloudflare. Este salto HTTPS es lo que justifica `SECURE_COOKIES: "true"` en el archivo Compose. > También puedes mirar [Setup CloudPanel as Reverse Proxy with Docker and Dockge](/cloudpanel-setup-dockge/) para usar CloudPanel como reverse proxy para tus contenedores Docker o [How to Use Traefik as A Reverse Proxy in Docker](/traefik-proxy-docker/). ### 6. Crea la cuenta de admin y tu primer flujo Abre el dominio que configuraste. La primera visita muestra un **formulario de registro de admin** (email y contraseña). Esta cuenta se guarda en Postgres y las sesiones son cookies JWT; la vieja era de basic-auth `FLOWISE_USERNAME` / `FLOWISE_PASSWORD` terminó con v3.0.1. Elige una contraseña fuerte aquí, porque esta cuenta controla cada credencial almacenada en la instancia. El editor 3.1.x se divide en constructores **Assistant / Chatflow / Agentflow** y se ve distinto a las imágenes de este artículo. El modelo de arrastrar y soltar es el mismo; solo se movió el chrome. Una vez dentro, crea tu primer flujo: añade nodos desde la barra lateral, conéctalos, y configura cada uno. Empieza con un chatflow simple. Un nodo LLM más un nodo de memoria basta para probar el cableado. *Captura de una UI de Flowise más vieja. El editor 3.1.x difiere.* También hay un marketplace de plantillas que puedes clonar como punto de partida en vez de construir desde un lienzo vacío. ### 7. Usa el chatflow de FlowiseAI externamente Cuando el flujo hace lo que quieres, Flowise te da varias formas de usarlo fuera del editor: un snippet de embed para sitios web, snippets de Python y JavaScript, un ejemplo cURL, o un enlace de compartir plano. Un hábito de seguridad mientras estás aquí: limpia el JSON de flujo exportado antes de pegarlo en un gist, un ticket o un repo. Las exportaciones pueden llevar valores de variables y configuración que no querrías pública. Trata el JSON exportado como un archivo de config, no como un diagrama. ## Actualizar una instalación Flowise existente (migración de volumen y auth) Si tu stack se parece a la versión 2024 de este artículo (imagen en `:latest`, volumen en `/root/.flowise`, basic auth en el entorno), aquí está la migración ordenada al montaje 3.1.4. Haz estos pasos en orden; cada uno previene un fallo específico. 1. **Vuelca la base de datos primero.** Si los datos importan, haz un `pg_dump` antes de tocar nada. El servicio de backup del paso 2 solo ayuda si ya estaba corriendo. Si no, hazlo a mano: `docker compose exec flowise-db pg_dump -U flowise flowise > flowise-backup.sql`. 2. **Para el stack:** `docker compose down`. 3. **Arregla la propiedad del volumen.** Los viejos bind mounts `/root/.flowise` son propiedad de root; la imagen 3.0.11+ corre como uid 1000 y hará EACCES/crashloop si no: ```sh chown -R 1000:1000 ./flowiseai ``` 4. **Actualiza el mount y la imagen.** Cambia el volumen a `./flowiseai:/home/node/.flowise` y fija `flowiseai/flowise:3.1.4`. La ruta de actualización va **a** 3.1.4, no más allá; es la última release. 5. **Reclama la instancia (una vez).** Según los [docs oficiales de auth](https://docs.flowiseai.com/configuration/authorization/app-level), mantén `FLOWISE_USERNAME` y `FLOWISE_PASSWORD` en el entorno para una ejecución: en la primera visita, entra con esas viejas credenciales basic-auth para reclamar la propiedad, luego crea la nueva cuenta de admin. Después, elimina las variables viejas. (Este flujo está documentado upstream; pruébalo en una copia de prueba primero si tu instancia es una de la que no puedes permitirte quedar fuera.) 6. **Pon los cuatro secretos JWT/sesión y `APP_URL`** del paso 3 de la instalación para que las sesiones sobrevivan reinicios. 7. **No subas el major de Postgres.** Si tu volumen fue creado por `postgres:16-alpine`, quédate en 16. Las imágenes Postgres se niegan a arrancar entre majors contra un directorio de datos existente sin `pg_upgrade` o un volcado-restauración. Cambiar `postgres:16-alpine` a `postgres:17-alpine` sobre el mismo directorio `./flowise-db-data` fallará al arrancar: el formato del directorio de datos no es compatible entre majors. Quédate en tu major actual, o vuelca-restaura a un volumen 17 fresco. Luego levántalo y corre el mismo bloque de verificación del paso 4. Los dos modos de fallo que previene esta sección son crashloops de EACCES y logins rotos. Ambos tienen arreglos expandidos en la siguiente sección. Rollback: `docker compose down` es reversible mientras no hayas borrado `./flowiseai` o `./flowise-db-data`. Si el stack actualizado se porta mal y tienes el archivo compose viejo, restaurar el archivo viejo y el tag de imagen viejo recupera el comportamiento anterior, excepto que igualmente quieres estar en 3.1.4 por las correcciones de seguridad. ## Troubleshooting de FlowiseAI en Docker El volumen es propiedad de root de la era pre-3.0.11 `/root/.flowise`, o montaste en la ruta vieja. El contenedor corre como usuario `node` (uid 1000) y no puede escribir directorios propiedad de root. Para el stack y arregla la propiedad en el directorio del host, luego asegúrate de que el destino del mount es `/home/node/.flowise`: ```sh docker compose down chown -R 1000:1000 ./flowiseai docker compose up -d docker compose logs flowise --tail 50 ``` Roto se ve como `EACCES: permission denied` en los logs o el contenedor atascado en `Restarting`. Desde 3.1.0, la validación de seguridad HTTP está activada por defecto con una deny list que bloquea `localhost`, `127.0.0.1` y direcciones internas. Es mitigación SSRF, y también bloqueará una llamada legítima a un servidor de modelos local. Si quieres [montar Ollama con Open WebUI usando Docker Compose](/es/ollama-docker-instalacion/) en el mismo host y apuntar Flowise a él, este es el ajuste que estorba. Tienes dos opciones: poner `HTTP_SECURITY_CHECK: "false"` en el entorno, o extender `HTTP_DENY_LIST` deliberadamente. Entiende el trade-off: apagar el check re-habilita rutas de server-side request forgery a través de tus flujos. En una máquina mono-tenant detrás de Cloudflare Access el riesgo es manejable; en algo compartido, prefiere una allowlist estrecha a desactivar el check. Los secretos JWT/sesión se dejaron sin poner (o estás en defaults), así que los tokens no son estables entre reinicios. Comprueba también que `EXPIRE_AUTH_TOKENS_ON_RESTART` no está en `true`. Pon `JWT_AUTH_TOKEN_SECRET`, `JWT_REFRESH_TOKEN_SECRET`, `EXPRESS_SESSION_SECRET` y `TOKEN_HASH_SECRET` en `.env` (paso 3), recrea el contenedor (`docker compose up -d`), y entra una vez más. `APP_URL` no coincide con la URL pública, o `SECURE_COOKIES: "true"` está puesto mientras sirves HTTP plano (el navegador suelta la cookie). Pon `APP_URL` a la URL exacta que escriben los usuarios (esquema incluido), y mantén `SECURE_COOKIES` activado solo detrás de HTTPS, que es lo que tienes si seguiste el paso del Cloudflare Tunnel. Flowise no puede ver la IP real del cliente y cuenta cada petición como viniendo de la dirección del proxy. Pon `NUMBER_OF_PROXIES: 1` (ya está en el archivo Compose de arriba) cuando corras detrás de exactamente una capa de proxy como Cloudflare Tunnel. El backup cubrió solo Postgres. Las credenciales están cifradas con una clave guardada en el volumen `.flowise` (`SECRETKEY_PATH`); una BD restaurada sin esa clave no puede descifrar nada. Restaura el directorio `.flowise` junto al volcado de la base de datos, del mismo punto en el tiempo. Si la clave se fue, las credenciales se fueron; tendrás que re-introducir las claves API en cada flujo. Por eso la regla "haz backup de ambas rutas" del paso 2 no es opcional. ## Endurecer una instancia Flowise congelada No llegan parches, así que la reducción de exposición es todo el juego. El VPS en sí es la parte barata (2 vCPU / 4 GB lo cubre); el coste continuo de correr software en fin de vida es tu tiempo en backups y revisión de exposición.
  • **Llega a 3.1.4 primero, luego congela.** De 3.1.2 a 3.1.4 fueron releases de seguridad (fuga de credenciales, IDOR en `PUT /api/v1/user`, filtrado entre workspaces, allowlist stdio MCP, clickjacking). Cualquier cosa más vieja corre código con vulnerabilidades conocidas.
  • **Pon Cloudflare Access (Zero Trust) delante del tunnel.** La UI del editor no debería estar abierta a internet en una aplicación que nunca será parcheada otra vez. Un check de identidad por email delante es el control de más valor de esta lista.
  • **Usa el firewall del host, o no publiques en absoluto.** Allowlist UFW solo para SSH y el tunnel. Si de verdad no necesitas acceso público, mantenlo solo LAN o tailnet. Mira [cómo aseguré mi servidor Docker](/bsi-security-report-docker-ufw/) para la parte de firewall y exposición.
  • **Menor privilegio dentro de Flowise:** desactiva nodos que no uses (`DISABLED_NODES`), mantén `ALLOW_BUILTIN_DEP=false`, y si usas herramientas MCP stdio mantén `CUSTOM_MCP_ALLOWED_COMMANDS` en una allowlist estrecha.
  • **Trata los backups como tu seguro real.** Volcados de base de datos más el volumen `.flowise`, restaurados juntos, probados al menos una vez. Un backup no probado es una esperanza, no un plan.
  • **Vigila la lista de forks de vez en cuando.** Ninguno con tracción existía a octubre de 2026. Si emerge un fork serio antes de que Docker Hub empiece a retirar tags deprecated, se convierte en tu ruta de actualización. Comprueba periódicamente en vez de asumir que aparecerá uno.
 Si quieres una capa barata más, el filtrado a nivel DNS (uso [NextDNS](https://go.bitdoze.com/nextdns)) puede bloquear callbacks a dominios conocidos-malos incluso si algo del stack se explota, pero Cloudflare Access y el firewall son los controles que importan aquí. ## Alternativas a Flowise: n8n, Langflow y agentes de codificación Si aún no estás comprometido, consideraría estas tres direcciones. **n8n** es mi default para automatización de flujos. Está activamente mantenido (200k+ estrellas y un repo ocupado), cubre flujos de triggers/agentes/automatización ampliamente, y tiene una historia de self-hosting real. Si lo que te gustaba de Flowise era cablear pasos IA en automatizaciones de negocio, aquí es adonde ir. El montaje completo está en [self-hostear n8n en 2026 con Docker](/n8n-self-host-workflow-automation/). **Langflow** es el reemplazo 1:1 más cercano para el modelo low-code de chatflows. Misma idea de constructor visual, activamente mantenido (150k+ estrellas), y juega bien con Postgres, así que la arquitectura de este artículo se transfiere. Puedes [instalar Langflow con Docker Compose](/es/instalar-langflow-docker/) en la misma forma que esta guía. **Agentes de codificación** son la dirección hacia la que el equipo de Flowise dijo que se movían, y el espacio también se ha movido ahí. Si el techo del arrastrar y soltar es lo que te trajo a este artículo, considera saltarte la capa del constructor: [construye tu propio agente IA con Mastra](/build-ai-agent-mastra/) y mantén la lógica en código donde puedas versionarla, probarla y revisarla. En el lado CLI, agentes de codificación open-source como [OpenCode Go](https://go.bitdoze.com/opencode-go) corren modelos de codificación de bajo coste si quieres explorar ese camino barato.