Wallabag on VPS: installation, configuration, and maintenance

Wallabag on a VPS allows you to easily install, configure, and maintain a personal service for saving web pages without ads, with offline reading capability and convenient access from any device. The minimal requirements for running Wallabag on a server are 1 vCPU, 1 GB RAM, and a 10 GB NVMe disk, making it accessible even on basic VPS plans.

In an era of information overload and constant competition for user attention, the ability to save an interesting article or web page for later, thoughtful study becomes critically important. Services like Pocket or Instapaper have long proven their worth, but what if you want complete control over your data, no ads, and independence from third-party companies? This is where Wallabag comes in — a powerful open-source solution for self-hosted "read-it-later" functionality.

Deploying Wallabag on your own Virtual Private Server (VPS) from Valebyte.com gives you not only complete sovereignty over your saved articles but also guarantees high performance, reliability, and security. In this article, we will detail how to install Wallabag on a VPS using Docker and Docker Compose, configure it to work through a reverse proxy with HTTPS, and how to ensure regular maintenance, including backups and updates. We will also provide recommendations for choosing the optimal VPS configuration for Wallabag under different usage scenarios.

What is Wallabag and why choose self-hosted on a VPS?

Wallabag is a free, open-source application that allows you to save web pages for later reading. It removes unnecessary elements such as ads, pop-ups, and navigation bars, leaving only the main content of the article in a clean, easy-to-read format. Imagine a personal digital library where every saved article is available at any time, even without an internet connection, via mobile apps or a web interface.

What is Wallabag for?

• Distraction-free reading: Wallabag cleans articles of "digital clutter," allowing you to focus on the content.
• Offline availability: Saved pages can be read without an internet connection, which is convenient when traveling or with unstable connectivity.
• Content organization: The ability to add tags, archive, and mark as read helps systematize information.
• Cross-platform: Access via web interface, official and third-party apps for iOS, Android, browser extensions.
• Privacy: Your data is stored on your server, not on third-party cloud platforms.

Advantages of Wallabag on your own server

Choosing a self-hosted solution like Wallabag and deploying it on a VPS instead of using public services or installing it on a home server offers several undeniable advantages:

• Full data control: All your saved articles, notes, and settings are stored exclusively on your VPS. No one but you has access to them. This is critically important for confidential information or simply for those who value privacy.
• Independence from third-party services: You are not dependent on changes in privacy policies, tariffs, or the sudden closure of third-party services. Your Wallabag will work as long as your VPS works.
• Flexibility and scalability: On a VPS, you can configure Wallabag exactly as you need it. As your library grows or the number of users increases (if you decide to share access), you can easily scale VPS resources by increasing RAM, vCPU, or disk space.
• Improved performance: A high-quality VPS from Valebyte.com with NVMe drives and high-speed network channels will ensure fast Wallabag operation, which is especially noticeable with a large number of saved articles and active use.
• Integration with other services: On your own server, you can easily integrate Wallabag with other self-hosted applications, such as RSS readers (FreshRSS, Miniflux) or identity management systems (Keycloak, Authelia), creating a unified ecosystem.
• No ads or restrictions: Unlike free versions of commercial services, your Wallabag on a VPS will be completely free of ads and any functional limitations.

Installing Wallabag on a VPS transforms it from a simple application into a powerful, personalized information management tool, entirely under your control.

Wallabag System Requirements and Optimal VPS Selection

Before proceeding with Wallabag installation, it's important to understand what resources will be required for its stable and fast operation. Wallabag is not a resource-intensive application for individual use, but requirements may increase depending on the data volume and the number of active users.

Minimal Requirements for Wallabag

For running Wallabag in a Docker container for one or two users with a moderate number of articles (up to several thousand), the following minimal VPS characteristics are suitable:

• Processor (vCPU): 1 core. Wallabag does not require intensive computations; most operations involve database and file system interaction.
• Random Access Memory (RAM): 1 GB. This will be sufficient for Docker Engine, the Wallabag container (PHP-FPM, Nginx/Apache inside the container), and the database (PostgreSQL or MySQL/MariaDB). If you plan to use SQLite, RAM consumption might be even lower.
• Disk Space: 10-20 GB NVMe disk. NVMe will significantly speed up database operations and page loading. 10 GB is enough for the operating system, Docker, and several thousand articles. Each article occupies from several tens to several hundreds of kilobytes.
• Operating System: Ubuntu Server 22.04 LTS (recommended), Debian 11/12, or CentOS 8/9.
• Network Bandwidth: 100 Mbps - 1 Gbps. For Wallabag, basic bandwidth is usually sufficient.

Such configurations are available from Valebyte.com starting from $5-7 per month, making Wallabag a very affordable self-hosted solution.

Optimal VPS Configuration for Wallabag under Load

If you plan to use Wallabag actively, save tens of thousands of articles, or if you will have several active users (e.g., a family account or a small team), you should consider a more powerful VPS:

• Processor (vCPU): 2 cores. This will provide better performance when simultaneously processing requests, parsing new articles, and serving multiple users.
• Random Access Memory (RAM): 2-4 GB. More RAM will allow the database to cache more data, speed up operations, and ensure stable performance during peak loads. If you plan to host other services on the same VPS (e.g., Netdata for monitoring or other self-hosted applications), 4 GB RAM will be a good choice.
• Disk Space: 50-100 GB NVMe disk. For a large volume of data and to provide room for future growth. NVMe drives are critically important for database performance.
• Network Bandwidth: 1 Gbps. Although Wallabag is not very demanding on the network, a high-speed channel is always beneficial for overall server operation.

Choosing a KVM VPS is preferable to OpenVZ, as KVM provides full virtualization and better resource isolation, which is important for stable Docker and database operation. Valebyte.com offers a wide selection of KVM VPS plans that are ideal for such tasks.

Preparing your VPS for Wallabag Docker Installation

For the simplest and most reliable Wallabag installation, we will use Docker and Docker Compose. This allows isolating the application with all its dependencies in containers, simplifying deployment, updates, and migration.

System Update and Docker Engine Installation

Connect to your VPS via SSH. The first step should always be to update the system:

sudo apt update && sudo apt upgrade -y

Next, we will install Docker Engine. Follow the official Docker documentation for your operating system. For Ubuntu, it looks like this:

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

# Add Docker's official GPG key
sudo mkdir -p /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

# Add Docker repository
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
  $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# Install Docker Engine, Docker CLI, and Containerd
sudo apt update
sudo apt install docker-ce docker-ce-cli containerd.io -y

# Add current user to the docker group to work without sudo
sudo usermod -aG docker $USER
# To apply changes, you need to log out and log back into the SSH session or restart the VPS
# newgrp docker (alternatively, without reconnecting)

Verify Docker installation:

docker run hello-world

If you see the message "Hello from Docker!", then Docker is installed and working correctly.

Docker Compose Setup

Docker Compose allows you to define and run multi-container Docker applications. Wallabag consists of several components (application, database), so Docker Compose is ideal for its deployment. Install Docker Compose V2 (which is now part of the Docker CLI):

sudo apt install docker-compose-plugin -y

Verify installation:

docker compose version

You should see the Docker Compose version, for example, Docker Compose version v2.x.x.

Now your VPS is ready for Wallabag Docker deployment.

Step-by-Step Wallabag Installation on VPS with Docker Compose

Now that Docker and Docker Compose are installed, we can proceed with Wallabag deployment. We will use official Wallabag and PostgreSQL (or MariaDB) Docker images for the database.

Creating the docker-compose.yml file for Wallabag

Create a directory for Wallabag and navigate into it:

mkdir wallabag
cd wallabag

In this directory, create the docker-compose.yml file:

nano docker-compose.yml

Insert the following content. This example uses PostgreSQL as the database, which is the recommended option for stable operation.

version: "3.5"

services:
  wallabag:
    image: wallabag/wallabag:latest
    container_name: wallabag
    environment:
      - SYMFONY__ENV__DATABASE_URL=postgresql://wallabag:your_strong_db_password@db:5432/wallabag?serverVersion=13&charset=utf8
      - SYMFONY__ENV__DOMAIN_NAME=https://wallabag.yourdomain.com # Replace with your domain
      - SYMFONY__ENV__FOSUSER_REGISTRATION=true # Allow new user registration (true/false)
      - SYMFONY__ENV__TWOFACTOR_AUTH=true # Enable two-factor authentication
      - SYMFONY__ENV__LIWA_CLIENT_ID= # Optional: for integration with Read It Later (Pocket-like)
      - SYMFONY__ENV__LIWA_CLIENT_SECRET= # Optional: for integration with Read It Later (Pocket-like)
      # Additional options:
      # - SYMFONY__ENV__MAILER_URL=smtp://user:[email protected]:587?encryption=tls&auth_mode=login
    volumes:
      - ./data/wallabag:/var/www/wallabag/web/assets/images/
      - ./data/wallabag:/var/www/wallabag/data/
    depends_on:
      - db
    restart: unless-stopped
    ports:
      - "127.0.0.1:8080:80" # Wallabag will be accessible on port 8080 of your VPS only locally

  db:
    image: postgres:13-alpine
    container_name: wallabag_db
    environment:
      - POSTGRES_USER=wallabag
      - POSTGRES_PASSWORD=your_strong_db_password # Use the same password as in SYMFONY__ENV__DATABASE_URL
      - POSTGRES_DB=wallabag
    volumes:
      - ./data/postgres:/var/lib/postgresql/data
    restart: unless-stopped

Important notes:

• Replace your_strong_db_password with a strong password.
• Replace https://wallabag.yourdomain.com with your actual domain that you will use to access Wallabag. If you don't have a domain, you can use an IP address, but for HTTPS and convenience, a domain is highly recommended.
• SYMFONY__ENV__FOSUSER_REGISTRATION=true allows new users to register via the web interface. For personal use or a closed group, it's better to set it to false after creating the first administrator.
• The port 127.0.0.1:8080:80 means that Wallabag will be accessible on port 8080 *only within your VPS* (for reverse proxy). If you want temporary direct access, change it to 8080:80 (but this is insecure without HTTPS and a reverse proxy).
• The volumes section ensures that Wallabag and database data are saved on your VPS disk, even if containers are recreated.

Starting Wallabag and Initial Setup

Save the file (Ctrl+X, Y, Enter) and start the Docker Compose containers:

docker compose up -d

The -d option runs containers in the background. The process may take several minutes while images are downloaded and the database is initialized.

Check the status of the containers:

docker compose ps

You should see that both containers (wallabag and wallabag_db) are in the "Up" state.

Creating the first administrator:

After the initial launch, you need to create an administrator. Connect to the Wallabag container and execute the command:

docker compose exec wallabag bin/console wallabag:install --env=prod

During the execution of this command, you will be prompted to enter a username, email address, and password for the administrator.

Now Wallabag on the server is running, but it's only accessible locally on port 8080. To make it accessible externally and with HTTPS, we'll need to set up a reverse proxy.

Setting up Reverse Proxy (Nginx/Caddy) and HTTPS for Wallabag

For secure and convenient access to Wallabag from the internet, as well as for automatic HTTPS certificate acquisition (Let's Encrypt), a reverse proxy server needs to be configured. We will cover two popular options: Nginx and Caddy.

Before you begin, ensure that your domain (e.g., wallabag.yourdomain.com) points to your VPS's IP address in your DNS records (A type).

Nginx as a Reverse Proxy for Wallabag

Nginx is a powerful and widely used web server that excels as a reverse proxy. If you don't have Nginx installed yet, do so:

sudo apt install nginx -y

Create a new configuration file for your Wallabag domain:

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

Insert the following content, replacing wallabag.yourdomain.com with your actual domain:

server {
    listen 80;
    listen [::]:80;
    server_name wallabag.yourdomain.com;

    location / {
        proxy_pass http://127.0.0.1:8080;
        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_buffering off;
        proxy_request_buffering off;
    }
}

Save the file, create a symbolic link to it in sites-enabled, and check the Nginx configuration:

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

If the configuration is okay, reload Nginx:

sudo systemctl reload nginx

Now Wallabag should be accessible via HTTP through your domain. The next step is to configure HTTPS using Certbot.

Configuring HTTPS with Certbot for Nginx

Install Certbot and the Nginx plugin:

sudo apt install certbot python3-certbot-nginx -y

Run Certbot to obtain and install the certificate:

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

Follow Certbot's instructions. It will automatically modify the Nginx configuration, adding an HTTP to HTTPS redirect and SSL parameters. After Certbot completes, your Wallabag will be accessible via HTTPS.

Check that automatic certificate renewal is working:

sudo systemctl status certbot.timer

If the timer is active, Certbot will automatically renew certificates before they expire.

Caddy: An easy way to get HTTPS

Caddy is a modern web server that automatically obtains and renews HTTPS certificates for your domains, making it extremely convenient for Wallabag on a server. If you haven't installed Caddy yet, you can do so as follows:

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

Stop Nginx if it's running to avoid port 80/443 conflicts:

sudo systemctl stop nginx
sudo systemctl disable nginx

Create or edit the Caddyfile:

sudo nano /etc/caddy/Caddyfile

Remove existing content and insert the following, replacing wallabag.yourdomain.com with your domain:

wallabag.yourdomain.com {
    reverse_proxy 127.0.0.1:8080
    # Additional security settings (optional)
    header {
        Strict-Transport-Security "max-age=31536000; includeSubDomains; preload"
        X-Frame-Options "DENY"
        X-Content-Type-Options "nosniff"
        X-XSS-Protection "1; mode=block"
        Referrer-Policy "strict-origin-when-cross-origin"
    }
}

Save the file and check the Caddy configuration:

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

If the configuration is correct, restart Caddy:

sudo systemctl reload caddy

Caddy will automatically obtain a Let's Encrypt certificate and configure HTTPS for your domain. Your Wallabag is now accessible via HTTPS.

Wallabag Maintenance on VPS: Backups, Updates, and Monitoring

Regular maintenance is key to stable and secure Wallabag operation on your VPS. This includes creating backups, timely updates, and system status monitoring.

Wallabag Backup Strategies

Backup is the most important aspect. Wallabag stores data in two places: the database (PostgreSQL) and the file system (saved images, configuration files). Both components must be backed up.

Create a backup script in the Wallabag directory (e.g., backup.sh):

nano backup.sh

Insert the following content:

#!/bin/bash

# Settings
BACKUP_DIR="/root/wallabag_backups" # Directory for storing backups
DATE=$(date +%Y-%m-%d_%H-%M-%S)
WALLABAG_DIR="$(pwd)" # Current docker-compose.yml directory

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

echo "Starting Wallabag backup..."

# 1. PostgreSQL database backup
echo "Backing up PostgreSQL database..."
docker compose exec -T db pg_dump -U wallabag wallabag > "$BACKUP_DIR/wallabag_db_backup_$DATE.sql"
if [ $? -eq 0 ]; then
    echo "Database backup successfully created: $BACKUP_DIR/wallabag_db_backup_$DATE.sql"
else
    echo "Error backing up database!"
    exit 1
fi

# 2. Wallabag files backup (data and assets)
echo "Backing up Wallabag files..."
tar -czf "$BACKUP_DIR/wallabag_files_backup_$DATE.tar.gz" -C "$WALLABAG_DIR/data" .
if [ $? -eq 0 ]; then
    echo "Files backup successfully created: $BACKUP_DIR/wallabag_files_backup_$DATE.tar.gz"
else
    echo "Error backing up Wallabag files!"
    exit 1
fi

echo "Backup completed."

# Clean up old backups (e.g., keep the last 7 days)
find "$BACKUP_DIR" -type f -name "*.sql" -mtime +7 -delete
find "$BACKUP_DIR" -type f -name "*.tar.gz" -mtime +7 -delete
echo "Old backups deleted (older than 7 days)."

Make the script executable:

chmod +x backup.sh

Now you can run this script manually or schedule its execution using Cron. For example, for a daily backup at 03:00 AM:

crontab -e

Add the following line:

0 3 * * * cd /root/wallabag && ./backup.sh >> /var/log/wallabag_backup.log 2>&1

This will save backups to /root/wallabag_backups and logs to /var/log/wallabag_backup.log. It is also recommended to configure copying these backups to remote storage (S3, Dropbox, another VPS) for maximum reliability.

Updating Wallabag Docker Containers

Wallabag updates are usually released regularly, bringing new features, bug fixes, and security improvements. Since we use Docker, updating is very simple:

cd /root/wallabag # Navigate to the directory with docker-compose.yml
docker compose pull # Download new image versions
docker compose up -d # Recreate containers with new images

After updating, Wallabag database migrations may need to be performed:

docker compose exec wallabag bin/console doctrine:migrations:migrate --no-interaction --env=prod

It is recommended to perform these operations once a month or after significant updates are released.

Monitoring Wallabag Operation

Monitoring your VPS and Wallabag allows for prompt problem identification. You can use:

• docker compose logs -f: View container logs in real-time for debugging.
• htop or top: View CPU and RAM usage on the VPS.
• Netdata: A powerful real-time monitoring system that is easily installed on a VPS and provides detailed information about load, network, disk, and Docker container status.
• UptimeRobot or Healthchecks.io: External services to check the availability of your Wallabag via HTTP/HTTPS.

Regular checking of logs and metrics will help you maintain Wallabag in optimal condition.

Which Valebyte.com VPS config to choose for Wallabag under real load?

Choosing the right VPS for Wallabag depends on your needs. Valebyte.com offers various plans that can be optimal for Wallabag in different scenarios. It's important to consider not only resources (CPU, RAM, Disk) but also the disk type (NVMe), network bandwidth, and data center location.

Comparison Table of VPS Plans for Wallabag

Below is an approximate table to help you choose the right VPS plan from Valebyte.com for Wallabag VPS, depending on the anticipated load and usage.

Usage Scenario	Recommended VPS Config (Valebyte.com)	Approx. Plan/Month	Comments
Personal use, up to 1000 articles	1 vCPU, 1 GB RAM, 20 GB NVMe	from $5-$7	Basic plan, ideal for starting. Excellent for a single user.
Personal use, 1000-10000 articles, active reading	2 vCPU, 2 GB RAM, 50 GB NVMe	from $10-$15	Optimal balance of performance and price. Suitable for active readers and moderate library growth.
Family access / Small team (2-5 users), >10000 articles	2-4 vCPU, 4 GB RAM, 100 GB NVMe	from $20-$30	Ensures comfortable operation for multiple users. Sufficient resources for the database and content parsing.
Extended use, integrations, high load, >5 users	4 vCPU, 8 GB RAM, 200 GB NVMe	from $40-$60+	For very large libraries, many users, or if Wallabag is not the only service on this VPS.

Note: Prices are approximate and may vary depending on promotions, data center location, and additional options.

Additional Server Selection Recommendations

1. Disk Type: NVMe is always better. For Wallabag, especially with PostgreSQL, disk subsystem speed is critically important. NVMe drives provide significantly higher read/write speeds compared to SSDs or HDDs, which directly impacts application responsiveness and database performance.
2. Data Center Location: Choose a data center that is geographically closer to you and your users. This will reduce latency and speed up page loading. Valebyte.com offers VPS in various locations.
3. Bandwidth: Most Valebyte.com plans offer 1 Gbps channels, which is more than sufficient for Wallabag.
4. Automatic Backups from Provider: Some VPS plans include automatic daily full server backups. This can be an excellent complement to your own Wallabag backups, providing an additional layer of data protection.
5. Monitoring: Ensure you have access to basic VPS monitoring metrics (CPU, RAM, Disk I/O usage) through the Valebyte.com control panel. This will help you quickly respond to potential issues.

Choosing the right VPS is an investment in the stability and performance of your personal Wallabag service. Valebyte.com provides a reliable infrastructure that is ideal for Wallabag self-hosted.

Conclusion

Installing, configuring, and maintaining Wallabag on a VPS is an excellent way to gain full control over your digital article library, ensuring privacy, no ads, and high performance. By using Docker and Docker Compose, the deployment process becomes simple and reliable, and setting up a reverse proxy with HTTPS guarantees secure access.

Choosing an optimal VPS from Valebyte.com with NVMe drives and sufficient RAM will allow Wallabag to operate quickly and stably even with active use and a large library. Don't forget about regular backups and updates to keep your Wallabag always current and secure.