Appwrite on VPS: installation, configuration, and maintenance

Installing Appwrite on a VPS, configuring it, and subsequent maintenance involves deploying the platform via Docker Compose on a virtual server with a minimum of 2 vCPUs, 4 GB RAM, and a 40 GB NVMe disk, allowing developers to quickly get a powerful, self-hosted backend for their applications with full control over the infrastructure.

Appwrite is a powerful open-source Backend-as-a-Service (BaaS) that provides developers with all the necessary APIs and tools to build scalable applications. It offers databases, authentication, file storage, functions, and much more, saving you from having to write a backend from scratch. Deploying Appwrite on your own VPS gives you full control over data, security, and performance, which is critical for many projects. In this article, we will detail how to perform Appwrite installation on a VPS, configure it for stable operation, and ensure efficient maintenance.

What is Appwrite and why use Appwrite on a VPS?

Appwrite is a comprehensive backend solution that significantly accelerates application development. Instead of spending time building infrastructure for user authentication, database operations, file storage, or background tasks, developers can use Appwrite's ready-made APIs. This allows them to focus on client-side logic and business requirements.

Choosing Appwrite on a VPS, or as it is also called, Appwrite self-hosted, is driven by several key advantages:

• Full Control: You completely own your data and infrastructure. This is especially important for projects with high security, privacy, or specific regulatory requirements.
• Flexibility and Customization: You can configure the server environment, install additional tools, and optimize Appwrite for your unique needs, which is often lacking in cloud BaaS solutions.
• Economy of Scale: For many projects, self-hosting Appwrite on a VPS turns out to be significantly more cost-effective than using paid cloud BaaS providers, especially as traffic and data volume grow.
• Performance: You can choose a VPS with optimal characteristics (NVMe disks, high-frequency processors, large amounts of RAM) to ensure maximum performance, without being dependent on "neighboring" clients in the cloud.
• No Vendor Lock-in: You are not tied to a single cloud provider and can always migrate Appwrite to another server or hosting.

Appwrite vs. BaaS competitors: why self-hosting?

There are many BaaS solutions on the market, such as Google's Firebase, Supabase, Parse Server, etc. Each has its strengths. Firebase offers deep integration with the Google ecosystem and serverless functions but can be expensive and less flexible in terms of data control. Supabase, like Appwrite, is an open-source alternative to Firebase but is based on PostgreSQL and has a slightly different architecture.

The main difference of Appwrite self-hosted from many competitors lies precisely in the ability to have full control over the environment. While Firebase is a fully managed service where you pay for usage and cannot influence the infrastructure, Appwrite allows you to deploy it on any server. This gives you the freedom to choose hardware, operating system, and network configuration. If you are looking for a similar solution but with an emphasis on PostgreSQL, we recommend checking out our article on installing Supabase on a VPS.

For developers who value independence, data privacy, and long-term cost-effectiveness, installing Appwrite on a server becomes the obvious choice. Valebyte.com offers reliable VPS and dedicated servers, ideally suited for such tasks.

Appwrite System Requirements and Optimal VPS Selection

Before proceeding with the Appwrite installation, it is important to choose the right virtual server. Appwrite runs in Docker containers, which makes it very portable, but also resource-intensive, especially under active load. The correct choice of VPS configuration is key to the stability and performance of your application.

Minimum and Recommended Configurations for Appwrite Self-Hosted

Appwrite, like any other complex system, has its hardware requirements. These requirements depend on the expected load: the number of active users, data volume, request frequency, and complexity of the functions performed.

• Minimum Requirements (for development and testing):
  • CPU: 1 vCPU
  • RAM: 2 GB
  • Disk: 20 GB NVMe/SSD
  • OS: Ubuntu 20.04+ (or other modern Linux)

  On such a configuration, Appwrite will launch and run, but under any significant load, you will encounter slowdowns. This is suitable exclusively for personal projects, learning, or demonstrations.

• Recommended Requirements (for small to medium production applications):
  • CPU: 2-4 vCPUs (the more, the better for parallel operations)
  • RAM: 4-8 GB (sufficient for most database operations and caching)
  • Disk: 40-80 GB NVMe (NVMe is critically important for database speed and file operations)
  • OS: Ubuntu 22.04 LTS

  This configuration will ensure stable operation for applications with moderate load, supporting hundreds of active users and thousands of requests per minute. NVMe disks play a key role here, significantly accelerating I/O operations, which directly impacts the responsiveness of Appwrite's database and file storage.

• High Load Requirements (scalable production applications):
  • CPU: 8+ vCPUs
  • RAM: 16+ GB
  • Disk: 100+ GB NVMe (possibly with a separate volume for data)
  • OS: Ubuntu 22.04 LTS

  For projects with thousands of active users, intensive data operations, and a large number of background tasks, a more powerful server will be required. In this case, it might be worth considering not just a VPS, but a dedicated server, which will provide maximum performance without "neighbors."

Which VPS to choose for Appwrite on a server?

The choice of VPS provider is no less important than the configuration itself. Pay attention to the following aspects when choosing a VPS for Appwrite on a server:

• Virtualization Type: KVM virtualization is recommended for Appwrite, as it provides full resource isolation and maximum performance. KVM VPS vs OpenVZ VPS is an important choice, and KVM is always preferable for production workloads.
• Storage Type: NVMe disks are the standard for high-performance applications. They provide significantly higher read/write speeds compared to regular SSDs or HDDs, which is critically important for Appwrite's database (MariaDB) and file storage.
• Server Location: Choose a data center geographically close to your primary audience to minimize latency.
• Network Bandwidth: Ensure your VPS plan offers sufficient bandwidth (minimum 1 Gbps) and traffic volume.
• Support: A reliable provider with prompt technical support is always a plus.

Valebyte.com offers various VPS plans that are ideal for deploying Appwrite. Here is an approximate table of configurations and their applicability:

Valebyte Plan (example)	CPU (vCores)	RAM (GB)	Disk (NVMe, GB)	Bandwidth	Approximate Appwrite Load	Recommended Price (monthly)
Basic-2	2	4	40	1 Gbps	Development, testing, small projects (up to 500 active users)	From $15
Standard-4	4	8	80	1 Gbps	Medium production applications (up to 5000 active users)	From $30
Pro-8	8	16	160	1 Gbps	Large production applications, high load (up to 20000 active users)	From $60
Dedicated Entry	16+	32+	240+	10 Gbps	Very high load, demanding services (more than 20000 active users)	From $150

When choosing a VPS, it's always better to opt for a configuration with a small reserve to allow for growth and avoid performance issues in the future.

Preparing the VPS for Appwrite Installation

Before proceeding with the Appwrite installation, you need to prepare your virtual server. This step includes updating the operating system, installing Docker and Docker Compose, and basic firewall configuration to ensure security. We will use Ubuntu Server 22.04 LTS as the most common and well-supported OS for such tasks.

System Update and Docker Installation

The first step is always to update your system. This ensures that you have all the latest security patches and available package versions installed.

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

After updating the system, you need to install Docker and Docker Compose. Appwrite is fully containerized and uses Docker to deploy all its components (database, cache, queues, API servers, etc.).

The simplest way to install Docker is to use the official script:

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

This script will install Docker Engine, Docker CLI, and the Docker Compose Plugin. After installation, it is recommended to add your user to the docker group to avoid using sudo with every Docker command:

sudo usermod -aG docker $USER
newgrp docker

Verify that Docker is installed and running:

docker --version
docker compose version

You should see the versions of Docker and Docker Compose. If you see a "command not found" error for Docker Compose, you might have an older Docker version, and Docker Compose needs to be installed separately. However, for modern distributions and the get-docker.sh script, this should not be an issue.

Understanding how to work with Docker containers is key to successful Appwrite management. For a deeper dive into containerization, we recommend reading the article Containers vs. VMs vs. Bare-metal: The 2026 Hosting Landscape.

Firewall Configuration (UFW)

Configuring the firewall is a critically important step to protect your server. We will use UFW (Uncomplicated Firewall), which is pre-installed in Ubuntu and easy to configure.

Allow the necessary ports:

• 22/tcp: For SSH access. Make sure you allow this port before enabling the firewall, otherwise you will lose access to the server!
• 80/tcp: For HTTP traffic (required for obtaining Let's Encrypt SSL certificates).
• 443/tcp: For HTTPS traffic (the main port for Appwrite access).
• Any other ports if Appwrite will use them directly (e.g., for specific functions or custom services, but usually 80/443 is sufficient when a reverse proxy is used).

sudo ufw allow 22/tcp
sudo ufw allow 80/tcp
sudo ufw allow 443/tcp
sudo ufw enable
sudo ufw status verbose

The command sudo ufw enable activates the firewall. After that, sudo ufw status verbose will show the current rules. Make sure all necessary ports are allowed, and others are blocked by default.

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

After preparing the server, you can proceed with the Appwrite installation itself. Thanks to Docker, this process is greatly simplified and takes only a few minutes.

Downloading the Appwrite Docker Installation Script

Appwrite provides a convenient script to initialize all necessary Docker Compose configuration files. Run the following command:

docker run -it --rm \
    --volume /var/run/docker.sock:/var/run/docker.sock \
    --volume "$(pwd)"/appwrite:/usr/src/code/appwrite:rw \
    --pull always \
    appwrite/appwrite:latest install

Let's break down this command:

• docker run -it --rm: Runs the container in interactive mode, removing it after completion.
• --volume /var/run/docker.sock:/var/run/docker.sock: Allows the Appwrite container to interact with the Docker daemon on the host machine. This is necessary for Appwrite to manage its own containers.
• --volume "$(pwd)"/appwrite:/usr/src/code/appwrite:rw: Mounts the current appwrite directory on the host into the container. All Appwrite configuration files and Docker Compose files will be stored here.
• --pull always: Ensures that you are using the freshest version of the Appwrite image.
• appwrite/appwrite:latest install: Instructs Docker to run the Appwrite image with the latest tag and execute the install command inside it.

Configuring Environment Variables and Starting Appwrite Docker

After executing the install command, the script will ask you a few questions:

1. Choose your server HTTP port: 80 (default, unless you plan to use another port).
2. Choose your server HTTPS port: 443 (default).
3. Choose your Appwrite server hostname: Enter the domain name you will use to access Appwrite (e.g., appwrite.yourdomain.com). If you don't have a domain yet, you can use your VPS's IP address, but a domain is highly recommended for a production environment.
4. Choose your Appwrite secret key: Leave blank to generate a random key or enter your own. This is a very important key for security.

After answering the questions, the script will generate the docker-compose.yml file and other configuration files in the appwrite directory you specified. Now you need to navigate to this directory:

cd appwrite

And start Appwrite using Docker Compose:

docker compose up -d

The command docker compose up -d will start all Appwrite services in the background (-d means "detached"). Docker will begin downloading the necessary images and launching containers. This may take several minutes, depending on your internet connection speed and VPS performance.

You can check the status of running containers:

docker compose ps

Ensure that all Appwrite containers (appwrite_appwrite, appwrite_mariadb, appwrite_redis, appwrite_influxdb, appwrite_telegraf, appwrite_functions, appwrite_worker, and others) are in the "Up" state.

Now you can access your Appwrite installation by navigating to your VPS's IP address or the domain name you specified during installation in your browser. You will see the Appwrite welcome page where you can create an administrator account.

Configuring Reverse Proxy and HTTPS for Appwrite

Direct access to Appwrite via an IP address or HTTP port 80 is not a secure or professional solution. For a production environment, it is crucial to set up a Reverse Proxy and ensure traffic encryption using HTTPS. This enhances security, allows the use of a domain name, and simplifies SSL certificate management.

We will consider two popular reverse proxy options: Nginx and Caddy. Both are capable of automatically obtaining and renewing SSL certificates from Let's Encrypt.

Using Nginx as a Reverse Proxy

Nginx is a high-performance web server and reverse proxy, widely used for serving high-load websites and applications. If you already have experience with Nginx, this might be the preferred option.

1. Install Nginx:

sudo apt install nginx -y
sudo systemctl enable nginx
sudo systemctl start nginx

2. Configure Nginx for Appwrite:

Create a new configuration file for your domain (e.g., appwrite.yourdomain.com.conf) in the /etc/nginx/conf.d/ directory. Replace appwrite.yourdomain.com with your actual domain.

sudo nano /etc/nginx/conf.d/appwrite.yourdomain.com.conf

Paste the following code:

server {
    listen 80;
    listen [::]:80;
    server_name appwrite.yourdomain.com; # Replace with your domain

    location / {
        proxy_pass http://localhost:80; # Appwrite listens on port 80 inside Docker
        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_redirect off;

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

3. Test and Reload Nginx:

sudo nginx -t
sudo systemctl reload nginx

4. Install Certbot for Let's Encrypt (HTTPS):

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

sudo apt install certbot python3-certbot-nginx -y
sudo certbot --nginx -d appwrite.yourdomain.com # Replace with your domain

Follow Certbot's instructions. It will automatically modify your Nginx configuration to use HTTPS and set up automatic certificate renewal. After this, your Appwrite will be accessible via HTTPS.

Configuring Caddy for Automatic HTTPS

Caddy is a modern web server with automatic HTTPS, which significantly simplifies SSL setup. It is ideal if you want to get HTTPS up and running as quickly and painlessly as possible.

1. Install 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 caddy -y

2. Configure Caddyfile:

Caddy uses a configuration file called Caddyfile. Edit it:

sudo nano /etc/caddy/Caddyfile

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

appwrite.yourdomain.com { # Replace with your domain
    reverse_proxy localhost:80 {
        header_up Host {host}
        header_up X-Real-IP {remote_ip}
        header_up X-Forwarded-For {remote_ip}
        header_up X-Forwarded-Proto {scheme}
        
        # WebSocket support
        header_up Upgrade {http.request.header.Upgrade}
        header_up Connection {http.request.header.Connection}
    }
}

3. Test and Reload Caddy:

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

Caddy will automatically obtain an SSL certificate from Let's Encrypt and configure HTTPS. Now your Appwrite is accessible via HTTPS through the specified domain.

Regardless of whether you choose Nginx or Caddy, ensure that the DNS A-record for your domain (e.g., appwrite.yourdomain.com) points to your VPS's IP address.

Basic Appwrite Maintenance: Backups, Updates, and Monitoring

Appwrite installation is just the beginning. To ensure stable, secure, and up-to-date operation of your platform, regular maintenance is required. This includes data backup, timely updates, and system health monitoring.

Appwrite Data Backup Strategies

Backup is the most important aspect of any server maintenance. Data loss can be catastrophic. Appwrite stores its data in several locations:

1. MariaDB Database: Primary project data, users, settings, etc.
2. File Storage (MinIO): User-uploaded files, avatars, documents, etc.
3. Environment Variables and Docker Compose Configuration: The .env file and docker-compose.yml in your appwrite directory.

Recommended Backup Strategy:

1. MariaDB Database Backup:

You can dump the database directly from the MariaDB Docker container:

# Navigate to the Appwrite directory
cd ~/appwrite

# Find the MariaDB container name (usually appwrite_mariadb_1 or appwrite-mariadb-1)
docker compose ps

# Perform a database dump
# Replace `YOUR_MARIADB_ROOT_PASSWORD` with the password from the .env file
docker exec appwrite-mariadb-1 /usr/bin/mysqldump -u root --password=YOUR_MARIADB_ROOT_PASSWORD appwrite > appwrite_backup_$(date +%Y%m%d_%H%M%S).sql

2. File Storage (MinIO) Backup:

Files are stored in a Docker volume. You can copy the contents of this volume. First, find the volume name:

docker volume ls | grep appwrite_uploads

This is usually something like appwrite_appwrite_uploads. Then use the command docker run --rm -v <volume_name>:/volume -v $(pwd)/backups:/backup alpine tar czf /backup/appwrite_uploads_$(date +%Y%m%d_%H%M%S).tar.gz -C /volume . to create an archive. Or simply copy the files from the uploads folder, which is usually mounted from the local file system.

If you are using local storage for MinIO (which is the default setting for a simple installation), the files are located in the appwrite/uploads directory on your host. Simply copy this directory:

cd ~/appwrite
tar -czf appwrite_uploads_backup_$(date +%Y%m%d_%H%M%S).tar.gz uploads/

3. Configuration File Backup:

Copy the .env and docker-compose.yml files from your appwrite directory:

cd ~/appwrite
cp .env .env.backup_$(date +%Y%m%d_%H%M%S)
cp docker-compose.yml docker-compose.yml.backup_$(date +%Y%m%d_%H%M%S)

Automating Backups:

Use cron to automate these tasks. For example, for daily database and file backups to the ~/appwrite/backups directory:

mkdir -p ~/appwrite/backups
sudo nano /etc/crontab

Add the lines (replace YOUR_MARIADB_ROOT_PASSWORD and YOUR_USER):

0 3 * * * YOUR_USER bash -c "cd /home/YOUR_USER/appwrite && docker exec appwrite-mariadb-1 /usr/bin/mysqldump -u root --password=YOUR_MARIADB_ROOT_PASSWORD appwrite > backups/appwrite_backup_$(date +\%Y\%m\%d_\%H\%M\%S).sql"
15 3 * * * YOUR_USER bash -c "cd /home/YOUR_USER/appwrite && tar -czf backups/appwrite_uploads_backup_$(date +\%Y\%m\%d_\%H\%M\%S).tar.gz uploads/"

Store backups on a separate disk or in cloud storage (e.g., S3-compatible). Never store the only copies of backups on the same server as the production data.

Updating Appwrite and Docker Containers

Regular Appwrite updates are important for new features, bug fixes, and security patches. The update process is quite simple thanks to Docker.

1. Check the current Appwrite version:

Log in to the Appwrite administration panel and check the version number in the footer or settings.

2. Update:

Before updating, always perform a full backup. Then navigate to the Appwrite directory and execute the following commands:

cd ~/appwrite
docker compose pull # Downloads the latest versions of Appwrite images
docker compose up -d # Recreates containers with new images

If Appwrite requires database migration, it will automatically run the necessary scripts when the new containers start. After updating, check the container logs for errors:

docker compose logs

And ensure that all services are running correctly again.

Monitoring Appwrite on the Server

Monitoring allows you to track the performance and health of your Appwrite server, identifying problems before they become critical.

• Docker Container Monitoring:

  Use docker stats to view resource usage (CPU, RAM, network) for each Appwrite container. This provides a quick overview of performance.

  docker stats
          

• Container Logs:

  Check Appwrite container logs for errors or warnings:

  docker compose logs -f
          

  This will show logs for all services in real-time. You can also view logs for a specific service, e.g., docker compose logs appwrite_appwrite_1.

• VPS Resource Monitoring:

  Use tools such as htop, top, free -h, df -h to monitor overall CPU, RAM, disk, and network load on your VPS.

  htop
          

• Built-in Appwrite Metrics:

  Appwrite provides its own monitoring dashboard with metrics for API usage, database, and other services. It can be accessed through the Appwrite admin panel.

For more advanced monitoring, you can set up systems like Prometheus and Grafana, which can collect metrics from Docker containers and present them in convenient dashboards. This is beyond the scope of this article but is an important step for production systems.

Appwrite Performance Optimization and Scaling

After successfully installing Appwrite on a VPS and basic configuration, it's important to consider performance optimization and scaling options. Efficient use of server resources allows Appwrite to handle more requests and serve more users without slowdowns.

Resource Configuration and Caching

Appwrite is configured quite well by default, but for specific loads or to increase performance, you can make changes via environment variables in the .env file of your Appwrite directory. After any change to .env, you must restart the Appwrite containers (docker compose down && docker compose up -d).

1. Redis Optimization:

Appwrite actively uses Redis for caching and queue management. Ensure that Redis is allocated sufficient RAM. In .env, you can find variables related to Redis:

• _APP_REDIS_HOST: Redis host.
• _APP_REDIS_PORT: Redis port.

To optimize Redis itself, you can configure its parameters via a configuration file (if you are not using the default Appwrite container but running Redis separately). Important parameters include maxmemory and maxmemory-policy.

2. Worker Configuration:

Appwrite uses workers to perform background tasks (sending emails, file processing, function execution). The number of workers can be adjusted. More workers mean better parallel processing, but also higher CPU and RAM consumption.

• _APP_WORKER_PER_CORE: Number of workers per CPU core. By default, Appwrite automatically determines the optimal number.

If you have a powerful VPS with many cores but are seeing delays in background tasks, it might be worth increasing the number of workers.

3. API Caching:

To reduce database load and speed up API responses, Appwrite supports caching. Ensure it is active. In .env, there are variables related to caching:

• _APP_CACHE_ENABLED: Enable/disable caching (enabled/disabled).
• _APP_CACHE_TTL: Cache time-to-live in seconds.

4. MariaDB Database Optimization:

MariaDB is the heart of Appwrite. For high-load systems, fine-tuning MariaDB might be necessary. This includes parameters such as innodb_buffer_pool_size (for caching data in RAM), query_cache_size, and others. These parameters are usually configured in the my.cnf file inside the MariaDB container. To make such changes, you might need to create a custom Docker image for MariaDB or use configuration file mounting.

5. Using a CDN for Static Files:

If your application actively uses Appwrite's file storage and serves many static assets (images, videos), consider using a Content Delivery Network (CDN). This will significantly reduce the load on your VPS and speed up content delivery for users worldwide. Appwrite allows you to configure a custom domain for static files, which can be pointed to a CDN.

When to Consider a Dedicated Server?

While a VPS provides excellent flexibility and scalability for most projects, there comes a point when its resources become insufficient. Here are some signs when you should consider migrating from a VPS to a dedicated server:

• Persistent High CPU Load: If your VPS consistently runs with 80-90% CPU utilization or higher, it's a clear sign of insufficient computing resources.
• Insufficient RAM: If Appwrite or the database constantly uses swap, this leads to significant slowdowns. Adding RAM to a VPS can help, but at some point, a dedicated server will offer more memory at a better price.
• Peak Loads: If your application experiences sharp and frequent peak loads that the VPS cannot effectively handle, a dedicated server with more powerful hardware will ensure stability.
• Disk I/O Requirements: For applications with intensive read/write operations to the database or file storage, a dedicated server with high-performance NVMe disks (possibly in a RAID array) can offer significantly better performance than a VPS with shared disk storage.
• Specific Security or Compliance Requirements: Some security standards or regulatory requirements may dictate the use of physically isolated hardware.
• Need for Horizontal Scaling: For very large projects requiring multiple Appwrite instances behind a load balancer, a dedicated server can become the foundation for such a cluster architecture.

Valebyte.com offers a wide range of dedicated servers that can provide maximum performance and reliability for the most demanding Appwrite installations. Migrating to a dedicated server gives you exclusive access to all physical machine resources, eliminating "noisy neighbors" and ensuring predictable performance.

Conclusion

Installing, configuring, and maintaining Appwrite on a VPS is a powerful solution for developers seeking full control over their backend, optimizing costs, and ensuring high performance. By following these instructions, you can deploy a stable and secure Appwrite environment, while regular backups and timely updates guarantee the long-term reliability of your platform. To ensure optimal performance and scalability, especially for production applications, we recommend choosing a VPS with NVMe disks and sufficient RAM, provided by Valebyte.com.