Activepieces on VPS: installation, configuration, and maintenance

Activepieces can be installed on a VPS using Docker/Docker Compose, providing flexibility in setup, scaling, and full control over workflow automation, starting with a VPS with 2 vCPU, 4 GB RAM, and a 50 GB NVMe disk for basic tasks.

What is Activepieces and why install Activepieces on a VPS?

Activepieces is a powerful open-source workflow automation platform designed to connect various applications and services without writing code. It allows you to create complex automations (called "flows") by linking triggers and actions between hundreds of popular SaaS applications, such as Slack, Trello, Gmail, Stripe, databases, and many more. Unlike proprietary solutions like Zapier or Make (formerly Integromat), Activepieces provides full transparency and control over your data and automation logic.

Installing Activepieces on a VPS offers several significant advantages, especially for developers, system administrators, and companies that prioritize security, data privacy, and deep customization. Self-hosting Activepieces allows you to host all your automations on your own server, bypassing third-party cloud services, which is critical for sensitive data or specific infrastructure requirements.

Advantages of Activepieces self-hosted

• Full Data Control: All data passing through your automations remains on your server. This is critical for compliance with GDPR, HIPAA, and other regulatory requirements.
• Cost Savings: As the number of automations and tasks grows, the cost of using cloud alternatives can increase significantly. Activepieces on a VPS often proves to be a more economical solution in the long run, especially for high volumes of operations.
• Scalability and Performance: You can independently choose the VPS configuration that matches your needs. If the load grows, you can easily upgrade your VPS to a more powerful plan.
• Customization: Activepieces' open-source nature allows you to modify the platform, add your own connectors (pieces), and integrate it with internal systems, which is not possible with proprietary services.
• Vendor Independence: You are not tied to the pricing policies or functionality changes of third-party providers.
• Security: You control the entire infrastructure, applying your own security policies, firewalls, and monitoring systems.

Comparison with other automation platforms

The market offers numerous automation tools, both cloud-based and self-hosted. Activepieces occupies a niche between fully cloud solutions like Zapier, Make, and more low-level automation tools such as Windmill on VPS or Node-RED on VPS.

• Zapier / Make: Cloud-based, easy to use, but expensive, have task limits, and do not provide full control over data and infrastructure. Activepieces is a direct self-hosted alternative.
• Windmill: Also an open-source automation platform, often geared towards more complex scenarios involving Python/TypeScript scripts. Activepieces focuses more on a "no-code" approach with a wide range of ready-made connectors.
• Node-RED: A low-level tool requiring more technical knowledge to create flows. Excellent for IoT and specific integrations, but less versatile for business automations than Activepieces.

Choosing Activepieces for installation on your own VPS is a strategic decision for those seeking a balance between ease of use, power, and full control over their automation.

System Requirements for Activepieces on a Server: Which VPS to Choose?

Choosing the right VPS for Activepieces is a key factor for the stable and productive operation of your automation platform. Activepieces, like any application running via Docker, has its own resource requirements. These requirements depend on the expected load: the number of active "flows", their execution frequency, the complexity of integrations, and the volume of data processed.

Activepieces' official recommendations for self-hosting involve using Docker and Docker Compose. The main components that consume resources are: PostgreSQL database, Redis for caching and queues, and the Activepieces service itself (API, Worker, Frontend).

Minimum and Recommended Configurations

For small projects or testing Activepieces on a server, modest resources may suffice, but a more powerful VPS will be required for a production environment with active automations.

• Minimum Configuration (for testing or very light load, up to 5-10 active "flows" with infrequent runs):
  • Processor: 1 vCPU (2.0 GHz+)
  • RAM: 2 GB RAM
  • Disk: 30-40 GB NVMe SSD (for better database performance)
  • Operating System: Ubuntu 22.04 LTS (recommended) or another modern Linux system.
  • Bandwidth: 100 Mbps
• Recommended Configuration (for production environment, up to 50-100 active "flows" with moderate run frequency):
  • Processor: 2 vCPU (2.5 GHz+)
  • RAM: 4 GB RAM
  • Disk: 50-80 GB NVMe SSD
  • Operating System: Ubuntu 22.04 LTS
  • Bandwidth: 200-500 Mbps
• High-Load Configuration (for intensive use, hundreds of "flows", thousands of runs per day):
  • Processor: 4+ vCPU (3.0 GHz+)
  • RAM: 8-16 GB RAM
  • Disk: 100+ GB NVMe SSD
  • Operating System: Ubuntu 22.04 LTS
  • Bandwidth: 1 Gbps

Important: NVMe SSDs significantly improve database performance (PostgreSQL, Redis), which is critical for Activepieces, as all data about "flows", tasks, and their statuses are stored in the DB. HDDs or regular SATA SSDs can become a bottleneck.

Impact of Load on VPS Selection

The load on Activepieces is determined by several factors:

• Number of active "flows": The more automations running concurrently, the more resources are required.
• Frequency of "flow" execution: "Flows" that run every minute consume more resources than those that run once an hour or on an event.
• Complexity of "flows": "Flows" with many steps, complex logic (e.g., processing large volumes of data, loops, conditional branching) require more CPU and RAM.
• Integrations: Some integrations (e.g., with file storage, image processing) can be more resource-intensive.
• Number of users: Although Activepieces primarily operates in the background, active use of the web interface by multiple users can increase the load on the API and Frontend.

Considering these factors, it's always better to choose a VPS with a slight resource overhead to avoid performance issues in the future. Valebyte.com offers various VPS plans that are ideal for deploying Activepieces, ensuring high performance and reliability thanks to NVMe disks and modern processors.

Usage Scenario	vCPU	RAM	Disk (NVMe SSD)	Approx. VPS Cost/month
Testing / Development	1	2 GB	30 GB	from $7
Small Business / Personal Use (up to 50 flows)	2	4 GB	50 GB	from $15
Medium Business / Active Use (up to 200 flows)	4	8 GB	100 GB	from $30
Large Business / High Load (200+ flows)	6+	16+ GB	200+ GB	from $60

Preparing Your VPS for Activepieces Docker Installation

Before proceeding with Activepieces installation, you need to prepare your VPS. This step includes updating the operating system, installing necessary packages, and, of course, installing Docker and Docker Compose, which are the foundation for Activepieces deployment.

For demonstration purposes, we will use Ubuntu 22.04 LTS, as it is one of the most popular and stable operating systems for servers.

System Update and Installation of Necessary Packages

The first step should always be to update your system. This ensures that you have the latest security patches and up-to-date package versions installed.

Connect to your VPS via SSH and execute the following commands:

sudo apt update
sudo apt upgrade -y
sudo apt autoremove -y

These commands will update package lists, install all available updates, and remove unnecessary packages. Then, install a few useful utilities that might come in handy:

sudo apt install -y curl wget git vim htop

curl and wget are needed for downloading files, git for cloning repositories (though not strictly necessary for Activepieces, it's useful), vim or nano for editing text files, and htop for monitoring system resources.

Installing Docker and Docker Compose

Activepieces is recommended to be installed using Docker and Docker Compose. Docker allows applications to run in isolated containers, and Docker Compose simplifies the management of multi-container Docker applications.

1. Install Docker Engine:

To install Docker on Ubuntu, it is recommended to use the official script:

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

This script will install the latest stable version of Docker Engine, containerd, and Docker Compose.

2. Add user to Docker group:

After installing Docker, by default, Docker commands can only be executed with root privileges or by a user in the docker group. Add your current user (e.g., your_username) to the docker group to avoid using sudo every time:

sudo usermod -aG docker your_username

Replace your_username with your actual username. To apply the changes, you need to log out of your SSH session and log back in, or restart the VPS.

3. Verify Docker installation:

Ensure Docker is installed and running correctly:

docker run hello-world

You should see the message "Hello from Docker!".

4. Verify Docker Compose installation:

Docker Compose is usually installed along with the Docker script. Check its version:

docker compose version

You should see the Docker Compose version (e.g., Docker Compose version v2.x.x).

Your VPS is now fully prepared for Activepieces deployment.

Step-by-Step Activepieces Installation on VPS via Docker Compose

After preparing the VPS, we can proceed with the direct installation of Activepieces on the VPS. We will use Docker Compose, which significantly simplifies the deployment process for all necessary components: Activepieces, PostgreSQL, and Redis.

Creating the docker-compose.yml file for Activepieces

First, create a directory for Activepieces and navigate into it:

mkdir activepieces
cd activepieces

Next, create the docker-compose.yml file. This is the main configuration file that describes the services, networks, and volumes for your application. Use a text editor, such as nano or vim:

nano docker-compose.yml

Paste the following content into the file. This is the standard Activepieces configuration, which includes three main services: activepieces (the main application), redis (for caching and queues), and postgres (for data storage).

version: "3.8"

services:
  activepieces:
    image: activepieces/activepieces:latest
    container_name: activepieces
    restart: always
    ports:
      - "80:80" # Here 80 is the port Activepieces will be accessible on your VPS. Can be changed.
    environment:
      # Database settings
      AP_DB_TYPE: POSTGRES
      AP_POSTGRES_HOST: postgres
      AP_POSTGRES_PORT: 5432
      AP_POSTGRES_USERNAME: activepieces
      AP_POSTGRES_PASSWORD: ${AP_POSTGRES_PASSWORD} # Will be taken from .env file
      AP_POSTGRES_DATABASE: activepieces
      # Redis settings
      AP_REDIS_URL: redis://redis:6379
      # JWT settings
      AP_JWT_SECRET: ${AP_JWT_SECRET} # Will be taken from .env file
      # URL of your Activepieces installation (for callbacks and API)
      AP_FRONTEND_URL: ${AP_FRONTEND_URL} # E.g., https://activepieces.yourdomain.com
      AP_PIECES_SOURCE_URL: https://cdn.activepieces.com/pieces
      # Settings for S3-compatible storage (for large data, logs)
      # If not using S3, data will be stored locally in the container (less reliable)
      # AP_STORAGE_METHOD: S3
      # AP_S3_REGION: us-east-1
      # AP_S3_BUCKET: your-activepieces-bucket
      # AP_S3_ACCESS_KEY_ID: your-access-key
      # AP_S3_SECRET_ACCESS_KEY: your-secret-key
      # Logging settings
      AP_LOG_LEVEL: INFO
      # Additional settings
      AP_WORKER_URL: http://activepieces:80/api/v1/worker-webhook
    volumes:
      - activepieces_data:/app/server/dist/data # For local storage, if S3 is not used

  postgres:
    image: postgres:15-alpine
    container_name: activepieces_postgres
    restart: always
    environment:
      POSTGRES_USER: activepieces
      POSTGRES_PASSWORD: ${AP_POSTGRES_PASSWORD}
      POSTGRES_DB: activepieces
    volumes:
      - postgres_data:/var/lib/postgresql/data

  redis:
    image: redis:7-alpine
    container_name: activepieces_redis
    restart: always
    volumes:
      - redis_data:/data

volumes:
  activepieces_data:
  postgres_data:
  redis_data:

Save the file (Ctrl+O, Enter, Ctrl+X for nano).

Creating the .env file:

To store sensitive data such as passwords and secret keys, create a .env file in the same directory:

nano .env

Add the following variables to it:

AP_POSTGRES_PASSWORD=your_strong_postgres_password
AP_JWT_SECRET=your_long_random_jwt_secret_key
AP_FRONTEND_URL=http://your_domain_or_ip # Or https://your_domain.com after HTTPS setup

Important:

• Replace your_strong_postgres_password with a strong password.
• Replace your_long_random_jwt_secret_key with a long, random string (minimum 32 characters). You can generate one, for example, using the command openssl rand -base64 32.
• AP_FRONTEND_URL must match the URL you plan to use to access Activepieces. If you are using a domain with HTTPS, specify it here. For initial testing, you can use your VPS's IP address.

Save the .env file.

Starting Activepieces and Initial Setup

Now that you have docker-compose.yml and .env, you can start Activepieces. Execute the command in the activepieces directory:

docker compose up -d

This command will download Docker images, create, and start all services in the background (-d). The process may take several minutes, especially on the first run, as Docker will be downloading images.

Checking container status:

docker compose ps

You should see that all three containers (activepieces, activepieces_postgres, activepieces_redis) are in the running status.

Accessing Activepieces:

After a successful launch, you will be able to access the Activepieces web interface by navigating to http://your_vps_ip (or http://your_domain if you have configured DNS) in your browser. Upon first access, you will be prompted to create an administrator account.

Congratulations! You have successfully installed Activepieces on your VPS. The next step is to configure secure access using a domain name and HTTPS.

Setting up Reverse Proxy (Nginx/Caddy) and HTTPS for Activepieces self-hosted

Once Activepieces is running on your VPS, it is crucial to set up a reverse proxy and HTTPS. This will ensure a secure connection, allow you to use a domain name instead of an IP address, and manage traffic. We will cover two popular options: Nginx and Caddy.

Prerequisites:

1. Domain Name: Ensure you have a domain name (e.g., activepieces.yourdomain.com) and its A-record points to your VPS's IP address.
2. Close Direct Activepieces Port: Change the Activepieces port in docker-compose.yml from "80:80" to "127.0.0.1:8080:80" (or any other internal port). This will make Activepieces accessible only from the local host, and all external traffic will pass through the reverse proxy. After making the change, run docker compose down, then docker compose up -d.
3. Update AP_FRONTEND_URL: Make sure to update the AP_FRONTEND_URL variable in the .env file to your domain with HTTPS (e.g., https://activepieces.yourdomain.com). Restart the containers afterward.

Nginx Configuration as a Reverse Proxy

Nginx is a high-performance web server that also excels as a reverse proxy. To use Nginx, you will need to install and configure it.

1. Install Nginx:

sudo apt install -y nginx

2. Configure Nginx:

Create a new configuration file for your Activepieces domain. For example, /etc/nginx/sites-available/activepieces.conf:

sudo nano /etc/nginx/sites-available/activepieces.conf

Paste the following content, replacing activepieces.yourdomain.com with your actual domain:

server {
    listen 80;
    server_name activepieces.yourdomain.com;

    location / {
        proxy_pass http://127.0.0.1:8080; # Port on which Activepieces listens locally
        proxy_set_header Host $host;
        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;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_read_timeout 86400; # Increase timeout for long-running operations
    }
}

3. Activate configuration:

Create a symbolic link to the file in sites-enabled and test the Nginx configuration:

sudo ln -s /etc/nginx/sites-available/activepieces.conf /etc/nginx/sites-enabled/
sudo nginx -t

If there are no errors, restart Nginx:

sudo systemctl restart nginx

4. Configure HTTPS with Certbot:

To obtain free SSL/TLS certificates from Let's Encrypt, use Certbot. Install it:

sudo apt install -y certbot python3-certbot-nginx

Then, obtain and install the certificate:

sudo certbot --nginx -d activepieces.yourdomain.com

Certbot will automatically modify your Nginx configuration to use HTTPS and set up automatic certificate renewal. After this, your Activepieces will be accessible via https://activepieces.yourdomain.com.

Using Caddy for Simplified HTTPS Setup

Caddy is a modern web server that automatically manages Let's Encrypt HTTPS certificates, significantly simplifying setup. It's an excellent choice if you want to avoid manual Nginx and Certbot configuration.

1. Install Caddy:

Install Caddy by following the instructions on the official website, or use the repository:

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

2. Configure Caddyfile:

Create or edit the /etc/caddy/Caddyfile file:

sudo nano /etc/caddy/Caddyfile

Remove all existing content and paste the following, replacing activepieces.yourdomain.com with your domain:

activepieces.yourdomain.com {
    reverse_proxy 127.0.0.1:8080 # Port on which Activepieces listens locally
    header {
        Strict-Transport-Security max-age=31536000;
    }
}

Caddy will automatically obtain an SSL certificate and configure HTTPS for your domain.

3. Restart Caddy:

sudo systemctl restart caddy
sudo systemctl enable caddy

Now your Activepieces is accessible via https://activepieces.yourdomain.com, and Caddy will automatically manage certificates.

The choice between Nginx and Caddy depends on your preferences and experience. Nginx is more flexible but requires more manual configuration. Caddy is simpler to use and excellent for quick HTTPS setup.

Maintaining Activepieces on a Server: Backups, Updates, and Monitoring

Regular maintenance of Activepieces on a server is key to the stability, security, and currency of your automation platform. This includes backup strategies, update procedures, and continuous resource monitoring.

Activepieces Data Backup Strategies

Activepieces data includes "flow" configurations, execution history, user information, and connections. Loss of this data can be catastrophic. Therefore, a reliable backup strategy is crucial.

The main Activepieces data is stored in the PostgreSQL database. If you use S3-compatible storage for large files (as an option in docker-compose.yml), then this data will be there. Otherwise, it is stored in the activepieces_data volume.

Recommended backup approach:

1. PostgreSQL Database Backup: This is the most critical component. You can use the pg_dump command from within the PostgreSQL container.
2. Configuration Files Backup: Save your docker-compose.yml and .env files.
3. Docker Volumes Backup: If you are not using S3, the activepieces_data, postgres_data, and redis_data volumes also require backup.

Example backup script (PostgreSQL):

Create the script backup_activepieces.sh:

#!/bin/bash

BACKUP_DIR="/var/backups/activepieces"
DATE=$(date +%Y%m%d%H%M%S)
DB_CONTAINER="activepieces_postgres" # PostgreSQL container name
DB_USER="activepieces"
DB_NAME="activepieces"
ENV_FILE="/path/to/your/activepieces/.env" # Path to your .env file

# Create backup directory if it doesn't exist
mkdir -p $BACKUP_DIR

# Load password from .env file
if [ -f "$ENV_FILE" ]; then
    source "$ENV_FILE"
else
    echo "Error: .env file not found at $ENV_FILE"
    exit 1
fi

# PostgreSQL backup
echo "Creating PostgreSQL backup..."
docker exec -e PGPASSWORD=$AP_POSTGRES_PASSWORD $DB_CONTAINER pg_dump -U $DB_USER -d $DB_NAME > $BACKUP_DIR/activepieces_db_backup_$DATE.sql

if [ $? -eq 0 ]; then
    echo "PostgreSQL backup successfully created: $BACKUP_DIR/activepieces_db_backup_$DATE.sql"
else
    echo "Error creating PostgreSQL backup."
fi

# Backup Docker Compose files
cp /path/to/your/activepieces/docker-compose.yml $BACKUP_DIR/docker-compose_$DATE.yml
cp /path/to/your/activepieces/.env $BACKUP_DIR/.env_$DATE

# Clean up old backups (e.g., keep last 7 days)
find $BACKUP_DIR -type f -name "activepieces_db_backup_*.sql" -mtime +7 -delete
find $BACKUP_DIR -type f -name "docker-compose_*.yml" -mtime +7 -delete
find $BACKUP_DIR -type f -name ".env_*.env" -mtime +7 -delete

echo "Backup complete."

Replace /path/to/your/activepieces/ with the actual path to your Activepieces directory. Make the script executable (chmod +x backup_activepieces.sh) and add it to cron for daily execution.

For a more comprehensive backup approach, including Docker volumes, you might consider tools like Restic on VPS, which allows you to efficiently create incremental backups and store them in various cloud storage solutions.

Updating Activepieces Docker Containers

Updating Activepieces to the latest version usually involves updating Docker images and restarting containers. Before updating, it is always recommended to perform a backup.

cd /path/to/your/activepieces/ # Navigate to the directory containing docker-compose.yml
docker compose pull activepieces # Download the latest Activepieces image
docker compose down # Stop current containers
docker compose up -d # Start containers with new images

Database migrations may sometimes be required. Activepieces usually handles them automatically when a new image is launched, but always check the official documentation for specific instructions regarding major updates.

Monitoring VPS Resources and Activepieces Logs

Regular monitoring helps identify performance issues or errors before they become critical.

Monitoring VPS resources:

• htop: For interactive monitoring of CPU, RAM, and processes.
• docker stats: Shows resource usage (CPU, RAM, network, disk) by all running Docker containers.
• df -h: Check free disk space.
• free -h: Check RAM usage.

Monitoring Activepieces logs:

Activepieces container logs contain important information about errors and "flow" operations.

docker compose logs -f activepieces # View Activepieces logs in real-time
docker compose logs activepieces # View all Activepieces logs

Pay attention to error messages or warnings that may indicate issues with integrations or configuration.

Implementing these maintenance practices will ensure the long-term stability and reliability of your Activepieces installation on a VPS.

Optimal VPS Configuration for Activepieces under Real-World Load

Choosing the optimal VPS configuration for Activepieces under real-world load is not a static decision but a process that requires understanding your workflow and potential growth. The right choice will ensure not only stability but also cost-effectiveness.

Factors Affecting Performance

Activepieces performance directly depends on several key aspects:

• Number of concurrently executing "flows": Each active "flow" consumes a portion of CPU time and RAM. If you have hundreds of "flows" running simultaneously or with very high frequency, this will create a significant load.
• Complexity of "flows": "Flows" that perform complex operations (e.g., processing large data arrays, multi-step transformations, long waits for responses from external APIs) require more resources.
• I/O Intensity: The PostgreSQL database and Redis actively use the disk subsystem. High frequency of data writes/reads (e.g., when saving logs of thousands of tasks) requires fast NVMe SSDs.
• Network Requests: Activepieces constantly interacts with external APIs. While this is usually not a bottleneck for the VPS itself, a stable and fast network connection is necessary.

For example, if your "flow" checks incoming emails and processes attachments every minute, this will create a constant but relatively small load. However, if a "flow" runs once an hour but downloads and processes gigabytes of data from cloud storage, the peak load will be significantly higher, requiring more RAM and CPU for a short period.

Scaling Recommendations

Scaling Activepieces can be both vertical (increasing resources of the current VPS) and horizontal (adding new servers, which is more complex and requires cluster solutions).

For most scenarios, especially in the initial stages, vertical scaling is sufficient:

1. Start with a buffer: Even if you expect a small load, start with the configuration recommended for small businesses (2 vCPU, 4 GB RAM, 50 GB NVMe). This will give you a buffer for growth and testing.
2. Resource Monitoring: Continuously monitor CPU, RAM, and disk usage. If the CPU is consistently at 80-90% utilization or RAM runs out, it's a clear signal to upgrade. Use htop and docker stats for this.
3. Optimize "flows": Review your automations. Perhaps some of them can be simplified, their run frequency reduced, or resource-intensive parts moved to separate services.
4. Database Separation: For very high loads, consider moving PostgreSQL and/or Redis to separate VPS instances or managed database services. This reduces the load on the main Activepieces VPS.
5. Use S3-compatible storage: If your "flows" handle many files or large data volumes, configure Activepieces to use external S3-compatible storage (e.g., MinIO on another VPS or cloud S3). This will offload the local VPS disk.

Recommendations for Choosing a VPS for Activepieces

1. Prioritize NVMe SSD: Disk speed is critical for PostgreSQL and Redis. Always choose a VPS with NVMe SSD.
2. Balance of CPU and RAM: For Activepieces, balance is important. Too much CPU with insufficient RAM (or vice versa) will lead to inefficient resource utilization.
3. Reliable Provider: Choose a provider with a good reputation, such as Valebyte.com, which offers stable VPS with fast technical support and flexible pricing plans.
4. Server Location: Choose a data center located closer to your target audience or to the APIs you interact with most frequently to minimize latency.
5. Plan Scalability: Ensure that your pricing plan can be easily upgraded to a more powerful one without reinstalling the system.
6. Backup: Clarify whether the provider offers automatic VPS backup services, or plan your own backup strategy as discussed earlier.

Remember that the best VPS for Activepieces is one that meets your current needs, has room for future growth, and is economically viable.

Conclusion

Installing Activepieces on a VPS via Docker Compose provides full control over your automation, high performance, and flexibility in scaling, making it an ideal choice for companies and developers who value security and independence. For stable Activepieces operation under load, we recommend choosing a VPS with at least 2 vCPU, 4 GB RAM, and a fast NVMe SSD, as well as carefully configuring backups and monitoring.