🚀 Deploy Flowise + Kubernetes + Helm on Ubuntu VPS (10-Step Guide)

Here’s a step-by-step guide to deploy FlowiseAI (commonly just Flowise) on a Ubuntu VPS using Helm + Kubernetes. I assume you have a Ubuntu server (or VPS) and you’re comfortable with shell commands and basic Kubernetes.

I’ll walk you through setting up Kubernetes (if not already), installing Helm, and deploying the Flowise helm chart, with production-ready tweaks.

What is Flowise?

Flowise is a low-code/no-code open-source platform for building AI agents and workflows visually.

Here are the key facts, followed by some thoughts on how it might fit your marketing/hosting-company context.

✅ What it is

• Provides modular building-blocks (nodes) that you can wire together in a drag-and-drop visual UI to create conversational agents, workflow automations, knowledge-retrieval bots, etc.
• Supports multiple fronts: chat assistants, multi-agent systems, human-in-the-loop workflows, observability/metrics for production use.
• Open-source: the codebase is on GitHub with ~46k stars (as of the referenced snapshot) and you can self-host.

🎯 Key Features (for your reference)

• Visual builder + workflow orchestration for single-agent or multi-agent systems.
• Integration support: wide range of LLMs (large language models), embedding/vector DBs, and various data sources.
• Human-in-the-loop: you can insert checkpoints where a human reviews/approves the agent’s output.
• Observability/metrics: execution traces, monitoring, fine-tuning of workflows in production.
• Deployment flexibility: self-hosted or cloud, which gives you control (important for a hosting/infra-oriented user).

What is Kubernetes?

Kubernetes (often abbreviated K8s) is an open-source system for automating the deployment, scaling, and management of containerized applications.

🧩 Overview

Kubernetes was originally developed by Google and is now maintained by the Cloud Native Computing Foundation (CNCF). It’s designed to help you run applications reliably across clusters of physical or virtual machines by managing containers (like those from Docker, containerd, etc.) automatically.

⚙️ Core Functions

• Container orchestration: Automatically schedules and runs containers across nodes in a cluster.
• Scaling: Increases or decreases application instances based on demand (manual or automatic).
• Load balancing: Distributes traffic evenly across multiple instances of a service.
• Self-healing: Restarts failed containers, replaces unresponsive nodes, and ensures desired state is maintained.
• Rolling updates: Deploys new versions of apps without downtime.
• Secret and configuration management: Securely stores passwords, keys, and config values.

🧠 Key Components

🚀 Why It’s Popular

• Works across any environment — on-premises, private cloud, or public cloud (AWS, Azure, GCP, etc.).
• Enables microservices architecture, allowing teams to develop and deploy components independently.
• Supports GitOps, DevOps pipelines, and CI/CD automation.
• Backed by a large ecosystem (Helm, Istio, Prometheus, etc.).

What is Helm?

Helm is the package manager for Kubernetes — often described as “apt” or “yum” for Kubernetes.”

It simplifies the deployment, management, and versioning of complex Kubernetes applications by packaging them into reusable units called Helm charts.

🧩 Overview

Helm was created by Deis (acquired by Microsoft) and is now a CNCF (Cloud Native Computing Foundation) project — just like Kubernetes itself.
It provides a standardized way to define, install, and upgrade even the most complex Kubernetes workloads with just a few commands.

📦 What is a Helm Chart?

A Helm chart is a collection of files that describe a set of Kubernetes resources.
Each chart contains:

• Chart.yaml — metadata about the chart (name, version, description)
• values.yaml — default configuration values
• templates/ — YAML templates that define Kubernetes manifests (Deployments, Services, Ingress, etc.)
• charts/ — optional subcharts (dependencies)

Charts let you define reusable and configurable deployments.

Example:
Instead of manually applying 10 YAML files to deploy a web app, you can use:

helm install myapp ./mychart

Helm will generate all necessary Kubernetes objects (pods, services, ingress, etc.) from your chart.

⚙️ Key Features

🚀 Why Use Helm

• Simplifies deploying complex, multi-service applications (e.g., WordPress, FlowiseAI, Prometheus, Grafana).
• Supports DevOps automation and CI/CD pipelines.
• Enables consistent deployments across multiple environments (dev, staging, production).
• Makes it easy to share your application as a chart to other users or customers.

Prerequisites

Make sure:

• You have a Ubuntu 20.04/Ubuntu 22.04 VPS with sudo access.
• Enough resources: Flowise docs recommend for production 2 main servers each with ~4 vCPU + 8 GB RAM and workers similarly.
• You have or will set up a Kubernetes cluster (single node is okay for testing – multi-node for production).
• kubectl installed and configured to talk to your cluster.
• Helm v3 installed. The Flowise Helm chart lists prerequisite Helm >= 3.9 and Kubernetes >= 1.24.
• A domain or at least ability to expose a service (Ingress/LoadBalancer) if you want external access.

How to Deploy Flowise + Kubernetes + Helm on Ubuntu VPS

To deploy Flowise + Kubernetes + Helm on Ubuntu VPS, follow the steps outlined below:

1. Set up Kubernetes on Ubuntu VPS

   If you don’t already have K8s cluster, you can set up a simple one-node cluster for testing. Example with kubeadm (you can adjust for your needs):

   sudo apt update && sudo apt install -y apt-transport-https ca-certificates curl curl -fsSL https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add - echo "deb https://apt.kubernetes.io/ kubernetes-jammy main" | sudo tee /etc/apt/sources.list.d/kubernetes.list echo "deb [signed-by=/etc/apt/keyrings/kubernetes-apt-keyring.gpg] https://pkgs.k8s.io/core:/stable:/v1.28/deb/ /" | sudo tee /etc/apt/sources.list.d/kubernetes.list curl -fsSL https://pkgs.k8s.io/core:/stable:/v1.28/deb/Release.key | sudo gpg --dearmor -o /etc/apt/keyrings/kubernetes-apt-keyring.gpg sudo apt update sudo swapoff -a sudo ufw allow 22,8080/tcp sudo ufw enable sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" sudo apt update sudo apt install docker-ce -y sudo systemctl start docker sudo systemctl enable docker sudo apt install -y kubelet kubeadm kubectl sudo kubeadm init --pod-network-cidr=10.244.0.0/16

   Then set up your user’s kubeconfig:

   mkdir -p $HOME/.kube sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config sudo chown $(id -u):$(id -g) $HOME/.kube/config

   Install a pod network (e.g., Flannel):

   kubectl apply -f https://raw.githubusercontent.com/flannel-io/flannel/master/Documentation/kube-flannel.yml

   (For production, you may choose a more robust CNI & multi-node). Once the cluster is up, ensure kubectl get nodes shows the node as Ready.

2. Install Helm

   On your Ubuntu VPS (or whichever machine you’ll manage helm from):

   curl https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 | bash helm version

   You should see Helm v3.x. Also add any necessary Helm repositories if needed (we’ll do that below).

3. Add the Flowise Helm chart repository

   According to the Helm chart metadata: the chart is available under the cowboysysop repo (and other repos).
   Run:

   helm repo add cowboysysop https://cowboysysop.github.io/charts/ helm repo update

   You can verify by:

   helm search repo cowboysysop/flowise

   You should see chart details (versions, etc).

4. Create a namespace & override values for production

   It’s good practice to isolate Flowise in its own namespace.

   kubectl create namespace flowise
   

   Then prepare a values.yaml to override defaults for your deployment. Create a file flowise-values.yaml with contents such as:

   replicaCount: 1
   image:
   repository: flowiseai/flowise
   tag: latest
   # Database settings: for production you should use PostgreSQL (not sqlite)
   database:
   type: postgres
   host: 
   port: 5432
   username: flowise
   password: 
   database: flowisedb
   persistence:
   enabled: true
   storageClass: 
   accessModes:
   - ReadWriteOnce
   size: 10Gi
   ingress:
   enabled: true
   hosts:
   - host: flowise.example.com
   paths: ["/"]
   tls:
   - secretName: flowise-tls
   hosts:
   - flowise.example.com
   # Optional resources
   resources:
   requests:
   cpu: "500m"
   memory: "1Gi"
   limits:
   cpu: "1"
   memory: "2Gi"
   

   Notes:

   • The official docs recommend using PostgreSQL instead of SQLite for production.
   • Enable persistence so your flows survive pod restarts.
   • Configure an Ingress (or LoadBalancer) if you want external access.
   • Adjust resource requests/limits based on your VPS.

5. Install the Helm chart

   With your namespace and values in place, run:

   helm install flowise cowboysysop/flowise \ --namespace flowise \ -f flowise-values.yaml

   This will deploy Flowise into your cluster. You can check status:

   kubectl get pods -n flowise kubectl get svc -n flowise

   Wait until the pods are in Running and the service is available.

6. Verify external access

   If you set up Ingress with a domain (e.g., flowise.example.com), ensure DNS points to your LoadBalancer/Ingress IP. Visit https://flowise.example.com (or http:// depending on your setup) in your browser. You should see Flowise UI. If you didn’t set Ingress and only internal access: you can port-forward:

   kubectl port-forward svc/flowise -n flowise 3000:3000

   Then open http://localhost:3000.

7. Post-deployment configuration & production tweaks

   • In the Flowise UI or via .env (depending on chart), set admin username/password (or via Helm values).
   • Enable persistent storage for files (logs, uploads). See Flowise docs on Storage.
   • For high-traffic / production: consider multiple replicas, worker nodes, autoscaling.
   • Configure backup for your PostgreSQL database.
   • Secure your cluster: enable RBAC, network policies, TLS.
   • Monitor logs via kubectl logs or integrate with a logging stack.
   • Set up proper resource limits, liveness/readiness probes (many Helm charts include these).
   • Ensure you pin image tags (not always “latest”) to avoid unexpected changes.

8. Upgrade / maintain the deployment

   When a new version of the chart is released:

   helm repo update helm upgrade flowise cowboysysop/flowise \ --namespace flowise -f flowise-values.yaml

   Follow chart CHANGELOG and ensure cluster compatibility (Kubernetes version must meet minimum).
   Also test on staging before production.

9. (Optional) Scaling / Workers / Queue mode

   Flowise supports a “Queue mode” for production (queue workers, etc).
   You may configure additional worker pods in your values.yaml, e.g.:

   worker: enabled: true replicaCount: 2 resources: requests: cpu: "1" memory: "2Gi" limits: cpu: "2" memory: "4Gi"

   Check the chart documentation for exact values supported. Also ensure you have message queue infrastructure (if required) and configure accordingly.

10. Clean-up (if needed)

    If you ever want to remove the deployment:

    helm uninstall flowise --namespace flowise kubectl delete namespace flowise

    Also delete any persistent volumes, storage classes, and database if you created them for this setup.

Summary

You now have a deployment plan:

• Set up Kubernetes → Install Helm → Add Flowise chart repo → Create namespace + values override → Install chart → Configure and access → Maintain & scale.
  This setup gives you a self-hosted Flowise on your Ubuntu VPS + K8s cluster, managed via Helm.

Here’s a production-ready values.yaml template for deploying FlowiseAI on Kubernetes via Helm — tuned for a typical Ubuntu VPS or small cluster.

It includes configuration for PostgreSQL, persistent storage, Ingress with TLS, environment variables, autoscaling, and worker queue mode.

# values.yaml for FlowiseAI (Helm)
# =====================================
# Customize values before installing with:
# helm install flowise cowboysysop/flowise -n flowise -f values.yaml
replicaCount: 1
image:
repository: flowiseai/flowise
tag: "latest"      # use a fixed version for production (e.g. "2.0.1")
pullPolicy: IfNotPresent
imagePullSecrets: []
nameOverride: ""
fullnameOverride: ""
serviceAccount:
create: true
annotations: {}
name: ""
podAnnotations: {}
podLabels: {}
podSecurityContext: {}
securityContext: {}
service:
type: ClusterIP
port: 3000
# ────────────────────────────────
# Persistent Storage Configuration
# ────────────────────────────────
persistence:
enabled: true
existingClaim: ""
storageClass: "standard"   # Use your storage class name
accessModes:
- ReadWriteOnce
size: 10Gi
# ────────────────────────────────
# Environment Variables / App Config
# ────────────────────────────────
env:
- name: FLOWISE_USERNAME
value: "admin"
- name: FLOWISE_PASSWORD
value: "ChangeMe123!"
- name: FLOWISE_PORT
value: "3000"
- name: FLOWISE_FILE_SIZE_LIMIT
value: "20mb"
# Database (PostgreSQL recommended for production)
- name: DATABASE_TYPE
value: "postgres"
- name: DATABASE_HOST
value: "postgresql.default.svc.cluster.local"
- name: DATABASE_PORT
value: "5432"
- name: DATABASE_USER
valueFrom:
secretKeyRef:
name: flowise-db-secret
key: postgres-username
- name: DATABASE_PASSWORD
valueFrom:
secretKeyRef:
name: flowise-db-secret
key: postgres-password
- name: DATABASE_NAME
value: "flowisedb"
# Optional base URL (helpful when running behind reverse proxy)
- name: FLOWISE_BASE_URL
value: "https://flowise.example.com"
# ────────────────────────────────
# PostgreSQL External / Subchart Configuration
# ────────────────────────────────
postgresql:
enabled: true
image:
tag: "15"
auth:
username: flowise
password: ChangeMePG!
database: flowisedb
primary:
persistence:
enabled: true
size: 5Gi
# ────────────────────────────────
# Ingress Configuration
# ────────────────────────────────
ingress:
enabled: true
className: "nginx"
annotations:
kubernetes.io/ingress.class: nginx
cert-manager.io/cluster-issuer: "letsencrypt-prod"
hosts:
- host: flowise.example.com
paths:
- path: /
pathType: Prefix
tls:
- secretName: flowise-tls
hosts:
- flowise.example.com
# ────────────────────────────────
# Resources / Limits
# ────────────────────────────────
resources:
requests:
cpu: "500m"
memory: "1Gi"
limits:
cpu: "1"
memory: "2Gi"
# ────────────────────────────────
# Autoscaling (HorizontalPodAutoscaler)
# ────────────────────────────────
autoscaling:
enabled: false
minReplicas: 1
maxReplicas: 3
targetCPUUtilizationPercentage: 80
targetMemoryUtilizationPercentage: 80
# ────────────────────────────────
# Worker Queue Mode (Optional)
# ────────────────────────────────
worker:
enabled: false
replicaCount: 2
resources:
requests:
cpu: "1"
memory: "2Gi"
limits:
cpu: "2"
memory: "4Gi"
# ────────────────────────────────
# Node / Scheduling Preferences
# ────────────────────────────────
nodeSelector: {}
tolerations: []
affinity: {}

🔐 Create a Secret for PostgreSQL credentials

Before installing, create the secret referenced in the values.yaml:

kubectl create secret generic flowise-db-secret \
--namespace flowise \
--from-literal=postgres-username=flowise \
--from-literal=postgres-password='ChangeMePG!'

🚀 Deploy Flowise with Helm

helm repo add cowboysysop https://cowboysysop.github.io/charts/
helm repo update
kubectl create namespace flowise
helm install flowise cowboysysop/flowise -n flowise -f values.yaml

Check progress:

kubectl get pods -n flowise
kubectl get svc -n flowise

Once pods are running and Ingress is configured, access via:

https://flowise.example.com

Single-Node Cluster

Below is a ready-to-deploy values-k3s.yaml designed for MicroK8s or k3s single-node Kubernetes environments on Ubuntu VPS.

It auto-uses the built-in local-path storage, NodePort networking, and SQLite persistence for a smooth, self-contained FlowiseAI deployment.

🧩 values-k3s.yaml

# FlowiseAI Helm configuration for single-node k3s or MicroK8s clusters
# Tested on Ubuntu 22.04 LTS + k3s v1.30 / microk8s v1.30
replicaCount: 1
image:
repository: flowiseai/flowise
tag: "latest"
pullPolicy: IfNotPresent
serviceAccount:
create: true
service:
type: NodePort
port: 3000
nodePort: 31000   # Accessible at http://:31000
# ────────────────────────────────
# Storage
# ────────────────────────────────
# k3s and microk8s provide "local-path" as default storageClass
persistence:
enabled: true
storageClass: "local-path"
accessModes:
- ReadWriteOnce
size: 5Gi
annotations: {}
finalizers:
- kubernetes.io/pvc-protection
# ────────────────────────────────
# Environment Variables
# ────────────────────────────────
# SQLite for simplicity on single-node deployments
env:
- name: FLOWISE_USERNAME
value: "admin"
- name: FLOWISE_PASSWORD
value: "ChangeMe123!"
- name: FLOWISE_PORT
value: "3000"
- name: FLOWISE_FILE_SIZE_LIMIT
value: "20mb"
- name: DATABASE_TYPE
value: "sqlite"
- name: DATABASE_PATH
value: "/root/.flowise/database.sqlite"
- name: FLOWISE_BASE_URL
value: "http://:31000"  # Optional but recommended for API consistency
# ────────────────────────────────
# Resource Allocation
# ────────────────────────────────
resources:
requests:
cpu: "500m"
memory: "512Mi"
limits:
cpu: "1"
memory: "1Gi"
# ────────────────────────────────
# Simplify single-node
# ────────────────────────────────
autoscaling:
enabled: false
worker:
enabled: false
ingress:
enabled: false
nodeSelector: {}
tolerations: []
affinity: {}

🚀 Deployment Instructions

1. 1️⃣ Install k3s or MicroK8s

   Option A — k3s (lightweight Kubernetes):

   curl -sfL https://get.k3s.io | sh - sudo k3s kubectl get nodes

   Option B — MicroK8s (Canonical):

   sudo snap install microk8s --classic sudo microk8s status --wait-ready sudo microk8s enable dns storage alias kubectl='microk8s kubectl'

2. 2️⃣ Install Helm

   curl https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 | bash helm version

3. 3️⃣ Deploy Flowise

   kubectl create namespace flowise helm repo add cowboysysop https://cowboysysop.github.io/charts/ helm repo update helm install flowise cowboysysop/flowise -n flowise -f values-k3s.yaml

   Wait until pod is running:

   kubectl get pods -n flowise

4. 4️⃣ Access Flowise

   Once ready, access:

   http://:31000

   Login with:

   Username: admin Password: ChangeMe123!

5. 🧰 (Optional) Enable HTTPS Reverse Proxy with Caddy

   sudo apt install caddy -y sudo nano /etc/caddy/Caddyfile

   Add:

   flowise.example.com { reverse_proxy 127.0.0.1:31000 }

   Then:

   sudo systemctl restart caddy

   Your FlowiseAI instance will be available securely at:

   https://flowise.example.com

Conclusion

You now know how to deploy Flowise + Kubernetes + Helm on Ubuntu VPS.