Implantar Flowise em VPS: Docker, fluxos de IA visuais, Ollama e HTTPS

Já vi muita gente que começa querendo fazer fluxos de trabalho de IA e acaba com cada vez mais ferramentas instaladas.

Perguntas e respostas simples vão para o Open WebUI, perguntas e respostas sobre documentos vão para o AnythingLLM, aplicações complexas vão para o Dify, automação vai para o n8n. Cada ferramenta resolve uma parte do problema, mas se o que você realmente quer fazer é:

Encadear LLM, prompts, banco de vetores, recuperação, chamadas de ferramentas e nós de API em uma única cadeia visual.

Então o Flowise merece uma análise separada.

Ele é mais como um editor visual do LangChain. Você não começa escrevendo um monte de código Python/TypeScript; em vez disso, arrasta nós no navegador: Chat Model, Prompt Template, Retriever, Vector Store, Tool, Chain, e depois conecta e testa.

Este artigo aborda a auto-hospedagem em VPS: quais especificações conseguem rodar, como implantar com Docker, como adicionar HTTPS e autenticação de login, como fazer backup dos dados, quando escolher o Flowise e quando não forçar a barra.

Primeiro a conclusão: para quem o Flowise serve

O Flowise não é "mais uma casca web do ChatGPT". Ele serve para orquestrar cadeias de IA.

Necessidade	O Flowise serve	Ferramenta mais adequada
Montar fluxos de trabalho LLM com arrastar e soltar	Serve	Flowise
Aprender fluxos de LangChain / RAG	Serve	Flowise
Criar rapidamente um protótipo de API de IA	Serve	Flowise
Criar um backend completo de aplicação de IA	Mais ou menos	Dify
Automação multiplataforma	Mais ou menos	n8n
Apenas conversar	Não muito	Open WebUI
Apenas perguntas e respostas sobre base de conhecimento documental	Não necessariamente	AnythingLLM

Eu entendo assim:

Dify é mais uma plataforma de aplicações de IA
n8n é mais uma plataforma de fluxos de trabalho de automação
Flowise é mais uma ferramenta para montar cadeias de LLM

Se você quer entender "como um Q&A com RAG realmente encadeia documentos, banco de vetores, prompt e modelo", os nós visuais do Flowise tornam isso muito intuitivo.

Como escolher as especificações da VPS

O Flowise em si não é pesado. O que realmente consome recursos são o banco de dados, o banco de vetores, os modelos locais e as requisições concorrentes que você conecta.

Se você só rodar o Flowise + APIs de modelos na nuvem:

Uso	Especificações da VPS
Teste pessoal	1 núcleo / 2GB / 20GB SSD
Uso pessoal de longo prazo	2 núcleos / 4GB / 40GB SSD
Uso compartilhado de equipe pequena	4 núcleos / 8GB / 80GB SSD

Se você também quiser rodar Qdrant, PostgreSQL, Redis e Ollama na mesma máquina, não compre a configuração mínima.

Minha recomendação:

Só conectar OpenAI / Claude / DeepSeek / OpenRouter: 2C4G é suficiente
Flowise + Qdrant + PostgreSQL: 4C8G é mais estável
Flowise + modelos locais Ollama: 16GB de RAM é um ponto de partida mais realista

Não rode um monte de ferramentas de IA em uma máquina pequena de 1C1G. Conseguir abrir o painel é uma coisa; rodar fluxos de trabalho de verdade é outra.

Preparação antes da implantação

Este artigo usa uma VPS com Ubuntu / Debian como exemplo.

Primeiro faça login via SSH:

ssh root@your_server_ip

Atualize o sistema:

apt update && apt upgrade -y

Instale as ferramentas básicas:

apt install -y ca-certificates curl gnupg ufw

Verifique os recursos:

free -h
df -h

O Flowise roda por padrão na porta 3000. Primeiro verifique se ela está ocupada:

ss -tlnp | grep 3000

Se esta máquina já tem Perplexica, Grafana ou algum projeto frontend ocupando a 3000, você precisará trocar a porta ou usar um proxy reverso para distinguir por domínio.

Instalar o Docker

Se a máquina ainda não tem o Docker instalado, siga os passos abaixo.

install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | gpg --dearmor -o /etc/apt/keyrings/docker.gpg
chmod a+r /etc/apt/keyrings/docker.gpg
echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu $(. /etc/os-release && echo $VERSION_CODENAME) stable" > /etc/apt/sources.list.d/docker.list
apt update
apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

Confirme a instalação:

docker --version
docker compose version

A implantação mais simples com Docker Run

Se você só quer colocar no ar para testar primeiro, pode usar o Docker Run.

docker run -d \
  --name flowise \
  --restart unless-stopped \
  -p 127.0.0.1:3000:3000 \
  -v /opt/flowise:/root/.flowise \
  -e PORT=3000 \
  -e FLOWISE_USERNAME=admin \
  -e FLOWISE_PASSWORD='replace-with-a-strong-password' \
  flowiseai/flowise:latest

Duas coisas a observar:

Eu vinculo a porta a 127.0.0.1 para não expor diretamente à internet
/opt/flowise é montado em /root/.flowise para evitar perda de dados quando o contêiner for recriado

Ver o contêiner:

docker ps --filter "name=flowise"

Ver os logs:

docker logs flowise --tail=100

Testar localmente:

curl -I http://127.0.0.1:3000

Se funcionar localmente, depois use o Caddy para HTTPS.

Implantar com Docker Compose

Para uso de longo prazo, eu recomendo mais o Compose. O diretório fica claro e as atualizações e backups são mais fáceis.

Criar o diretório:

mkdir -p /opt/flowise
cd /opt/flowise

Criar .env:

cat > .env << 'EOF'
PORT=3000
FLOWISE_USERNAME=admin
FLOWISE_PASSWORD=replace-with-a-strong-password
DATABASE_PATH=/root/.flowise
SECRETKEY_PATH=/root/.flowise
LOG_PATH=/root/.flowise/logs
BLOB_STORAGE_PATH=/root/.flowise/storage
DISABLE_FLOWISE_TELEMETRY=true
EOF

Certifique-se de alterar a senha aqui; não use o valor de exemplo.

Criar docker-compose.yml:

services:
  flowise:
    image: flowiseai/flowise:latest
    container_name: flowise
    restart: unless-stopped
    ports:
      - "127.0.0.1:3000:3000"
    environment:
      - PORT=${PORT}
      - FLOWISE_USERNAME=${FLOWISE_USERNAME}
      - FLOWISE_PASSWORD=${FLOWISE_PASSWORD}
      - DATABASE_PATH=${DATABASE_PATH}
      - SECRETKEY_PATH=${SECRETKEY_PATH}
      - LOG_PATH=${LOG_PATH}
      - BLOB_STORAGE_PATH=${BLOB_STORAGE_PATH}
      - DISABLE_FLOWISE_TELEMETRY=${DISABLE_FLOWISE_TELEMETRY}
    volumes:
      - /opt/flowise/data:/root/.flowise
    entrypoint: /bin/sh -c "sleep 3; flowise start"

Iniciar:

docker compose up -d

Verificar:

docker compose ps
docker logs flowise --tail=100

Essa configuração já é suficiente para testes pessoais e de equipes pequenas.

Configurar HTTPS com Caddy

Suponha que seu domínio seja:

flowise.example.com

Adicione um registro A no DNS:

flowise.example.com -> your_server_ip

Instale o Caddy:

apt install -y debian-keyring debian-archive-keyring apt-transport-https curl
curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/gpg.key' | gpg --dearmor -o /usr/share/keyrings/caddy-stable-archive-keyring.gpg
curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/debian.deb.txt' > /etc/apt/sources.list.d/caddy-stable.list
apt update
apt install -y caddy

Edite a configuração:

nano /etc/caddy/Caddyfile

Escreva:

flowise.example.com {
    reverse_proxy 127.0.0.1:3000
}

Verifique e recarregue:

caddy validate --config /etc/caddy/Caddyfile
systemctl reload caddy

Agora acesse:

https://flowise.example.com

Você verá a página de login do Flowise.

Como configurar o firewall

Se usar o Caddy como proxy reverso, abra apenas SSH, 80 e 443.

ufw allow 22/tcp
ufw allow 80/tcp
ufw allow 443/tcp
ufw enable
ufw status

Não abra a 3000:

ufw deny 3000/tcp

A configuração do Compose acima já vincula a 3000 a 127.0.0.1; este passo adiciona mais uma camada de proteção.

Se o painel do Flowise ficar exposto sem proteção à internet, o risco é alto.

Porque ele pode conter:

Chaves de API da OpenAI / DeepSeek
Informações de conexão do banco de vetores
Informações de conexão do banco de dados
Interfaces de chamada de ferramentas internas
Os endpoints de API dos fluxos de trabalho que você criou

No mínimo, configure:

FLOWISE_USERNAME=admin
FLOWISE_PASSWORD=replace-with-a-strong-password

Se você usar dentro de uma empresa, também pode adicionar Cloudflare Access, Tailscale ou VPN para permitir que apenas usuários específicos acessem o painel.

Como criar seu primeiro Flow

Depois da implantação, não comece com um Agent complexo.

Comece com a cadeia mínima:

Adicione um nó Chat Model
Escolha OpenAI / OpenRouter / DeepSeek / Ollama
Adicione um Prompt Template
Conecte a um LLM Chain
Abra o Chat para testar

Uma pergunta de teste mínima pode ser:

用三句话解释 VPS、Docker 和反向代理的关系。

Se isso não funcionar, não mexa ainda em RAG, Tool ou Agent.

Os problemas comuns geralmente são:

Chave de API preenchida errada
Nome do modelo errado
A VPS não consegue acessar a API do modelo
Nós conectados incorretamente
Não testar novamente após salvar

Conectar OpenAI / DeepSeek / OpenRouter

A vantagem do Flowise é que ele tem muitos nós de modelos, então você pode escolher conforme a sua situação.

Se usar OpenAI, normalmente é preciso preparar:

OPENAI_API_KEY=sk-xxxx

Se usar OpenRouter, você pode escolher a forma compatível com OpenAI; o importante é a Base URL e o nome do modelo.

Se usar DeepSeek, também pode conectar de forma compatível com OpenAI.

Aqui não coloque as chaves de API em documentos públicos, nem faça commit de .env em um repositório Git.

Eu recomendo preencher no gerenciamento de Credential do Flowise, em vez de codificar em cada nó. Assim é mais prático quando você trocar a chave depois.

Conectar modelos locais Ollama

Se você quiser que os modelos rodem na sua própria VPS, pode conectar o Ollama.

Instalar o Ollama:

curl -fsSL https://ollama.com/install.sh | sh

Baixar um modelo:

ollama pull qwen2.5:7b

Testar:

curl http://127.0.0.1:11434/api/tags

Se o Flowise estiver no Docker e precisar acessar o Ollama do host, não dá para simplesmente escrever localhost.

Adicione no Compose:

extra_hosts:
  - "host.docker.internal:host-gateway"

Depois, no nó Ollama do Flowise, preencha:

http://host.docker.internal:11434

Se você preencher http://localhost:11434, o contêiner do Flowise vai procurar a 11434 dentro do próprio contêiner, o que normalmente falha na conexão.

Vale a pena adicionar PostgreSQL

Por padrão, o Flowise pode salvar os dados como arquivos locais, o que é suficiente para testes pessoais.

Mas se você planeja uso multiusuário de longo prazo, ou quer backups mais organizados, pode considerar o PostgreSQL.

Uma regra simples:

Cenário	Escolha de banco de dados
Teste pessoal, poucos Flows	Arquivos locais padrão
Uso de longo prazo de equipe pequena	PostgreSQL é mais estável
Várias instâncias, alta concorrência	PostgreSQL + Redis + arquitetura mais completa

Não leve a arquitetura ao máximo desde o início. O Flowise já tem muitos nós e configurações; estabilizar o fluxo principal é mais importante do que empilhar serviços de banco de dados.

Como fazer backup de arquivos e dados

No mínimo, faça backup deste diretório:

/opt/flowise/data

Ele inclui seus Flows, Credentials, logs, arquivos de armazenamento e outros dados críticos.

Empacote localmente:

mkdir -p /opt/backups
tar -czf /opt/backups/flowise-data-$(date +%F).tar.gz /opt/flowise

Sincronize com o armazenamento de objetos:

rclone copy /opt/backups/flowise-data-$(date +%F).tar.gz r2:backup-bucket/flowise/

Se você usar PostgreSQL, faça também um backup adicional do banco de dados:

pg_dump "$DATABASE_URL" | gzip > /opt/backups/flowise-db-$(date +%F).sql.gz

Não faça backup apenas do arquivo Compose. O que realmente tem valor são os Flows e Credentials que você criou.

Como atualizar

Atualizar uma implantação com Compose é simples:

cd /opt/flowise
docker compose pull
docker compose up -d

Faça backup antes de atualizar:

tar -czf /opt/backups/flowise-before-upgrade-$(date +%F).tar.gz /opt/flowise

Verifique após atualizar:

docker compose ps
docker logs flowise --tail=100
curl -I http://127.0.0.1:3000

Depois rode de fato um Flow na interface web para confirmar que os nós, as Credentials e os endpoints de API estão funcionando.

Solução de problemas comuns

1. O domínio retorna 502

Primeiro veja o contêiner:

docker ps --filter "name=flowise"
docker logs flowise --tail=100

Depois veja a porta local:

curl -I http://127.0.0.1:3000

Se não funcionar localmente, corrija o contêiner do Flowise. Se funcionar localmente mas não pelo domínio, verifique o Caddy:

caddy validate --config /etc/caddy/Caddyfile
journalctl -u caddy -n 100 --no-pager

Confirme o usuário e a senha em .env:

cd /opt/flowise
grep FLOWISE_ .env

Reinicie após alterar:

docker compose up -d

Se o navegador tiver o estado antigo em cache, tente uma vez em uma janela anônima.

3. O nó falha ao chamar o modelo

Primeiro confirme a chave de API e o nome do modelo.

Se for OpenAI / OpenRouter:

curl -I https://api.openai.com

Se for Ollama:

curl http://127.0.0.1:11434/api/tags

Para acessar o Ollama do host de dentro do contêiner, use:

http://host.docker.internal:11434

4. O Flow se perde depois de salvar

Provavelmente o diretório persistente não foi montado.

Verifique se o Compose tem:

volumes:
  - /opt/flowise/data:/root/.flowise

Verifique o diretório do host:

ls -lah /opt/flowise/data

Se você rodou o contêiner antes sem montar, os dados podem já ter sido perdidos quando o contêiner foi removido.

5. Os fluxos de trabalho estão muito lentos

Primeiro veja os recursos da VPS:

htop
free -h
docker stats

Depois veja qual etapa está lenta:

A API do modelo está lenta
A recuperação no banco de vetores está lenta
Os trechos de documentos são grandes demais
O modelo local do Ollama é grande demais
As chamadas de ferramentas HTTP externas estão lentas

O Flowise estar lento não significa necessariamente que o próprio Flowise esteja lento; muitas vezes é um nó específico que está lento.

Como escolher entre Flowise, Dify e n8n

Essas três ferramentas costumam ser comparadas juntas.

Ferramenta	Mais adequada para
Flowise	Cadeias LLM visuais, LangChain, protótipos de RAG
Dify	Plataforma de aplicações de IA, publicação externa, base de conhecimento e fluxos de trabalho
n8n	Tarefas de automação, Webhooks, integração com sistemas de terceiros

Minha recomendação:

Quer aprender e depurar cadeias LLM: Flowise
Quer criar uma aplicação de IA completa para outras pessoas usarem: Dify
Quer integrar a IA aos processos de negócio: n8n

Por exemplo, se você quer fazer "o usuário envia um formulário -> consultar o CRM -> chamar o modelo para resumir -> enviar ao Slack", o n8n é mais adequado.

Se você quer fazer "recuperação de documentos -> Prompt -> resposta do modelo -> observar a saída de cada nó", o Flowise é mais intuitivo.

Se você quer fazer "um produto de IA com login, base de conhecimento, API e publicação de aplicações", o Dify é mais completo.

Como eu colocaria em prática

Se eu mesmo rodasse o Flowise em uma VPS, configuraria assim:

VPS: 2 núcleos e 4GB como ponto de partida
Implantação: Docker Compose
Porta: vincular apenas a 127.0.0.1:3000
HTTPS: proxy reverso Caddy
Login: configurar obrigatoriamente FLOWISE_USERNAME / FLOWISE_PASSWORD
Modelos: conectar primeiro OpenRouter / DeepSeek / OpenAI
Modelos locais: conectar o Ollama depois que o fluxo estiver estável
Backup: fazer backup diário de /opt/flowise
Uso de equipe de longo prazo: então considerar PostgreSQL

O valor do Flowise não está em "ter instalado uma ferramenta de IA", mas em dividir a cadeia LLM em nós que você pode ver e ajustar. Para quem aprende RAG, cria protótipos de IA e soluciona problemas de prompts e chamadas de ferramentas, ele é mais rápido do que escrever código diretamente e mais claro do que uma interface apenas de chat.

Mas ele não é um backend universal. Permissões, productização, gestão de usuários e publicação de aplicações complexas podem se encaixar melhor no Dify. Antes de escolher uma ferramenta, pense com clareza: você quer "montar cadeias" ou "criar um produto"?

Necessidade

O Flowise serve

Ferramenta mais adequada

Montar fluxos de trabalho LLM com arrastar e soltar

Serve

Flowise

Aprender fluxos de LangChain / RAG

Serve

Flowise

Criar rapidamente um protótipo de API de IA

Serve

Flowise

Criar um backend completo de aplicação de IA

Mais ou menos

Dify

Automação multiplataforma

Mais ou menos

n8n

Apenas conversar

Não muito

Open WebUI

Apenas perguntas e respostas sobre base de conhecimento documental

Não necessariamente

AnythingLLM

Uso

Especificações da VPS

Teste pessoal

1 núcleo / 2GB / 20GB SSD

Uso pessoal de longo prazo

2 núcleos / 4GB / 40GB SSD

Uso compartilhado de equipe pequena

4 núcleos / 8GB / 80GB SSD

install -m 0755 -d /etc/apt/keyrings curl -fsSL https://download.docker.com/linux/ubuntu/gpg | gpg --dearmor -o /etc/apt/keyrings/docker.gpg chmod a+r /etc/apt/keyrings/docker.gpg echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu $(. /etc/os-release && echo $VERSION_CODENAME) stable" > /etc/apt/sources.list.d/docker.list apt update apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

docker run -d \ --name flowise \ --restart unless-stopped \ -p 127.0.0.1:3000:3000 \ -v /opt/flowise:/root/.flowise \ -e PORT=3000 \ -e FLOWISE_USERNAME=admin \ -e FLOWISE_PASSWORD='replace-with-a-strong-password' \ flowiseai/flowise:latest

cat > .env << 'EOF' PORT=3000 FLOWISE_USERNAME=admin FLOWISE_PASSWORD=replace-with-a-strong-password DATABASE_PATH=/root/.flowise SECRETKEY_PATH=/root/.flowise LOG_PATH=/root/.flowise/logs BLOB_STORAGE_PATH=/root/.flowise/storage DISABLE_FLOWISE_TELEMETRY=true EOF

services: flowise: image: flowiseai/flowise:latest container_name: flowise restart: unless-stopped ports: - "127.0.0.1:3000:3000" environment: - PORT=${PORT} - FLOWISE_USERNAME=${FLOWISE_USERNAME} - FLOWISE_PASSWORD=${FLOWISE_PASSWORD} - DATABASE_PATH=${DATABASE_PATH} - SECRETKEY_PATH=${SECRETKEY_PATH} - LOG_PATH=${LOG_PATH} - BLOB_STORAGE_PATH=${BLOB_STORAGE_PATH} - DISABLE_FLOWISE_TELEMETRY=${DISABLE_FLOWISE_TELEMETRY} volumes: - /opt/flowise/data:/root/.flowise entrypoint: /bin/sh -c "sleep 3; flowise start"

apt install -y debian-keyring debian-archive-keyring apt-transport-https curl curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/gpg.key' | gpg --dearmor -o /usr/share/keyrings/caddy-stable-archive-keyring.gpg curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/debian.deb.txt' > /etc/apt/sources.list.d/caddy-stable.list apt update apt install -y caddy

Cenário

Escolha de banco de dados

Teste pessoal, poucos Flows

Arquivos locais padrão

Uso de longo prazo de equipe pequena

PostgreSQL é mais estável

Várias instâncias, alta concorrência

PostgreSQL + Redis + arquitetura mais completa

Ferramenta

Mais adequada para

Flowise

Cadeias LLM visuais, LangChain, protótipos de RAG

Dify

Plataforma de aplicações de IA, publicação externa, base de conhecimento e fluxos de trabalho

n8n

Tarefas de automação, Webhooks, integração com sistemas de terceiros

Primeiro a conclusão: para quem o Flowise serve

Como escolher as especificações da VPS

Preparação antes da implantação

Instalar o Docker

A implantação mais simples com Docker Run

Implantar com Docker Compose

Configurar HTTPS com Caddy

Como configurar o firewall

A autenticação de login deve estar ativada

Como criar seu primeiro Flow

Conectar OpenAI / DeepSeek / OpenRouter

Conectar modelos locais Ollama

Vale a pena adicionar PostgreSQL

Como fazer backup de arquivos e dados

Como atualizar

Solução de problemas comuns

1. O domínio retorna 502

2. Não consigo fazer login

3. O nó falha ao chamar o modelo

4. O Flow se perde depois de salvar

5. Os fluxos de trabalho estão muito lentos

Como escolher entre Flowise, Dify e n8n

Como eu colocaria em prática

Carregando…

Primeiro a conclusão: para quem o Flowise serve

Como escolher as especificações da VPS

Preparação antes da implantação

Instalar o Docker

A implantação mais simples com Docker Run

Implantar com Docker Compose

Configurar HTTPS com Caddy

Como configurar o firewall

A autenticação de login deve estar ativada

Como criar seu primeiro Flow

Conectar OpenAI / DeepSeek / OpenRouter

Conectar modelos locais Ollama

Vale a pena adicionar PostgreSQL

Como fazer backup de arquivos e dados

Como atualizar

Solução de problemas comuns

1. O domínio retorna 502

2. Não consigo fazer login

3. O nó falha ao chamar o modelo

4. O Flow se perde depois de salvar

5. Os fluxos de trabalho estão muito lentos

Como escolher entre Flowise, Dify e n8n

Como eu colocaria em prática