Cloud Provider Deployment

Flowise can be deployed on various cloud platforms. This guide covers the most popular options.

AWS (Amazon Web Services)

Deploy Flowise on AWS using multiple services.

AWS ECS with Fargate

Create an ECR repository

aws ecr create-repository --repository-name flowise

Build and push Docker image

# Authenticate Docker to ECR
aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin <account-id>.dkr.ecr.us-east-1.amazonaws.com

# Build image
docker build -t flowise .

# Tag image
docker tag flowise:latest <account-id>.dkr.ecr.us-east-1.amazonaws.com/flowise:latest

# Push image
docker push <account-id>.dkr.ecr.us-east-1.amazonaws.com/flowise:latest

Create RDS database

Create a PostgreSQL database using Amazon RDS:

aws rds create-db-instance \
  --db-instance-identifier flowise-db \
  --db-instance-class db.t3.micro \
  --engine postgres \
  --master-username flowise \
  --master-user-password YourSecurePassword \
  --allocated-storage 20

Create ECS cluster

aws ecs create-cluster --cluster-name flowise-cluster

Create task definition

Create a file task-definition.json:

task-definition.json

{
  "family": "flowise-task",
  "networkMode": "awsvpc",
  "requiresCompatibilities": ["FARGATE"],
  "cpu": "512",
  "memory": "1024",
  "containerDefinitions": [
    {
      "name": "flowise",
      "image": "<account-id>.dkr.ecr.us-east-1.amazonaws.com/flowise:latest",
      "portMappings": [
        {
          "containerPort": 3000,
          "protocol": "tcp"
        }
      ],
      "environment": [
        {"name": "PORT", "value": "3000"},
        {"name": "DATABASE_TYPE", "value": "postgres"},
        {"name": "DATABASE_HOST", "value": "flowise-db.xxxxx.us-east-1.rds.amazonaws.com"},
        {"name": "DATABASE_PORT", "value": "5432"},
        {"name": "DATABASE_NAME", "value": "flowise"},
        {"name": "DATABASE_USER", "value": "flowise"},
        {"name": "DATABASE_PASSWORD", "value": "YourSecurePassword"}
      ]
    }
  ]
}

aws ecs register-task-definition --cli-input-json file://task-definition.json

Create ECS service

aws ecs create-service \
  --cluster flowise-cluster \
  --service-name flowise-service \
  --task-definition flowise-task \
  --desired-count 1 \
  --launch-type FARGATE \
  --network-configuration "awsvpcConfiguration={subnets=[subnet-xxxxx],securityGroups=[sg-xxxxx],assignPublicIp=ENABLED}"

AWS EC2

Deploy Flowise on an EC2 instance:

Launch EC2 instance

Launch an Ubuntu 22.04 LTS instance (t2.medium or larger recommended).

Connect and install dependencies

# Update system
sudo apt update && sudo apt upgrade -y

# Install Docker
curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh

# Install Docker Compose
sudo apt install docker-compose -y

# Add user to docker group
sudo usermod -aG docker $USER

Clone and configure Flowise

git clone https://github.com/FlowiseAI/Flowise.git
cd Flowise/docker
cp .env.example .env

# Edit .env file with your settings
nano .env

Start Flowise

docker-compose up -d

Configure security group

Add inbound rule to allow port 3000 from your IP or load balancer.

AWS Storage Integration

Use S3 for file storage and Secrets Manager for secrets:

.env

# S3 Storage
STORAGE_TYPE=s3
S3_STORAGE_BUCKET_NAME=flowise-production
S3_STORAGE_ACCESS_KEY_ID=<your-access-key>
S3_STORAGE_SECRET_ACCESS_KEY=<your-secret-key>
S3_STORAGE_REGION=us-east-1

# AWS Secrets Manager
SECRETKEY_STORAGE_TYPE=aws
SECRETKEY_AWS_ACCESS_KEY=<your-access-key>
SECRETKEY_AWS_SECRET_KEY=<your-secret-key>
SECRETKEY_AWS_REGION=us-east-1
SECRETKEY_AWS_NAME=FlowiseEncryptionKey

Azure

Deploy Flowise on Microsoft Azure.

Azure Container Instances

Create resource group

az group create --name flowise-rg --location eastus

Create Azure Database for PostgreSQL

az postgres flexible-server create \
  --resource-group flowise-rg \
  --name flowise-db \
  --location eastus \
  --admin-user flowise \
  --admin-password YourSecurePassword \
  --sku-name Standard_B1ms \
  --tier Burstable \
  --storage-size 32

# Create database
az postgres flexible-server db create \
  --resource-group flowise-rg \
  --server-name flowise-db \
  --database-name flowise

Deploy container

az container create \
  --resource-group flowise-rg \
  --name flowise \
  --image flowiseai/flowise:latest \
  --dns-name-label flowise-unique \
  --ports 3000 \
  --environment-variables \
    PORT=3000 \
    DATABASE_TYPE=postgres \
    DATABASE_HOST=flowise-db.postgres.database.azure.com \
    DATABASE_PORT=5432 \
    DATABASE_NAME=flowise \
    DATABASE_USER=flowise \
    DATABASE_PASSWORD=YourSecurePassword \
    DATABASE_SSL=true

Access Flowise

Your Flowise instance will be available at:

http://flowise-unique.eastus.azurecontainer.io:3000

Azure App Service

Create App Service plan

az appservice plan create \
  --name flowise-plan \
  --resource-group flowise-rg \
  --is-linux \
  --sku B1

Create web app

az webapp create \
  --resource-group flowise-rg \
  --plan flowise-plan \
  --name flowise-app \
  --deployment-container-image-name flowiseai/flowise:latest

Configure environment variables

az webapp config appsettings set \
  --resource-group flowise-rg \
  --name flowise-app \
  --settings \
    PORT=3000 \
    DATABASE_TYPE=postgres \
    DATABASE_HOST=flowise-db.postgres.database.azure.com \
    DATABASE_PORT=5432 \
    DATABASE_NAME=flowise \
    DATABASE_USER=flowise \
    DATABASE_PASSWORD=YourSecurePassword

Azure Storage Integration

Use Azure Blob Storage for files:

.env

STORAGE_TYPE=azure
AZURE_BLOB_STORAGE_CONNECTION_STRING=<your-connection-string>
AZURE_BLOB_STORAGE_CONTAINER_NAME=flowise-storage

GCP (Google Cloud Platform)

Deploy Flowise on Google Cloud Platform.

Cloud Run

Set up Google Cloud SDK

gcloud init
gcloud config set project your-project-id

Build and push image to Container Registry

# Enable required APIs
gcloud services enable containerregistry.googleapis.com run.googleapis.com

# Build image
gcloud builds submit --tag gcr.io/your-project-id/flowise

Create Cloud SQL instance

gcloud sql instances create flowise-db \
  --database-version=POSTGRES_15 \
  --tier=db-f1-micro \
  --region=us-central1

# Create database
gcloud sql databases create flowise --instance=flowise-db

# Create user
gcloud sql users create flowise \
  --instance=flowise-db \
  --password=YourSecurePassword

Deploy to Cloud Run

gcloud run deploy flowise \
  --image gcr.io/your-project-id/flowise \
  --platform managed \
  --region us-central1 \
  --allow-unauthenticated \
  --add-cloudsql-instances your-project-id:us-central1:flowise-db \
  --set-env-vars PORT=3000,DATABASE_TYPE=postgres,DATABASE_HOST=/cloudsql/your-project-id:us-central1:flowise-db,DATABASE_NAME=flowise,DATABASE_USER=flowise,DATABASE_PASSWORD=YourSecurePassword

GCP Compute Engine

Similar to AWS EC2:

Create VM instance

gcloud compute instances create flowise-vm \
  --image-family=ubuntu-2204-lts \
  --image-project=ubuntu-os-cloud \
  --machine-type=e2-medium \
  --zone=us-central1-a

SSH and install Docker

gcloud compute ssh flowise-vm --zone=us-central1-a

# Install Docker
curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh

# Install Docker Compose
sudo apt install docker-compose -y

Deploy Flowise

git clone https://github.com/FlowiseAI/Flowise.git
cd Flowise/docker
cp .env.example .env
nano .env
docker-compose up -d

GCS Storage Integration

Use Google Cloud Storage for files:

.env

STORAGE_TYPE=gcs
GOOGLE_CLOUD_STORAGE_CREDENTIAL=/path/to/service-account-key.json
GOOGLE_CLOUD_STORAGE_PROJ_ID=your-project-id
GOOGLE_CLOUD_STORAGE_BUCKET_NAME=flowise-storage
GOOGLE_CLOUD_UNIFORM_BUCKET_ACCESS=true

Railway

Railway offers one-click deployment with automatic HTTPS.

One-Click Deploy

Deploy on Railway

Click to deploy Flowise on Railway with one click

Manual Deployment

Create new project

Go to Railway
Click “New Project”
Select “Deploy from GitHub repo”
Choose your Flowise fork

Add PostgreSQL database

Click “New” → “Database” → “Add PostgreSQL”
Railway will automatically provision a database

Configure environment variables

Add these variables to your Flowise service:

PORT=3000
DATABASE_TYPE=postgres
DATABASE_HOST=${{Postgres.PGHOST}}
DATABASE_PORT=${{Postgres.PGPORT}}
DATABASE_NAME=${{Postgres.PGDATABASE}}
DATABASE_USER=${{Postgres.PGUSER}}
DATABASE_PASSWORD=${{Postgres.PGPASSWORD}}

Deploy

Railway will automatically deploy and provide a public URL.

Railway’s free tier has usage limits. Monitor your usage to avoid unexpected charges.

Render

Render provides simple deployment with free tier options.

Deploy Web Service

Create new Web Service

Go to Render Dashboard
Click “New” → “Web Service”
Connect your GitHub repository or use Docker

Configure service

Environment: Docker
Docker Image: flowiseai/flowise:latest
Instance Type: Starter (or higher)

Add PostgreSQL database

Click “New” → “PostgreSQL”
Choose a name and instance type
Note the connection details

Set environment variables

Add to your Web Service:

PORT=3000
DATABASE_TYPE=postgres
DATABASE_HOST=<your-render-postgres-host>
DATABASE_PORT=5432
DATABASE_NAME=<your-db-name>
DATABASE_USER=<your-db-user>
DATABASE_PASSWORD=<your-db-password>
DATABASE_SSL=true

Deploy

Click “Create Web Service” to deploy.

DigitalOcean

Deploy Flowise on DigitalOcean using App Platform or Droplets.

App Platform

Create new app

Go to DigitalOcean App Platform
Click “Create App”
Choose “Docker Hub” as source
Enter flowiseai/flowise as image

Add managed database

In your app, click “Create” → “Database”
Select PostgreSQL
Choose plan and region

Configure environment variables

PORT=3000
DATABASE_TYPE=postgres
DATABASE_HOST=${db.HOSTNAME}
DATABASE_PORT=${db.PORT}
DATABASE_NAME=${db.DATABASE}
DATABASE_USER=${db.USERNAME}
DATABASE_PASSWORD=${db.PASSWORD}
DATABASE_SSL=true

Droplet

Create Droplet

Create Ubuntu 22.04 LTS Droplet (2GB RAM minimum)
Choose datacenter region
Add SSH key

SSH and setup

ssh root@your-droplet-ip

# Install Docker
curl -fsSL https://get.docker.com -o get-docker.sh
sh get-docker.sh

# Install Docker Compose
apt install docker-compose -y

Deploy Flowise

git clone https://github.com/FlowiseAI/Flowise.git
cd Flowise/docker
cp .env.example .env
nano .env
docker-compose up -d

Other Platforms

Northflank

One-click deploy on Northflank

HuggingFace Spaces

Deploy on HuggingFace Spaces

Elestio

Managed Flowise hosting on Elestio

Sealos

Deploy on Sealos platform

Production Checklist

Before deploying to production:

Domain and SSL

For production deployments, configure a custom domain with SSL:

AWS (ALB)
Nginx Reverse Proxy
Cloudflare

Create Application Load Balancer
Request SSL certificate in ACM
Configure HTTPS listener with certificate
Point target group to ECS service
Update DNS to point to ALB

server {
    listen 80;
    server_name flowise.example.com;
    return 301 https://$server_name$request_uri;
}

server {
    listen 443 ssl http2;
    server_name flowise.example.com;

    ssl_certificate /etc/letsencrypt/live/flowise.example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/flowise.example.com/privkey.pem;

    location / {
        proxy_pass http://localhost:3000;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_cache_bypass $http_upgrade;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

Get Started

Core Concepts

Building Workflows

Integrations

Features

Deployment

Development

Cloud Provider Deployment

AWS (Amazon Web Services)

AWS ECS with Fargate

AWS EC2

AWS Storage Integration

Azure

Azure Container Instances

Azure App Service

Azure Storage Integration

GCP (Google Cloud Platform)

Cloud Run

GCP Compute Engine

GCS Storage Integration

Railway

One-Click Deploy

Deploy on Railway

Manual Deployment

Render

Deploy Web Service

DigitalOcean

App Platform

Droplet

Other Platforms

Northflank

HuggingFace Spaces

Elestio

Sealos

Production Checklist

Domain and SSL

Next Steps

Environment Variables

Authentication

Build docs developers (and LLMs) love

Get Started

Core Concepts

Building Workflows

Integrations

Features

Deployment

Development

​AWS (Amazon Web Services)

​AWS ECS with Fargate

​AWS EC2

​AWS Storage Integration

​Azure

​Azure Container Instances

​Azure App Service

​Azure Storage Integration

​GCP (Google Cloud Platform)

​Cloud Run

​GCP Compute Engine

​GCS Storage Integration

​Railway

​One-Click Deploy

Deploy on Railway

​Manual Deployment

​Render

​Deploy Web Service

​DigitalOcean

​App Platform

​Droplet

​Other Platforms

Northflank

HuggingFace Spaces

Elestio

Sealos

​Production Checklist

​Domain and SSL

​Next Steps

Environment Variables

Authentication

Build docs developers (and LLMs) love

AWS (Amazon Web Services)

AWS ECS with Fargate

AWS EC2

AWS Storage Integration

Azure

Azure Container Instances

Azure App Service

Azure Storage Integration

GCP (Google Cloud Platform)

Cloud Run

GCP Compute Engine

GCS Storage Integration

Railway

One-Click Deploy

Manual Deployment

Render

Deploy Web Service

DigitalOcean

App Platform

Droplet

Other Platforms

Production Checklist

Domain and SSL

Next Steps