Implantar Langflow em VPS: Docker, PostgreSQL, API e HTTPS (2026)

O Langflow é para quem quer arrastar prompts, modelos, ferramentas e etapas de processamento de dados para formar um fluxo de trabalho executável. Ele não é um modelo de linguagem local e não elimina os custos dos modelos por mágica; uma VPS comum executa o editor visual, a API e o banco de dados, enquanto a inferência real é feita pela OpenAI, Anthropic, OpenRouter, LiteLLM ou outro servidor Ollama.

Este guia implanta a versão estável v1.11.1 publicada em 28 de julho de 2026. A arquitetura final é Langflow + PostgreSQL + Caddy, sem expor diretamente 7860 e 5432 à internet. O objetivo não é abrir uma página de demonstração temporariamente, mas configurar juntos o login, o HTTPS, a Flow API, as atualizações e os backups.

Primeiro, as conclusões de dimensionamento:

Uma pessoa criando fluxos com chamadas de API de baixa frequência: 2 núcleos, 4 GB e um SSD de 40 GB bastam para começar;
Uso compartilhado por 3 a 10 pessoas, ou fluxos com processamento de documentos mais pesado: recomendam-se 4 núcleos, 8 GB e um SSD de 80 GB;
Uma VPS comum com CPU não é adequada para rodar modelos grandes localmente; em especial, não divida 4 GB de memória entre Langflow, PostgreSQL e Ollama ao mesmo tempo;
Se você só quer testar por dez minutos, pode usar um único contêiner com SQLite; se pretende usar a longo prazo, vá direto para o PostgreSQL.

Como escolher entre Langflow, Dify e Flowise

Essas três ferramentas se sobrepõem, mas o foco de uso é diferente:

Ferramenta	Mais adequada para	Características da implantação
Langflow	Montar rapidamente Agentes, cadeias de modelos e APIs chamáveis com nós	Ecossistema Python, muitos componentes, depuração de Flows intuitiva
Dify	Criar aplicações de IA com base de conhecimento, painel administrativo e interface para o usuário final	Mais serviços, uma implantação completa consome mais recursos
Flowise	Quem conhece LangChain e quer montar fluxos de chat rapidamente	Ecossistema Node.js, início direto

Se o foco são aplicações RAG e gestão operacional, veja o tutorial de implantação da base de conhecimento privada do Dify. Leitores que preferem Node.js e LangChain podem comparar o tutorial de fluxos de trabalho visuais de IA com Flowise. Este artigo cobre apenas a implantação de produção do Langflow em uma única máquina.

Não olhe só para o contêiner do Langflow ao dimensionar a VPS

O Langflow em si não é a parte que mais consome recursos. A memória sobe bastante quando os fluxos carregam componentes, analisam arquivos e aguardam várias respostas de modelos; o PostgreSQL, o cache do sistema e o Docker também precisam de espaço.

Uso	Configuração recomendada	Observações
Aprendizado pessoal, poucos Flows	2 núcleos, 4 GB	Executar poucos fluxos por vez, sem inferência local
Equipe pequena, mais processamento de documentos	4 núcleos, 8 GB	Deixar folga para o banco de dados e tarefas concorrentes
Vários Workers, API de alta concorrência	8 GB ou mais, adicionar Redis	Fora do escopo leve de máquina única deste artigo
Inferência de modelos local	Uma máquina GPU separada	O Langflow apenas se conecta às APIs de modelos

Se ainda não decidiu o tamanho, veja Como escolher a configuração de uma VPS. 2 núcleos e 4 GB é um ponto de partida, não uma promessa de concorrência.

Como as requisições fluem após a implantação

Nesta arquitetura, apenas o Caddy fica exposto à internet:

浏览器 / API 客户端
        │ HTTPS 443
        ▼
      Caddy
        │ 127.0.0.1:7860
        ▼
     Langflow ──────► OpenAI / Anthropic / OpenRouter / LiteLLM
        │
        │ Docker 内部网络
        ▼
    PostgreSQL:5432

O PostgreSQL não tem mapeamento de porta no host. O Langflow se vincula apenas a 127.0.0.1:7860, então mesmo que o UFW esteja mal configurado, o editor não ficará exposto diretamente no IP público.

Preparar o domínio, o Docker e o firewall

Este artigo usa Ubuntu 24.04. Primeiro aponte os registros A/AAAA de langflow.example.com para a VPS. Substitua o domínio de exemplo pelo seu; não copie literalmente.

Instale as ferramentas básicas:

sudo apt update
sudo apt install -y ca-certificates curl openssl ufw

Instale o Docker a partir do repositório oficial:

sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg \
  -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc

echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/ubuntu \
  $(. /etc/os-release && echo "$VERSION_CODENAME") stable" |
  sudo tee /etc/apt/sources.list.d/docker.list >/dev/null

sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io \
  docker-buildx-plugin docker-compose-plugin
sudo systemctl enable --now docker
sudo docker version
sudo docker compose version

O firewall permite apenas SSH, HTTP e HTTPS:

sudo ufw allow OpenSSH
sudo ufw allow 80/tcp
sudo ufw allow 443/tcp
sudo ufw enable
sudo ufw status

Ao trabalhar remotamente, sempre libere o OpenSSH antes de ativar o UFW. Não abra 7860 nem 5432.

Criar o diretório de configuração do Langflow

sudo mkdir -p /opt/langflow
sudo chown "$USER":"$USER" /opt/langflow
cd /opt/langflow

Primeiro gere três valores aleatórios: a senha do banco de dados, a senha do administrador e a chave de criptografia. Os comandos abaixo apenas gravam em variáveis do terminal atual e não são salvos automaticamente em um arquivo de histórico:

langflow_db_password="$(openssl rand -hex 24)"
langflow_admin_password="$(openssl rand -hex 24)"
langflow_secret_key="$(python3 -c 'from secrets import token_urlsafe; print(token_urlsafe(32))')"

Crie .env:

umask 077
cat >.env <<EOF
POSTGRES_USER=langflow
POSTGRES_PASSWORD=${langflow_db_password}
POSTGRES_DB=langflow
LANGFLOW_SUPERUSER=admin
LANGFLOW_SUPERUSER_PASSWORD=${langflow_admin_password}
LANGFLOW_SECRET_KEY=${langflow_secret_key}
EOF
chmod 600 .env

Coloque a senha do administrador no gerenciador de senhas e depois limpe as variáveis do terminal:

unset langflow_db_password langflow_admin_password langflow_secret_key

LANGFLOW_SECRET_KEY é usado para criptografar as Credential no banco de dados. Se ele for perdido, mesmo que o banco de dados ainda exista, as chaves de modelo já salvas podem não ser mais descriptografáveis, então .env precisa ser incluído no backup junto com o banco de dados.

Escrever o Docker Compose

Crie /opt/langflow/docker-compose.yml:

services:
  postgres:
    image: postgres:16-trixie
    restart: unless-stopped
    environment:
      POSTGRES_USER: ${POSTGRES_USER}
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
      POSTGRES_DB: ${POSTGRES_DB}
    volumes:
      - langflow-postgres:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER} -d ${POSTGRES_DB}"]
      interval: 10s
      timeout: 5s
      retries: 10
    logging:
      driver: json-file
      options:
        max-size: "10m"
        max-file: "3"

  langflow:
    image: langflowai/langflow:v1.11.1
    restart: unless-stopped
    depends_on:
      postgres:
        condition: service_healthy
    ports:
      - "127.0.0.1:7860:7860"
    environment:
      LANGFLOW_DATABASE_URL: postgresql://${POSTGRES_USER}:${POSTGRES_PASSWORD}@postgres:5432/${POSTGRES_DB}
      LANGFLOW_CONFIG_DIR: /app/langflow
      LANGFLOW_AUTO_LOGIN: "False"
      LANGFLOW_SUPERUSER: ${LANGFLOW_SUPERUSER}
      LANGFLOW_SUPERUSER_PASSWORD: ${LANGFLOW_SUPERUSER_PASSWORD}
      LANGFLOW_SECRET_KEY: ${LANGFLOW_SECRET_KEY}
      LANGFLOW_OPEN_BROWSER: "False"
      LANGFLOW_LOG_LEVEL: INFO
      DO_NOT_TRACK: "True"
    volumes:
      - langflow-data:/app/langflow
    healthcheck:
      test:
        - CMD-SHELL
        - >-
          python -c "import urllib.request;
          urllib.request.urlopen('http://127.0.0.1:7860/health_check', timeout=5)"
      interval: 30s
      timeout: 10s
      retries: 10
      start_period: 90s
    logging:
      driver: json-file
      options:
        max-size: "20m"
        max-file: "3"

volumes:
  langflow-postgres:
  langflow-data:

Aqui se usa a imagem oficial v1.11.1 e postgres:16-trixie. O exemplo oficial indica que fixar a versão base Debian do PostgreSQL evita avisos de collation do glibc quando o sistema subjacente muda silenciosamente.

Primeiro renderize a configuração do Compose:

chmod 600 .env docker-compose.yml
sudo docker compose config --quiet
sudo docker compose config --images

Não cole a saída completa de docker compose config em fóruns ou tickets; ela expande as senhas do banco de dados e do administrador.

Para entender por que os healthchecks, a rotação de logs e as políticas de reinício são configurados assim, continue com a checklist de configuração do Docker Compose para produção.

Iniciar e verificar os contêineres

cd /opt/langflow
sudo docker compose pull
sudo docker compose up -d
sudo docker compose ps

A primeira inicialização precisa criar as tabelas do banco de dados e carregar os componentes, então demora mais que um site estático comum. Continue acompanhando os logs:

sudo docker compose logs -f --tail=200 langflow postgres

Quando o serviço parecer saudável, pressione Ctrl+C para sair dos logs e depois verifique o endpoint de saúde:

curl -fsS http://127.0.0.1:7860/health_check
sudo docker compose ps
sudo ss -lntp | grep -E ':7860|:5432'

O endpoint de saúde deve retornar o status do banco de dados e do serviço de chat. Na lista de escuta, 7860 deve ser apenas 127.0.0.1:7860; 5432 não deve aparecer entre as portas de escuta do host.

Configurar HTTPS com o Caddy

Instale o Caddy:

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

Edite /etc/caddy/Caddyfile:

langflow.example.com {
    encode zstd gzip
    reverse_proxy 127.0.0.1:7860 {
        transport http {
            read_timeout 10m
        }
    }
}

Fluxos mais longos podem aguardar a execução de modelos ou ferramentas, então aqui o tempo limite de leitura do proxy reverso é elevado para 10 minutos. Depois de salvar, valide e recarregue:

sudo caddy validate --config /etc/caddy/Caddyfile
sudo systemctl reload caddy
curl -I https://langflow.example.com

Se a emissão do certificado falhar, primeiro confirme que o DNS aponta para a VPS atual e que 80/443 não estão ocupadas por outro programa. Os passos completos de solução de problemas estão no tutorial de proxy reverso Caddy e HTTPS automático.

Abra https://langflow.example.com e faça login com o LANGFLOW_SUPERUSER de .env e a senha do administrador. Não volte a colocar o login automático em True; um editor público sem proteção de login será encontrado rapidamente por scanners.

Depois de entrar, conclua primeiro quatro coisas:

Crie um novo projeto para que os Flows seguintes não se acumulem todos no diretório padrão;
Crie um Flow de chat mínimo, começando pelo template Basic Prompting;
Crie uma nova Credential no componente de modelo e preencha uma Key da OpenAI, Anthropic ou OpenRouter;
Envie uma mensagem de teste no Playground para confirmar que os nós de entrada, modelo e saída funcionam.

As Keys de modelo ficam nas variáveis globais ou Credentials do Langflow e são criptografadas por LANGFLOW_SECRET_KEY. Não escreva Keys reais diretamente no JSON do Flow exportado nem codifique Keys diretamente no Compose de um tutorial.

Se sua equipe já tem um gateway de modelos unificado, você pode conectar o LiteLLM. Assim você centraliza Keys virtuais, orçamentos e roteamento de modelos; veja o tutorial de gateway de API LLM unificado com LiteLLM para a implantação.

Chamar um Flow pela API

Quando o Flow funcionar no Playground, abra o painel API do Flow e copie o Flow ID. Depois vá à página API Keys das configurações pessoais e crie uma Langflow API Key.

Defina as variáveis na máquina que faz a chamada:

export LANGFLOW_SERVER_URL="https://langflow.example.com"
export LANGFLOW_API_KEY="粘贴刚创建的 Langflow API Key"
export LANGFLOW_FLOW_ID="粘贴 Flow ID"

Chame a v1 Flow API:

curl --request POST \
  --url "${LANGFLOW_SERVER_URL}/api/v1/run/${LANGFLOW_FLOW_ID}?stream=false" \
  --header "Content-Type: application/json" \
  --header "x-api-key: ${LANGFLOW_API_KEY}" \
  --data '{
    "input_value": "用三句话解释什么是 VPS",
    "output_type": "chat",
    "input_type": "chat"
  }'

Se o Flow real precisar de tweaks, use o código gerado automaticamente pelo painel API. Os IDs de nó variam entre componentes, então não os copie cegamente do exemplo de outra pessoa.

Uma Langflow API Key só deve ficar no lado do servidor, em CI Secrets ou em uma plataforma de automação segura. Se for escrita no JavaScript do navegador, qualquer visitante poderá obtê-la pelas ferramentas de desenvolvedor.

Como atualizar e reverter

Não use latest em produção. Antes de atualizar, leia as Release Notes da nova versão, confirme as mudanças de migração do banco de dados e de variáveis de ambiente e depois faça o backup completo da próxima seção.

Verifique a imagem atual:

cd /opt/langflow
sudo docker compose images

Altere v1.11.1 em docker-compose.yml para a nova versão estável que você confirmou e depois:

sudo docker compose pull langflow
sudo docker compose up -d langflow
sudo docker compose logs --tail=300 langflow postgres
curl -fsS http://127.0.0.1:7860/health_check

Se a atualização envolver migração do banco de dados, simplesmente voltar a tag da imagem para v1.11.1 pode não reverter. O caminho seguro é restaurar juntos o dump do PostgreSQL anterior à atualização, o diretório de configuração e a versão antiga da imagem.

Backup do banco de dados, da configuração e das chaves

Um backup completo inclui pelo menos:

O banco de dados PostgreSQL;
O Volume langflow-data;
.env e docker-compose.yml;
O Caddyfile;
A versão atual da imagem do Langflow.

Crie um diretório de backup e exporte o PostgreSQL:

cd /opt/langflow
backup_dir="backups/$(date +%F-%H%M%S)"
mkdir -p "$backup_dir"

sudo docker compose exec -T postgres sh -c \
  'pg_dump -U "$POSTGRES_USER" -d "$POSTGRES_DB" -Fc' \
  >"$backup_dir/langflow-postgres.dump"

cp .env docker-compose.yml "$backup_dir/"
sudo cp /etc/caddy/Caddyfile "$backup_dir/Caddyfile"
sudo chown -R "$USER":"$USER" "$backup_dir"
chmod 600 "$backup_dir/.env"
sudo docker compose images >"$backup_dir/docker-images.txt"

Pare brevemente as gravações do Langflow e depois empacote o Volume de configuração:

sudo docker compose stop langflow
langflow_data_volume="$(sudo docker volume ls --format '{{.Name}}' | grep '_langflow-data$' | head -1)"
test -n "$langflow_data_volume"

sudo docker run --rm \
  -v "${langflow_data_volume}:/source:ro" \
  -v "$PWD/$backup_dir:/backup" \
  alpine tar -czf /backup/langflow-data.tar.gz -C /source .

sudo docker compose up -d langflow

Sincronize o backup com outra máquina ou com armazenamento de objetos. Um backup no mesmo disco da VPS só protege contra exclusão acidental, não contra a falha da máquina inteira. Para um plano externo mais completo, veja Simulação de backup e restauração de VPS.

Ensaie a restauração primeiro em uma VPS de teste. Prepare a mesma versão de .env e do Compose, inicie o PostgreSQL e depois restaure:

cat langflow-postgres.dump |
  sudo docker compose exec -T postgres sh -c \
  'pg_restore -U "$POSTGRES_USER" -d "$POSTGRES_DB" --clean --if-exists'

Depois restaure langflow-data e, por fim, inicie o Langflow. A chave e o banco de dados precisam ser correspondentes; não é possível restaurar apenas um deles.

Como diagnosticar falhas comuns

A página não abre

sudo docker compose ps
curl -v http://127.0.0.1:7860/health_check
sudo systemctl status caddy --no-pager
sudo journalctl -u caddy -n 100 --no-pager

Se a porta 7860 funciona localmente mas o domínio não abre, o problema geralmente está no DNS, no Caddy ou no firewall. Se também não funcionar localmente, verifique os logs do Langflow.

Falha na conexão com o PostgreSQL

sudo docker compose ps postgres
sudo docker compose logs --tail=200 postgres langflow
sudo docker compose exec postgres sh -c \
  'pg_isready -U "$POSTGRES_USER" -d "$POSTGRES_DB"'

Verifique principalmente se a senha do banco de dados contém caracteres especiais de URI adicionados manualmente, se o nome do serviço após a renderização do Compose é postgres e se um Volume antigo manteve outra senha. Este artigo usa senhas aleatórias hexadecimais, o que evita problemas de escape na string de conexão.

Confirme que as quatro variáveis existem em .env, mas não exiba seus valores:

for variable_name in \
  LANGFLOW_AUTO_LOGIN LANGFLOW_SUPERUSER LANGFLOW_SUPERUSER_PASSWORD LANGFLOW_SECRET_KEY; do
  sudo docker compose exec -T langflow sh -c \
    'test -n "$(printenv "$1")"' sh "$variable_name" &&
    echo "$variable_name 已设置"
done

Neste artigo, LANGFLOW_AUTO_LOGIN está escrito no Compose, não em .env. Por isso o primeiro item deve ser confirmado na configuração renderizada:

sudo docker compose config | grep 'LANGFLOW_AUTO_LOGIN: "False"'

A conta de administrador só é criada durante a inicialização. Quando já existe um banco de dados antigo, alterar .env não redefine automaticamente a senha de um usuário existente; não exclua contêineres repetidamente na esperança de dar sorte e, acima de tudo, não exclua o Volume do banco de dados.

A API retorna 401

Verifique se o cabeçalho da requisição é x-api-key e se o valor é a Langflow API Key, e não uma OpenAI Key. Confirme também que a API Key não tem espaços copiados a mais:

test -n "$LANGFLOW_API_KEY" && echo "LANGFLOW_API_KEY 已设置"
curl -i "${LANGFLOW_SERVER_URL}/api/v1/version" \
  -H "x-api-key: ${LANGFLOW_API_KEY}"

O Flow fica girando ou o proxy reverso expira

sudo docker compose logs -f --tail=200 langflow
free -h
sudo docker stats --no-stream

Se os logs mostrarem timeout da API do modelo, verifique primeiro o provedor do modelo e a rede de saída; se o contêiner foi OOM Killed, aumente a memória ou reduza os fluxos executados ao mesmo tempo. Não aumente o timeout do Caddy para uma hora de imediato; isso só esconde o erro real por mais tempo.

Checklist antes de publicar

O Langflow está fixado em v1.11.1 e não usa latest;
LANGFLOW_AUTO_LOGIN=False, e a senha do administrador é longa o suficiente;
LANGFLOW_SECRET_KEY é incluído no backup junto com o PostgreSQL;
7860 se vincula apenas a 127.0.0.1, e 5432 não tem porta no host;
O certificado de https://langflow.example.com está válido;
O Playground consegue concluir uma chamada real ao modelo;
Uma requisição à Flow API com x-api-key é bem-sucedida;
O banco de dados, o Volume de configuração, .env e o Caddyfile têm backups externos;
A versão da imagem é registrada antes da atualização e uma restauração de teste foi feita.

O Langflow é mais bem colocado "na frente da API do modelo": uma VPS comum executa o editor, os fluxos e o banco de dados, enquanto a GPU ou os modelos comerciais ficam do outro lado. 2 núcleos e 4 GB bastam para uma pessoa começar, mas equipes pequenas não devem economizar nesses 4 GB de memória. O que realmente determina se você poderá usá-lo a longo prazo não é a beleza dos nós, mas se o login, as chaves, o banco de dados e o processo de recuperação foram bem feitos.

Recursos oficiais

Ferramenta

Mais adequada para

Características da implantação

Langflow

Montar rapidamente Agentes, cadeias de modelos e APIs chamáveis com nós

Ecossistema Python, muitos componentes, depuração de Flows intuitiva

Dify

Criar aplicações de IA com base de conhecimento, painel administrativo e interface para o usuário final

Mais serviços, uma implantação completa consome mais recursos

Flowise

Quem conhece LangChain e quer montar fluxos de chat rapidamente

Ecossistema Node.js, início direto

Uso

Configuração recomendada

Observações

Aprendizado pessoal, poucos Flows

2 núcleos, 4 GB

Executar poucos fluxos por vez, sem inferência local

Equipe pequena, mais processamento de documentos

4 núcleos, 8 GB

Deixar folga para o banco de dados e tarefas concorrentes

Vários Workers, API de alta concorrência

8 GB ou mais, adicionar Redis

Fora do escopo leve de máquina única deste artigo

Inferência de modelos local

Uma máquina GPU separada

O Langflow apenas se conecta às APIs de modelos

浏览器 / API 客户端 │ HTTPS 443 ▼ Caddy │ 127.0.0.1:7860 ▼ Langflow ──────► OpenAI / Anthropic / OpenRouter / LiteLLM │ │ Docker 内部网络 ▼ PostgreSQL:5432

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

umask 077 cat >.env <<EOF POSTGRES_USER=langflow POSTGRES_PASSWORD=${langflow_db_password} POSTGRES_DB=langflow LANGFLOW_SUPERUSER=admin LANGFLOW_SUPERUSER_PASSWORD=${langflow_admin_password} LANGFLOW_SECRET_KEY=${langflow_secret_key} EOF chmod 600 .env

services: postgres: image: postgres:16-trixie restart: unless-stopped environment: POSTGRES_USER: ${POSTGRES_USER} POSTGRES_PASSWORD: ${POSTGRES_PASSWORD} POSTGRES_DB: ${POSTGRES_DB} volumes: - langflow-postgres:/var/lib/postgresql/data healthcheck: test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER} -d ${POSTGRES_DB}"] interval: 10s timeout: 5s retries: 10 logging: driver: json-file options: max-size: "10m" max-file: "3" langflow: image: langflowai/langflow:v1.11.1 restart: unless-stopped depends_on: postgres: condition: service_healthy ports: - "127.0.0.1:7860:7860" environment: LANGFLOW_DATABASE_URL: postgresql://${POSTGRES_USER}:${POSTGRES_PASSWORD}@postgres:5432/${POSTGRES_DB} LANGFLOW_CONFIG_DIR: /app/langflow LANGFLOW_AUTO_LOGIN: "False" LANGFLOW_SUPERUSER: ${LANGFLOW_SUPERUSER} LANGFLOW_SUPERUSER_PASSWORD: ${LANGFLOW_SUPERUSER_PASSWORD} LANGFLOW_SECRET_KEY: ${LANGFLOW_SECRET_KEY} LANGFLOW_OPEN_BROWSER: "False" LANGFLOW_LOG_LEVEL: INFO DO_NOT_TRACK: "True" volumes: - langflow-data:/app/langflow healthcheck: test: - CMD-SHELL - >- python -c "import urllib.request; urllib.request.urlopen('http://127.0.0.1:7860/health_check', timeout=5)" interval: 30s timeout: 10s retries: 10 start_period: 90s logging: driver: json-file options: max-size: "20m" max-file: "3" volumes: langflow-postgres: langflow-data:

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

curl --request POST \ --url "${LANGFLOW_SERVER_URL}/api/v1/run/${LANGFLOW_FLOW_ID}?stream=false" \ --header "Content-Type: application/json" \ --header "x-api-key: ${LANGFLOW_API_KEY}" \ --data '{ "input_value": "用三句话解释什么是 VPS", "output_type": "chat", "input_type": "chat" }'

cd /opt/langflow backup_dir="backups/$(date +%F-%H%M%S)" mkdir -p "$backup_dir" sudo docker compose exec -T postgres sh -c \ 'pg_dump -U "$POSTGRES_USER" -d "$POSTGRES_DB" -Fc' \ >"$backup_dir/langflow-postgres.dump" cp .env docker-compose.yml "$backup_dir/" sudo cp /etc/caddy/Caddyfile "$backup_dir/Caddyfile" sudo chown -R "$USER":"$USER" "$backup_dir" chmod 600 "$backup_dir/.env" sudo docker compose images >"$backup_dir/docker-images.txt"

sudo docker compose stop langflow langflow_data_volume="$(sudo docker volume ls --format '{{.Name}}' | grep '_langflow-data$' | head -1)" test -n "$langflow_data_volume" sudo docker run --rm \ -v "${langflow_data_volume}:/source:ro" \ -v "$PWD/$backup_dir:/backup" \ alpine tar -czf /backup/langflow-data.tar.gz -C /source . sudo docker compose up -d langflow

for variable_name in \ LANGFLOW_AUTO_LOGIN LANGFLOW_SUPERUSER LANGFLOW_SUPERUSER_PASSWORD LANGFLOW_SECRET_KEY; do sudo docker compose exec -T langflow sh -c \ 'test -n "$(printenv "$1")"' sh "$variable_name" && echo "$variable_name 已设置" done

Implantar o Langflow em uma VPS (2026): tutorial completo de Docker Compose, PostgreSQL, login, API e HTTPS

Como escolher entre Langflow, Dify e Flowise

Não olhe só para o contêiner do Langflow ao dimensionar a VPS

Como as requisições fluem após a implantação

Preparar o domínio, o Docker e o firewall

Criar o diretório de configuração do Langflow

Escrever o Docker Compose

Iniciar e verificar os contêineres

Configurar HTTPS com o Caddy

Chamar um Flow pela API

Como atualizar e reverter

Backup do banco de dados, da configuração e das chaves

Como diagnosticar falhas comuns

A página não abre

Falha na conexão com o PostgreSQL

A API retorna 401

O Flow fica girando ou o proxy reverso expira

Checklist antes de publicar

Recursos oficiais

Carregando…

Implantar o Langflow em uma VPS (2026): tutorial completo de Docker Compose, PostgreSQL, login, API e HTTPS

Como escolher entre Langflow, Dify e Flowise

Não olhe só para o contêiner do Langflow ao dimensionar a VPS

Como as requisições fluem após a implantação

Preparar o domínio, o Docker e o firewall

Criar o diretório de configuração do Langflow

Escrever o Docker Compose

Iniciar e verificar os contêineres

Configurar HTTPS com o Caddy

Chamar um Flow pela API

Como atualizar e reverter

Backup do banco de dados, da configuração e das chaves

Como diagnosticar falhas comuns

A página não abre

Falha na conexão com o PostgreSQL

A API retorna 401

O Flow fica girando ou o proxy reverso expira

Checklist antes de publicar

Recursos oficiais

Como escolher entre Langflow, Dify e Flowise

Não olhe só para o contêiner do Langflow ao dimensionar a VPS

Como as requisições fluem após a implantação

Preparar o domínio, o Docker e o firewall

Criar o diretório de configuração do Langflow

Escrever o Docker Compose

Iniciar e verificar os contêineres

Configurar HTTPS com o Caddy

O que fazer no primeiro login

Chamar um Flow pela API

Como atualizar e reverter

Backup do banco de dados, da configuração e das chaves

Como diagnosticar falhas comuns

A página não abre

Falha na conexão com o PostgreSQL

Falha no login ou conta de administrador não criada

A API retorna 401

O Flow fica girando ou o proxy reverso expira

Checklist antes de publicar

Recursos oficiais

Carregando…

Como escolher entre Langflow, Dify e Flowise

Não olhe só para o contêiner do Langflow ao dimensionar a VPS

Como as requisições fluem após a implantação

Preparar o domínio, o Docker e o firewall

Criar o diretório de configuração do Langflow

Escrever o Docker Compose

Iniciar e verificar os contêineres

Configurar HTTPS com o Caddy

O que fazer no primeiro login

Chamar um Flow pela API

Como atualizar e reverter

Backup do banco de dados, da configuração e das chaves

Como diagnosticar falhas comuns

A página não abre

Falha na conexão com o PostgreSQL

Falha no login ou conta de administrador não criada

A API retorna 401

O Flow fica girando ou o proxy reverso expira

Checklist antes de publicar

Recursos oficiais