Linkwarden on VPS: Installation, Configuration, and Maintenance

Installing, configuring, and maintaining Linkwarden on a VPS is the process of deploying a personal, open-source bookmark manager on a virtual private server, providing full control over your saved links, their organization, annotation, and access from anywhere in the world. This approach allows you to create a reliable and private repository for your digital link collection, leveraging the benefits of dedicated resources and the flexibility of your own server.

What is Linkwarden and why do you need it on a VPS?

Linkwarden is a modern, self-hosted bookmark manager developed as open-source software. It provides a powerful and intuitive way to save, organize, and share your web links. Unlike browser bookmarks or proprietary cloud services, Linkwarden allows you to fully own and control your data, which is especially valuable amidst growing concerns about privacy and the longevity of online services.

Why Linkwarden, not cloud services?

Choosing Linkwarden for self-hosting on a VPS is driven by several advantages over traditional cloud solutions and built-in browser features:

• Full data control: All your bookmarks are stored on your own server. This eliminates the risk of data loss due to service shutdown, policy changes, or third-party platform breaches.
• Privacy: No one but you has access to your link collection and information about it. No data collection, no targeted advertising, no analysis of your interests.
• Customization: You can configure Linkwarden to suit your needs, integrate it with other services on your VPS, and use your own domain and SSL certificates.
• Longevity: As long as your VPS is running, your bookmarks are accessible. You are not dependent on external companies and their business models.
• Open Source: Code transparency allows you to verify the absence of hidden features and vulnerabilities, and also fosters community development.

Key Features of Linkwarden

Linkwarden offers a rich set of features that make it a powerful tool for link management:

• Save links: Easily add links via the web interface, browser extensions, or API.
• Full-text search: Powerful search by titles, descriptions, and even the content of saved pages (with ArchiveBox integration).
• Tags and collections: Flexible tools for organizing bookmarks using tags and logical collections.
• Page archiving: Ability to save full copies of web pages (snapshots) so they remain accessible even if the original resource disappears or changes.
• Link checking: Automatic verification of the availability of saved links.
• Sharing: Ability to share links or collections with other users, if needed.
• API: Programmatic interface for integration with other applications and automation.
• Modern interface: Clean and responsive user interface, convenient for use on various devices.

By deploying Linkwarden on a VPS, you get not just a bookmark manager, but a personal knowledge archive, completely under your control.

Linkwarden System Requirements and VPS Configuration Selection

For a successful Linkwarden installation on a VPS, you need to ensure that your server meets the minimum system requirements. Since Linkwarden is most often deployed using Docker and Docker Compose, the requirements primarily concern the resources needed for container operation.

Minimum requirements for installing Linkwarden on a server

For a basic Linkwarden installation, intended for personal use with a small number of bookmarks (up to several thousand) without intensive use of page archiving features, the following minimum VPS characteristics are suitable:

• Operating System: Ubuntu 20.04+, Debian 10+, CentOS 7+ (any modern Linux distribution with Docker support).
• Processor (CPU): 1 vCPU (virtual core).
• Random Access Memory (RAM): 1 GB. This is sufficient for the Docker daemon, Linkwarden container, and its database (PostgreSQL) to run. If intensive page archiving with ArchiveBox is planned, more RAM may be required.
• Disk Space: 20 GB NVMe SSD. NVMe drives are significantly faster than traditional HDDs or SATA SSDs, which positively affects database speed and file access. 20 GB is enough for the system itself, Docker images, and thousands of bookmarks without a large number of saved full-text page copies.
• Network Bandwidth: 100 Mbps. This is more than enough for most home and small office scenarios.

It is important to note that KVM VPS is preferable to OpenVZ, as KVM provides full virtualization and better resource isolation, which is critical for stable operation of Docker containers.

Recommended VPS configurations for Linkwarden under real load

If you plan to use Linkwarden for a large personal collection, for a small team, or with active use of the page archiving feature (saving snapshots), it is recommended to consider more powerful configurations:

• For active personal use (up to 10,000+ bookmarks, moderate archiving):
  • CPU: 2 vCPU
  • RAM: 2-4 GB
  • Disk: 50-100 GB NVMe SSD (for storing archived pages)
  • Network Bandwidth: 200-500 Mbps
• For a small team (up to 5-10 users, intensive archiving):
  • CPU: 4 vCPU
  • RAM: 4-8 GB
  • Disk: 100-200 GB NVMe SSD (the more archives, the more disk space)
  • Network Bandwidth: 500 Mbps - 1 Gbps

The more links you plan to store, especially with full-text archiving, the more disk space you will need. Each archived page can take from several hundred kilobytes to several megabytes.

When choosing a linkwarden vps configuration, pay attention to the following aspects:

1. Disk type: NVMe SSD is always better for databases and applications requiring fast I/O.
2. Server location: Choose a data center geographically close to you or your users to minimize latency.
3. Bandwidth: Ensure that the traffic limit meets your expectations, especially with active access to archives.

Let's consider approximate VPS configurations and their cost, available from hosting providers such as Valebyte.com:

Valebyte.com Plan	vCPU	RAM	NVMe SSD	Bandwidth	Price (approx. per month)	Recommended Linkwarden Use
VPS-1	1	1 GB	25 GB	1 Gbps	$4.99 - $6.99	Personal use, up to 5000 bookmarks, no active archiving.
VPS-2	2	2 GB	50 GB	1 Gbps	$8.99 - $11.99	Active personal use, up to 10000+ bookmarks, moderate archiving.
VPS-3	2	4 GB	80 GB	1 Gbps	$15.99 - $19.99	Use for a small team (2-3 people), moderate/active archiving.
VPS-4	4	8 GB	160 GB	1 Gbps	$29.99 - $39.99	Use for a team (5-10 people), intensive archiving, high loads.

These prices are indicative and may vary depending on promotions, subscription duration, and selected data center location. For linkwarden on a server with a large number of users or extreme data volume, a dedicated server might be required.

Preparing the VPS for Linkwarden Installation via Docker

To install Linkwarden, we will use Docker and Docker Compose. This is the most recommended and convenient deployment method, which provides application isolation, simplifies dependency management, and facilitates updates. It is assumed that you already have a VPS with a Linux operating system installed (e.g., Ubuntu 22.04 LTS).

System Update and Docker/Docker Compose Installation

Before starting the installation, make sure your system is updated and all necessary packages are installed. Connect to the VPS via SSH.

sudo apt update && sudo apt upgrade -y
sudo apt install -y ca-certificates curl gnupg lsb-release

Next, we will install Docker Engine. For Ubuntu/Debian, this is done as follows:

sudo mkdir -p /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
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
sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

Add the current user to the docker group so you don't have to use sudo with every Docker command (remember to log out and log back into your SSH session after this command):

sudo usermod -aG docker $USER

Check the Docker installation:

docker run hello-world

If you see a welcome message, Docker is successfully installed. Now you have everything you need to work with linkwarden docker.

Creating necessary directories and user

For better organization of Linkwarden data, we will create a separate directory for its configuration and data. Also, for increased security, you can create a separate user if you don't want to use root or the main user for Docker operations. In this guide, we will work as the user added to the Docker group.

mkdir -p ~/linkwarden/data
cd ~/linkwarden

This ~/linkwarden/data directory will be used for persistent storage of Linkwarden data, including the PostgreSQL database and archived pages.

Step-by-step Linkwarden Installation on VPS with Docker Compose

Now that the VPS is prepared, we can proceed with the direct Linkwarden installation using Docker Compose. This method allows you to define all services (Linkwarden, database, Redis) in a single configuration file and manage them easily.

Creating the docker-compose.yml file

In the ~/linkwarden directory, create the docker-compose.yml file:

nano docker-compose.yml

Paste the following content. This is a standard configuration for linkwarden self-hosted:

version: '3.8'

services:
  linkwarden:
    image: ghcr.io/linkwarden/linkwarden:latest
    container_name: linkwarden
    restart: unless-stopped
    ports:
      - "3000:3000" # Default port for Linkwarden
    environment:
      # PostgreSQL database settings
      DATABASE_URL: postgresql://linkwarden:your_strong_password@db:5432/linkwarden?schema=public
      # Secret key for authentication. Generate a long and complex key.
      NEXTAUTH_SECRET: your_very_long_and_complex_secret_key
      # Your Linkwarden URL, will be used for link generation and OAuth
      NEXTAUTH_URL: http://localhost:3000 # Temporary, will be changed to your domain later
      # Redis settings
      REDIS_URL: redis://redis:6379/0
      # Other optional environment variables, see Linkwarden documentation
      # LINKWARDEN_ALLOW_REGISTRATION: "true" # Allow new user registration (default false)
      # LINKWARDEN_DEFAULT_THEME: "dark" # Default theme (dark, light, system)
    volumes:
      - ./data/linkwarden:/app/data # Directory for storing Linkwarden user data
    depends_on:
      - db
      - redis

  db:
    image: postgres:16-alpine
    container_name: linkwarden_db
    restart: unless-stopped
    environment:
      POSTGRES_USER: linkwarden
      POSTGRES_PASSWORD: your_strong_password # Must match DATABASE_URL
      POSTGRES_DB: linkwarden
    volumes:
      - ./data/postgres:/var/lib/postgresql/data # Directory for storing PostgreSQL data

  redis:
    image: redis:7-alpine
    container_name: linkwarden_redis
    restart: unless-stopped
    volumes:
      - ./data/redis:/data # Directory for storing Redis data

Be sure to change:

• your_strong_password: Replace with a very strong password for the PostgreSQL database.
• your_very_long_and_complex_secret_key: Generate a long random string (e.g., using openssl rand -base64 32 or an online generator). This key is used for encrypting sessions and other sensitive data.
• NEXTAUTH_URL: http://localhost:3000: At this stage, you can leave it as is. After configuring the reverse proxy and domain, you will change this to https://yourdomain.com.

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

Starting Linkwarden

Now you can start all Linkwarden services using Docker Compose:

docker compose up -d

The -d command runs containers in the background. If you want to see logs in real-time, omit -d, then use Ctrl+C to stop (containers will not be removed).

Check the status of running containers:

docker compose ps

You should see three running containers: linkwarden, linkwarden_db, and linkwarden_redis.

Initial setup and access to Linkwarden

After successfully starting the containers, Linkwarden will be available at your VPS's IP address and port 3000 (e.g., http://YOUR_VPS_IP:3000). Open this address in your browser.

Upon first access, you will be prompted to create an administrator account. Fill out the form using a strong password. After creating the account, you will be redirected to the Linkwarden dashboard.

At this point, linkwarden on the server is already running, but it is only accessible via IP address and without HTTPS. For secure and convenient use, you need to configure a reverse proxy and an SSL certificate.

Configuring Reverse Proxy and HTTPS for Linkwarden on the Server

Accessing Linkwarden via IP address and HTTP is not a secure or professional solution. We will set up a reverse proxy (Nginx or Caddy) to route traffic to Linkwarden and obtain a Let's Encrypt SSL certificate for a secure HTTPS connection. For this, you will need a domain name pointing to your VPS's IP address.

Nginx as Reverse Proxy for Linkwarden

Install Nginx if it's not already installed:

sudo apt install nginx -y

Create a new configuration file for Linkwarden in /etc/nginx/sites-available/:

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

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

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

    location / {
        proxy_pass http://localhost:3000;
        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;
    }
}

Enable the configuration by creating a symbolic link and check Nginx syntax:

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

If there are no errors, restart Nginx:

sudo systemctl restart nginx

Now Linkwarden will be accessible via your domain over HTTP.

Caddy as Reverse Proxy for Linkwarden

Caddy is a modern web server that automatically manages Let's Encrypt SSL certificates, which significantly simplifies HTTPS setup. If you prefer Caddy, first uninstall Nginx if it was installed (sudo apt remove nginx -y).

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

Create or edit the Caddyfile configuration file:

sudo nano /etc/caddy/Caddyfile

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

yourdomain.com {
    reverse_proxy localhost:3000
}

Save the file and apply the Caddy configuration:

sudo systemctl reload caddy

Caddy will automatically obtain and configure an SSL certificate for yourdomain.com, and Linkwarden will be accessible via https://yourdomain.com.

Obtaining an SSL certificate with Let's Encrypt (for Nginx)

If you are using Nginx, you will need Certbot to automatically obtain and renew Let's Encrypt SSL certificates. Install Certbot:

sudo apt install certbot python3-certbot-nginx -y

Run Certbot for your domain:

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

Follow Certbot's instructions. It will automatically modify the Nginx configuration, obtain the certificate, and set up redirection from HTTP to HTTPS. After this, Linkwarden will be accessible via https://yourdomain.com.

Important: After configuring the reverse proxy and HTTPS, update the NEXTAUTH_URL variable in your docker-compose.yml file. Change http://localhost:3000 to https://yourdomain.com (or your actual domain). Then restart the Linkwarden container:

cd ~/linkwarden
docker compose down
docker compose up -d

This will ensure correct operation of all Linkwarden features, including OAuth and correct link generation.

Linkwarden Maintenance: Backups, Updates, and Monitoring

Proper maintenance of your linkwarden vps is key to its stable and secure operation. This includes regular data backups, timely updates, and server status monitoring.

Linkwarden Data Backup

Linkwarden data consists of two main parts: the PostgreSQL database and files stored in the ./data/linkwarden directory (e.g., archived pages). It is important to regularly create backups of both.

Steps to create a backup:

1. Stop Linkwarden (optional, but recommended for consistency):

   cd ~/linkwarden
   docker compose stop linkwarden

2. Create a PostgreSQL database dump:

   docker compose exec db pg_dump -U linkwarden linkwarden > ~/linkwarden_backup/linkwarden_db_$(date +%Y%m%d%H%M%S).sql

   Make sure the ~/linkwarden_backup directory exists. If not, create it: mkdir -p ~/linkwarden_backup.

3. Make a copy of the Linkwarden files directory:

   rsync -av --delete ~/linkwarden/data/linkwarden/ ~/linkwarden_backup/linkwarden_files_$(date +%Y%m%d%H%M%S)/

4. Start Linkwarden:

   docker compose start linkwarden

Automating backups: You can automate this process using Cron jobs. For example, for a daily backup:

crontab -e

Add the following line (replace /home/youruser/linkwarden with your actual path):

0 3 * * * /bin/bash -c "cd /home/youruser/linkwarden && docker compose exec db pg_dump -U linkwarden linkwarden > /home/youruser/linkwarden_backup/linkwarden_db_$(date +%Y%m%d%H%M%S).sql && rsync -av --delete /home/youruser/linkwarden/data/linkwarden/ /home/youruser/linkwarden_backup/linkwarden_files_$(date +%Y%m%d%H%M%S)/"

This will perform a backup every day at 03:00. It is recommended to store backups not only on the same VPS but also on remote storage (S3, Dropbox, another server) to protect against complete VPS failure.

Updating Linkwarden and Docker Containers

Regular updates are important for receiving new features, bug fixes, and security patches.

Updating Linkwarden:

1. Navigate to the Linkwarden directory:

   cd ~/linkwarden

2. Stop current containers:

   docker compose down

3. Pull the latest images:

   docker compose pull

4. Start the updated containers:

   docker compose up -d

Updating the system and Docker: Regularly update the operating system and the Docker Engine itself. This can be done monthly or as important updates are released:

sudo apt update && sudo apt upgrade -y

Monitoring VPS Resources

Monitoring VPS resources allows you to track Linkwarden's performance and prevent problems related to resource shortages. You can use tools like htop, glances, or install a full-fledged monitoring system, such as Netdata.

• CPU Usage: Monitor CPU load. High load can indicate intensive activity (e.g., indexing new archives) or a problem.
• RAM Usage: Control RAM usage. If Linkwarden or the database consumes too much RAM, it can slow down operations or cause failures.
• Disk I/O: For Linkwarden, especially with active archiving, disk operation speed is important. High disk load can slow down saving and searching bookmarks.
• Disk Space: Regularly check free disk space. Page archives can quickly fill up the disk.

Maintenance recommendations:

1. Regular backups: Set a schedule for daily or weekly backups and ensure they are stored in a reliable location.
2. Monitoring: Set up notifications for critical metrics (e.g., if disk is 90% full or RAM is 95% utilized).
3. Updates: Keep an eye on official Linkwarden and Docker releases to apply updates promptly.
4. Logs: Regularly review container logs (docker compose logs -f) to identify errors and issues.
5. Firewall: Configure a firewall (UFW) on the VPS to allow access only to necessary ports (22 for SSH, 80/443 for the web server).

Which VPS Config for Real Load: Detailed Analysis

Choosing the optimal linkwarden vps configuration for real load depends on many factors, including the number of users, the volume of saved bookmarks, the intensity of web page archiving, and general performance requirements. Underestimating needs can lead to slowdowns, outages, and the need for costly upgrades.

Assessing Needs for Linkwarden

To correctly choose a VPS configuration, ask yourself the following questions:

• How many users will use Linkwarden?
  • 1-2 users (personal use): Minimal requirements.
  • 3-10 users (small team/family): More stable resources will be needed.
  • 10+ users (large team/community): High demands on CPU, RAM, and disk subsystem.
• How actively will the page archiving feature (snapshots) be used?
  • Rarely or never: Disk space is not a critical factor.
  • Occasionally, for important links: Moderate disk space will be needed.
  • Constantly, for most links: A large and fast NVMe SSD is required.
• What volume of data do you plan to store?
  • Thousands of bookmarks without archives: Several tens of megabytes for the database.
  • Tens of thousands of bookmarks with moderate archiving: Several gigabytes.
  • Hundreds of thousands of bookmarks with full archiving: Tens and hundreds of gigabytes.
• What are your expectations for response speed?
  • Fast access to interface and search: Requires a fast processor and SSD.
  • Instant saving and indexing: Requires good CPU, RAM, and NVMe SSD.

Examples of Usage Scenarios and Corresponding Plans

Let's consider several typical scenarios and suggest suitable linkwarden vps configurations:

1. Scenario 1: Personal use, up to 5000 bookmarks, minimal archiving.
   • Characteristics: 1 vCPU, 1 GB RAM, 25-30 GB NVMe SSD.
   • Justification: Linkwarden in this case will work quickly and efficiently. The database will not be large, archives will take up minimal space.
   • Recommended Valebyte.com plan: VPS-1 (from $4.99/month). This will be sufficient for comfortable work.
2. Scenario 2: Active personal use, up to 20,000 bookmarks, moderate archiving (20-30% of links).
   • Characteristics: 2 vCPU, 2-4 GB RAM, 50-80 GB NVMe SSD.
   • Justification: Additional CPU and RAM will ensure smooth operation with more intensive use, especially during indexing or searching large amounts of data. Increased disk space is needed for archives.
   • Recommended Valebyte.com plan: VPS-2 or VPS-3 (from $8.99-$15.99/month). The choice between 2 and 4 GB RAM depends on how often and how much you will archive.
3. Scenario 3: Small team (3-5 users), up to 50,000 bookmarks, active archiving.
   • Characteristics: 2-4 vCPU, 4-8 GB RAM, 100-200 GB NVMe SSD.
   • Justification: Several users simultaneously can create a load on the database and file system. More RAM will help cache data, and a fast disk is critical for archiving performance.
   • Recommended Valebyte.com plan: VPS-3 or VPS-4 (from $15.99-$29.99/month). If very intensive archiving is planned, it's better to choose 8 GB RAM and 200 GB SSD.
4. Scenario 4: Large team (5-10+ users), hundreds of thousands of bookmarks, intensive archiving.
   • Characteristics: 4+ vCPU, 8-16 GB RAM, 200+ GB NVMe SSD.
   • Justification: With such data volume and number of users, Linkwarden becomes a critically important service. Maximum resources are required to ensure stability and high performance.
   • Recommended Valebyte.com plan: VPS-4 and above (from $29.99/month) or even consider a dedicated server if the load is very high.

To optimize costs, you can always start with a minimal plan and upgrade your linkwarden on the server as your needs grow. Most VPS providers, including Valebyte.com, offer flexible plans and the ability to scale resources without reinstalling the system. Remember that disk space for archives is the fastest-growing resource, so plan for it with a margin or schedule regular cleanup/archiving of old snapshots.

Conclusion

Installing Linkwarden on a VPS using Docker Compose is a reliable and flexible way to create your own bookmark manager, with full control over your data. For most users, a VPS with 2 vCPU, 2-4 GB RAM, and 50-80 GB NVMe SSD will be the optimal choice, providing excellent performance and sufficient space for active use. Regular backups and timely updates are key elements for the long-term stability of your self-hosted solution.