Cómo Instalar FlowiseAI con Docker Compose (2026)

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

Estado de Flowise: fin de vida (lee esto primero)

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 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 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ú?

Software EOL en un hostname público es un riesgo real. La sección de endurecimiento 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.

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

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.

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

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.

Crea un docker-compose.yml con el siguiente contenido:

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.

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:

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.

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.

3. Crea el archivo .env con secretos

Junto al archivo Compose, crea un .env:

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:

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.

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.

4. Despliega y verifica FlowiseAI

Con el archivo Compose y el .env en su sitio:

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:

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

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 para usar CloudPanel como reverse proxy para tus contenedores Docker o How to Use Traefik as A Reverse Proxy in 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.

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:

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

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

docker compose down
chown -R 1000:1000 ./flowiseai
docker compose up -d
docker compose logs flowise --tail 50

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.

Si quieres una capa barata más, el filtrado a nivel DNS (uso 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.

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 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 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 corren modelos de codificación de bajo coste si quieres explorar ese camino barato.

Comprobación de realidad de migración: no hay exportador oficial de Flowise a ninguno de los destinos. Los flujos se exportan como JSON, pero n8n y Langflow tienen cada uno su propio DSL. Nada traduce automáticamente. Exporta un flujo representativo, reconstrúyelo a mano en el destino, y pruébalo antes de comprometerte con una ruta de migración. Presupuesta para la reconstrucción; no presupuestes un conversor que no existe.

Los tres se self-hostean bien en la misma máquina de 2 vCPU / 4 GB a la que apunta esta guía.

Conclusión

La instalación de este artículo funciona, y para cualquiera que ya corra Flowise es el montaje congelado correcto: flowiseai/flowise:3.1.4, Postgres detrás de un healthcheck, secretos de sesión reales, y SSL a través de un Cloudflare Tunnel. Con el upstream desaparecido, la disciplina operativa mantiene esto seguro: fija la imagen, verifica el despliegue, haz backup de ambos, la base de datos y el volumen .flowise, y recorta la exposición de la app (Cloudflare Access, firewall, o solo LAN). No corras nada más viejo que 3.1.4.

Si aún no estás comprometido con Flowise, no empieces. Instala algo mantenido en su lugar (n8n o Langflow) y mantén esta página marcada para el día en que necesites operar una instancia heredada.

Para más contenedores self-hosted, mira los mejores 100+ contenedores Docker para home server. Para el mapa más amplio de herramientas IA, mira top AI GitHub repos.