Trilium on VPS: installation, configuration, and maintenance

Installing Trilium on a VPS allows you to create a powerful, self-sufficient knowledge base or note management system with full control over your data, providing flexible customization and high performance through the use of Docker/Docker Compose, a reverse proxy, and regular backups.

What is Trilium Notes and why host it on a VPS?

Trilium Notes is a feature-rich, hierarchical, open-source note-taking application that allows users to organize information in a tree-like structure. Unlike many cloud solutions, Trilium is designed for self-hosting, giving you complete control over your data, security, and performance. Hosting Trilium on a VPS (Virtual Private Server) is an ideal solution for those seeking a balance between accessibility, power, and privacy.

More about Trilium Notes

Trilium Notes offers an impressive set of features that make it a powerful information management tool:

• Hierarchical structure: Notes are organized in a tree, allowing you to create complex knowledge structures with unlimited nesting depth.
• Advanced text editor: Supports Markdown, WYSIWYG editing, embedding images, files, tables, and code blocks with syntax highlighting.
• Scripting and automation: A built-in JavaScript engine allows you to create custom scripts for automating tasks, integrating with external services, and extending functionality.
• Note relationships: Ability to link notes, create clones, and set attributes for categorization and searching.
• Versioning and history: Automatic saving of each note's change history, allowing you to revert to previous versions.
• Encryption: Option to encrypt individual notes or entire subtrees to enhance the security of confidential information.
• Synchronization: Built-in synchronization between different Trilium instances, convenient for working from various devices.

Thanks to these capabilities, Trilium becomes an indispensable tool for developers, researchers, writers, and anyone who works with a large volume of information and needs structured storage and quick access.

Advantages of hosting Trilium on a VPS

When it comes to self-hosting, choosing a VPS for Trilium Notes offers several significant advantages compared to local installation or using third-party cloud services:

1. Full control over data: All your notes, attachments, and configurations are stored on your own server. This eliminates risks associated with privacy policies or potential data breaches from third-party providers. You decide where and how your data is stored.
2. 24/7 accessibility from anywhere in the world: Your server will be accessible online around the clock, allowing you to access your notes from any device with an internet connection, be it a computer, tablet, or smartphone.
3. Flexibility in configuration and scaling: You can configure the server to your needs, install necessary software, and optimize performance. As your knowledge base grows or the number of users increases, you can easily scale VPS resources (increase RAM, CPU, disk) without data migration.
4. High performance: Modern VPS servers, especially with NVMe drives, provide high database speed and responsive Trilium interface, which is critical for comfortable work with large volumes of data.
5. Privacy and security: You control server access, can configure a firewall, use VPN, and other security measures. This significantly reduces the likelihood of unauthorized access compared to public cloud solutions.
6. Cost-effectiveness: In the long run, self-hosting on a VPS can be more cost-effective than paying monthly subscriptions for cloud services, especially if you already have a VPS for other purposes.

Assessing System Requirements for Trilium Notes

Trilium Notes, being a Node.js application, is not extremely resource-intensive, but its demands can grow depending on the volume of your knowledge base, the number of attachments (images, files), the complexity of scripts, and the number of concurrently active users. Correctly assessing system requirements is critical to ensure stable and fast operation.

Minimum requirements for personal use (up to 10,000 notes)

For a single user or a small knowledge base, Trilium will run quite comfortably on basic VPS configurations:

• Processor (CPU): 1 vCPU with a clock speed of 2.0 GHz or higher. Modern single-core processors will handle most tasks.
• Random Access Memory (RAM): 1 GB. This amount will be sufficient to run Trilium and the operating system. However, if you plan to actively use attachments or scripts, 2 GB would be preferable.
• Disk space: 10-20 GB NVMe disk. Trilium stores its data in an SQLite database, and the speed of the disk subsystem directly affects application performance, especially when searching, opening large notes, or working with history. NVMe significantly outperforms regular SSDs and even more so HDDs in speed.
• Operating system: Ubuntu Server 22.04 LTS+, Debian 11+, CentOS Stream 9+. Any modern Linux distribution without a graphical interface.
• Network connection: 100 Mbps. For most scenarios, this is more than enough.

With these characteristics, the cost of a VPS can start from $5-7 per month with most providers.

Recommended configurations for active use and small teams (up to 50,000 notes, 2-5 users)

If you plan to use Trilium in a team, store a large number of attachments, actively use scripts, or simply want to have a performance reserve, you should consider a more powerful VPS:

• Processor (CPU): 2 vCPU. This will provide better multitasking and performance when several users work simultaneously or perform resource-intensive operations.
• Random Access Memory (RAM): 2-4 GB. More RAM will allow Trilium to cache more data, which will speed up access to frequently used notes and improve overall responsiveness.
• Disk space: 50+ GB NVMe disk. As the database grows, disk volume and speed become even more critical. NVMe will ensure minimal latency for database operations.
• Operating system: Ubuntu Server 22.04 LTS+, Debian 11+, CentOS Stream 9+.
• Network connection: 100 Mbps or 1 Gbps. For team collaboration or synchronizing large volumes of data, higher network speed will be an advantage.

The cost of such a VPS can range from $10-20 per month.

Important note: Although Trilium primarily uses a single CPU thread to process requests, having multiple cores is useful for background tasks, the operating system, and other processes such as Docker, reverse proxy, and monitoring.

Preparing your VPS for Trilium installation: basic steps

Before proceeding with Trilium installation, you need to prepare your VPS. These steps are standard for deploying most web applications and provide a stable and secure foundation for your system.

Choosing a provider and connecting via SSH

First, you will need an active VPS. Valebyte.com offers reliable and high-performance VPS servers with NVMe drives, which are ideal for applications like Trilium. After choosing a plan and deploying the server, you will receive an IP address, login (usually root), and password (or SSH key). To connect to the server, use an SSH client:

ssh root@YOUR_IP_ADDRESS

After the first login, it is recommended to create a new user with limited privileges and use it for daily work, as well as configure SSH key authentication for enhanced security.

Updating the system and installing necessary packages

Always start by updating your operating system. This ensures you have the latest security patches and package versions installed.

sudo apt update
sudo apt upgrade -y

Also, install a few useful utilities if they are not present by default:

sudo apt install curl wget git htop -y

Installing Docker and Docker Compose

We will use Docker and Docker Compose to install Trilium. This allows isolating the application from the main system, simplifies dependency management, and ensures portability. Containerization with Docker is a modern standard for deploying web applications.

Installing Docker Engine

To install Docker on Ubuntu/Debian, execute the following commands:

# Remove old versions of Docker (if any)
for pkg in docker.io docker-doc docker-compose docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin; do sudo apt remove $pkg; done

# Install necessary packages
sudo apt install ca-certificates curl gnupg -y

# Add Docker's official GPG key
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg

# Add the Docker repository
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" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# Update package list and install Docker Engine
sudo apt update
sudo apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin -y

Verifying Docker installation

Ensure that Docker is successfully installed and running:

sudo docker run hello-world

You should see a welcome message from Docker.

Adding a user to the docker group (optional, but recommended)

To avoid constantly using sudo when working with Docker, add your user to the docker group:

sudo usermod -aG docker $USER

Then log out of the SSH session and log in again for the changes to take effect. Now you can use docker commands without sudo.

Installing Trilium on a VPS with Docker Compose

Installing Trilium Notes using Docker Compose is the most recommended and convenient way to deploy the application on your VPS. It allows you to define all necessary services (Trilium, potentially a database, reverse proxy) and their configuration in a single YAML file, which significantly simplifies the management and scaling of your self-hosted application.

Creating the directory structure and docker-compose.yml file

First, let's create a directory for our Trilium project and navigate into it:

mkdir -p ~/trilium
cd ~/trilium

Then, create a docker-compose.yml file in this directory. This file will contain all the configuration for running Trilium.

nano docker-compose.yml

Paste the following content into the docker-compose.yml file:

version: '3.8'

services:
  trilium:
    image: zadam/trilium:0.62.2 # Specify the actual version
    container_name: trilium
    restart: unless-stopped
    ports:
      - "8080:8080" # Host port:Container port
    volumes:
      - ./data:/home/node/trilium-data # Store data outside the container
    environment:
      # - TRILIUM_DATA_DIR=/home/node/trilium-data # This is the path inside the container, specified in volumes
      - TRILIUM_PORT=8080 # The port Trilium listens on inside the container
      # - TRILIUM_URL_PATH= # If Trilium will be accessible via a subpath, e.g., /notes
      # - TRILIUM_PASSWORD=your_secure_password # Set a password for the first login if you want
      # - TRILIUM_DEBUG=true # Enable debug mode
      - TZ=Europe/Moscow # Set your timezone
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8080/"] # Health check
      interval: 30s
      timeout: 10s
      retries: 3

Let's break down each line of the configuration:

• version: '3.8': Specifies the version of the Docker Compose file format. It is recommended to use current versions.
• services:: Defines the services that will be launched. We currently have one service — trilium.
• image: zadam/trilium:0.62.2: Specifies the Docker image to be used. It is always recommended to use a specific version (e.g., 0.62.2) rather than latest to avoid unexpected updates. You can check the current version on Docker Hub or Trilium's GitHub page.
• container_name: trilium: Assigns a descriptive name to the container.
• restart: unless-stopped: The container will automatically restart if it stops for any reason (crash, server reboot), unless you stopped it manually.
• ports: - "8080:8080": Maps port 8080 from the container to port 8080 of the host machine. This means you can access Trilium at http://YOUR_IP_ADDRESS:8080. Later, we will configure a reverse proxy to use standard port 80/443 and a domain name.
• volumes: - ./data:/home/node/trilium-data: This is a very important line. It mounts the local directory ./data (relative to the current location of docker-compose.yml) to the /home/node/trilium-data directory inside the container. All Trilium data (database, attachments) will be stored in this directory on your VPS, ensuring their preservation even if the container is deleted or updated.
• environment:: Allows passing environment variables into the container.
  • TRILIUM_PORT=8080: Tells Trilium which port to listen on inside the container.
  • TZ=Europe/Moscow: Sets the timezone for the container. Replace with your own, for example, Asia/Yekaterinburg or America/New_York.
  • TRILIUM_PASSWORD=your_secure_password: (Optional) You can set an initial password for the "admin" user. If not specified, Trilium will prompt you to create one on first login. It is recommended not to use this option for the first launch, but to create the password via the web interface.
• healthcheck:: Defines how Docker will check the container's health.

Starting Trilium and first login

Save the docker-compose.yml file (Ctrl+O, Enter, Ctrl+X in nano). Now you are ready to start Trilium.

docker compose up -d

This command will perform the following actions:

1. Download the zadam/trilium Docker image if it's not available locally.
2. Create and start the trilium container in the background (-d flag, for "detached").
3. Create the ./data directory if it doesn't exist yet, and mount it.

You can check the status of the running container:

docker compose ps

The output should show that the trilium container is running (Up).

NAME                COMMAND                  SERVICE             STATUS              PORTS
trilium             "node ./src/main.js"     trilium             running (healthy)   0.0.0.0:8080->8080/tcp

Now open a web browser and go to http://YOUR_IP_ADDRESS:8080. You should see the Trilium Notes welcome page, where you will be prompted to create the first user and password. This is your first step towards creating your own knowledge base on a VPS.

Configuring Reverse Proxy and HTTPS for Trilium (Nginx and Caddy)

Direct access to Trilium via an IP address and port 8080 is not an optimal solution for long-term use. To ensure security, convenience, and a professional appearance for your knowledge base, you need to configure a reverse proxy with HTTPS support. The reverse proxy will accept all incoming requests on standard ports (80 for HTTP and 443 for HTTPS), forward them to your Trilium container, and manage SSL/TLS certificates.

In this section, we will cover configuring two popular reverse proxies: Nginx and Caddy.

Preliminary steps: domain name and DNS

Before configuring the reverse proxy, ensure that you have a domain name (e.g., notes.mydomain.com) and that its A record points to your VPS's IP address.

Configuring Nginx as a Reverse Proxy

Nginx is a powerful, high-performance web server often used as a reverse proxy. It will require manual configuration of SSL certificates using Certbot.

1. Installing Nginx

sudo apt install nginx -y

2. Creating an Nginx configuration file

Create a new configuration file for your domain. Replace notes.mydomain.com with your domain name.

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

Paste the following content:

server {
    listen 80;
    server_name notes.mydomain.com;

    location / {
        proxy_pass http://localhost:8080; # Forward to Trilium container port
        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;

        # WebSocket support for Trilium
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
    }
}

Save and close the file (Ctrl+O, Enter, Ctrl+X).

3. Activating Nginx configuration

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

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

If the syntax is okay (syntax is ok, test is successful), reload Nginx:

sudo systemctl reload nginx

Now you can access Trilium at http://notes.mydomain.com, but without HTTPS yet.

4. Configuring HTTPS with Certbot (Let's Encrypt)

Certbot automates obtaining and installing free SSL/TLS certificates from Let's Encrypt.

sudo apt install certbot python3-certbot-nginx -y
sudo certbot --nginx -d notes.mydomain.com

Follow Certbot's instructions. It will automatically modify your Nginx configuration to enable HTTPS and set up automatic certificate renewal. After successful completion, you will be able to access Trilium at https://notes.mydomain.com.

Configuring Caddy as a Reverse Proxy

Caddy is a modern web server with automatic HTTPS support (via Let's Encrypt or ZeroSSL), making it significantly easier to configure compared to Nginx + Certbot.

1. Installing Caddy

Follow the official Caddy installation instructions for your distribution. For Debian/Ubuntu:

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

2. Creating a Caddyfile

Caddy uses a configuration file called Caddyfile. Open it for editing:

sudo nano /etc/caddy/Caddyfile

Delete the existing content and paste the following, replacing notes.mydomain.com with your domain:

notes.mydomain.com {
    reverse_proxy localhost:8080 {
        # WebSocket support for Trilium
        header_up Upgrade {http.request.header.Upgrade}
        header_up Connection {http.request.header.Connection}
    }
}

Save and close the file.

3. Checking and starting Caddy

Check the Caddyfile syntax:

sudo caddy validate --config /etc/caddy/Caddyfile

If everything is in order, reload the Caddy service:

sudo systemctl reload caddy

Caddy will automatically obtain and configure an SSL certificate for your domain. Now you can access Trilium at https://notes.mydomain.com.

Regardless of whether you choose Nginx or Caddy, your Trilium server is now accessible via a secure HTTPS connection using a domain name, which significantly enhances convenience and security of use.

Ensuring Reliability: Backups and Updating Trilium Notes

The reliability of any self-hosted system is based on two pillars: regular backups and timely updates. For Trilium Notes, where your valuable information is stored, these aspects become paramount.

Trilium Notes Backup Strategies

Data loss is the worst-case scenario, which can be avoided with a well-thought-out backup strategy. Since Trilium data is stored in a Docker volume (in our case, in the ~/trilium/data directory on the VPS), backing up comes down to copying this directory.

1. Stopping Trilium before backup

To create a consistent backup of the SQLite database used by Trilium, it is recommended to stop the Trilium container during the data copying process. This ensures that the database is not actively being modified during the backup, preventing data corruption.

cd ~/trilium
docker compose stop trilium

2. Copying the data directory

After stopping the container, you can copy the data directory to a safe location. It is recommended to use a timestamp for each backup.

# Create a directory for backups if it doesn't exist
mkdir -p ~/trilium_backups

# Create an archive with the date
BACKUP_DATE=$(date +%Y%m%d_%H%M%S)
tar -czvf ~/trilium_backups/trilium_data_$BACKUP_DATE.tar.gz ~/trilium/data

3. Starting Trilium after backup

cd ~/trilium
docker compose start trilium

4. Automating backups with Cron

Manually performing backups is impractical. Use cron to automate this process. Create a script named backup_trilium.sh:

nano ~/trilium_backups/backup_trilium.sh

Paste the following content:

#!/bin/bash

# Directory where docker-compose.yml is located
TRILIUM_DIR="/root/trilium"
# Directory for storing backups
BACKUP_DIR="/root/trilium_backups"
# Backup file name
BACKUP_FILE="$BACKUP_DIR/trilium_data_$(date +%Y%m%d_%H%M%S).tar.gz"
# Trilium data directory inside TRILIUM_DIR
TRILIUM_DATA_PATH="$TRILIUM_DIR/data"

echo "Starting Trilium Notes backup..."

# Stop Trilium container
echo "Stopping Trilium container..."
docker compose -f "$TRILIUM_DIR/docker-compose.yml" stop trilium

# Create data archive
echo "Creating data archive from $TRILIUM_DATA_PATH..."
tar -czvf "$BACKUP_FILE" -C "$TRILIUM_DIR" data

# Start Trilium container
echo "Starting Trilium container..."
docker compose -f "$TRILIUM_DIR/docker-compose.yml" start trilium

# Delete old backups (e.g., older than 7 days)
echo "Deleting old backups (older than 7 days)..."
find "$BACKUP_DIR" -name "trilium_data_*.tar.gz" -type f -mtime +7 -delete

echo "Backup completed. File: $BACKUP_FILE"

Make the script executable:

chmod +x ~/trilium_backups/backup_trilium.sh

Add a task to Cron. Open crontab:

crontab -e

Add a line for daily backup, for example, at 3:00 AM:

0 3 * * * /root/trilium_backups/backup_trilium.sh >> /var/log/trilium_backup.log 2>&1

This will run the script every day at 3 AM and log the output to /var/log/trilium_backup.log.

5. Storing backups off-server

It is crucial to store copies of backups on remote storage (S3-compatible storage, Dropbox, Google Drive, another server). In case of VPS failure, a backup on the same server will be useless. Use rsync, sftp, or cloud utilities for automatic backup uploads.

Trilium Notes Update Procedure

Updating Trilium Notes installed via Docker Compose is quite simple, but requires caution and a preliminary backup.

1. Checking for a new version

Monitor official Trilium releases on GitHub or Docker Hub to learn about available updates.

2. Backup

Always create a backup before updating! Use the script created above or execute the commands manually.

cd ~/trilium
docker compose stop trilium
tar -czvf ~/trilium_backups/trilium_data_pre_update_$(date +%Y%m%d_%H%M%S).tar.gz ~/trilium/data

3. Changing the image version in docker-compose.yml

Edit the docker-compose.yml file and change the Trilium image version to the new one:

nano ~/trilium/docker-compose.yml

For example, from zadam/trilium:0.62.2 to zadam/trilium:0.63.1.

4. Updating the container

Navigate to the directory containing docker-compose.yml and execute the commands:

cd ~/trilium
docker compose pull trilium # Downloads the new image
docker compose up -d # Recreates the container with the new image, preserving data

Docker Compose will detect that the image has changed and will recreate the container, while preserving the connected data volume. After completion, verify that Trilium is working correctly by opening it in your browser.

If problems arise, you can always revert to a previous backup and/or a previous image version in docker-compose.yml.

For monitoring your server's status and alerting about potential issues, such as disk overflow or high CPU load, consider installing Netdata on your VPS. This will help you react promptly to potential malfunctions.

Choosing the Optimal VPS for Trilium under Real Load

Choosing the right VPS for Trilium Notes directly impacts its performance, responsiveness, and overall stability. While minimum requirements are quite modest, actual load can vary significantly depending on several key factors. The correct choice of VPS configuration will ensure comfortable operation and prevent slowdowns as your knowledge base grows.

Factors influencing VPS selection

1. Number of notes and attachments: The more notes, images, PDF files, and other attachments you store, the more disk space will be required, and the more intensive the load on the disk subsystem will be when searching or opening large notes.
2. Number of active users: Trilium is well-optimized for a single user, but if several people are simultaneously editing notes, performing searches, or synchronizing data, this will increase the load on the CPU and RAM.
3. Use of scripts and automation: If you actively use Trilium's built-in JavaScript engine for complex scripts, automation, or integrations, this can consume additional CPU and RAM resources.
4. Synchronization frequency: If you use synchronization between multiple Trilium instances, frequent and large synchronizations will burden the network and CPU.
5. Disk type: Trilium's SQLite database is very sensitive to disk speed. NVMe drives provide significantly better performance compared to regular SSDs, which is critical for large databases.

VPS Configuration Comparison Table for Trilium Notes

Below is a table with recommended VPS configurations from Valebyte.com for various Trilium Notes usage scenarios. Prices are approximate and may vary.

Usage Scenario	vCPU	RAM (GB)	Disk (NVMe)	Traffic	Approximate Price ($/month)
Personal Use (1 user, up to 10,000 notes, minimum attachments)	1-2	2	25-50 GB	500 GB - 1 TB	$7 - $15
Small Team/Active Personal Use (2-5 users, up to 50,000 notes, moderate attachments)	2-4	4	50-100 GB	1 TB - 2 TB	$15 - $30
Medium Team/Large Knowledge Base (5-15 users, up to 200,000 notes, many attachments, active scripts)	4-6	8	100-200 GB	2 TB - 4 TB	$30 - $60
Large Team/Enterprise (15+ users, over 200,000 notes, intensive load)	6+	16+	200+ GB	4 TB+	$60+

Selection Recommendations

• Always choose NVMe drives: The performance difference between NVMe and regular SSDs, especially for databases, is huge. Investing in a fast disk will pay off with Trilium's speed.
• Don't skimp on RAM: Trilium, as a Node.js application, can use in-memory caching. More RAM means fewer disk accesses and faster operation.
• Start with a buffer: If you are unsure about the exact load, it's better to choose a slightly more powerful plan than the minimum. It's easier to "cut back" resources than to constantly experience performance issues.
• Monitoring: After launching Trilium, use monitoring tools (e.g., htop, docker stats, Netdata) to track actual resource consumption. This will help you understand if the current configuration is sufficient or if scaling is required.
• VPS Flexibility: One of the key advantages of a VPS is the ability to easily scale resources (RAM, CPU, disk) without the need for reinstallation or migration. Valebyte.com offers such flexibility, allowing you to adapt the server to the growing needs of your Trilium Notes.

By choosing a VPS for Trilium, you are investing in the reliability and performance of your personal or team knowledge base. The right approach to configuration selection will help you avoid many problems in the future and focus on what matters most — creating and managing your notes.

Conclusion

Deploying Trilium Notes on a VPS is an optimal solution for those who value full control over their data, high performance, and flexible configuration. By using Docker Compose for installation and a reliable reverse proxy (Nginx or Caddy) for secure HTTPS access, you will create a powerful and private knowledge management system. Regular backups and timely updates will ensure long-term stability, and the correct choice of VPS configuration from Valebyte.com guarantees scalability and efficient operation under any load.