PeerTube on VPS: installation, configuration, and maintenance

Installing PeerTube on a VPS allows you to deploy your own decentralized video platform, providing full control over content, data, and privacy, as well as offering flexibility in configuration and scaling to meet the needs of your project or community.

What is PeerTube and Why Do You Need It?

PeerTube is an innovative, open-source decentralized video platform developed by the French non-profit organization Framasoft. Unlike centralized giants like YouTube or Vimeo, PeerTube does not store all videos on a single server. Instead, it uses a federated model (Fediverse), where many independent servers (instances) exchange content, allowing users to watch videos from any instance they are connected to.

Decentralized Video Platform and Its Advantages

The main difference of PeerTube lies in its architecture. Each PeerTube instance operates independently but can be federated with other instances. This means that a video published on one server can be discovered and watched by users of other servers if they are part of the federation. This system offers several key advantages:

• Censorship Resistance: The absence of a single point of control makes the platform more resilient to blocking and censorship. If one instance is blocked, the others continue to operate.
• Data Control: Instance owners have full control over their data and content, without being dependent on corporate rules.
• Peer-to-Peer (P2P) Technology: PeerTube uses WebTorrent technology for video distribution. This means that when watching videos, users can simultaneously act as seeds, distributing parts of the video to other viewers. This significantly reduces server load, especially with a large number of simultaneous views, and allows for efficient use of network resources.
• No Ads or Trackers: Most PeerTube instances are free from intrusive advertising and user tracking mechanisms, ensuring better privacy.
• Flexibility and Customization: The open-source nature allows for customizing and modifying the platform to specific needs, adding themes, plugins, and features.

For those looking for collaboration and file-sharing solutions on a VPS, we recommend checking out the installation of Filebrowser on a VPS, which can be a useful addition to your infrastructure.

Why Self-Host PeerTube on a VPS?

Deploying PeerTube self-hosted on a VPS (Virtual Private Server) is an optimal solution for many scenarios. Firstly, it provides full control over the environment, allowing you to choose the operating system, configure security settings, and optimize performance for your tasks. Secondly, a VPS ensures stability and dedicated resources, which is critically important for video hosting, especially if you plan to serve an active community or upload a lot of content.

By having PeerTube self-hosted on your own server, you can:

• Create a niche video platform for your community or project.
• Host educational content without restrictions.
• Provide private video hosting for corporate needs.
• Use PeerTube as an alternative to centralized platforms, supporting a decentralized internet.

PeerTube installation on a VPS via Docker/Compose significantly simplifies the deployment and management process, minimizing manual configurations and ensuring high portability.

PeerTube System Requirements: Which VPS to Choose?

Choosing the right VPS for PeerTube is a crucial factor that directly impacts the performance and stability of your video platform. System requirements can vary significantly depending on the expected load: number of users, volume of video content, frequency of uploads, and views.

Minimum Requirements for PeerTube Installation

For a basic PeerTube installation and a small instance intended for personal use or a very small community (up to 5-10 active users, a few dozen videos), the minimum requirements are as follows:

• Processor: 1-2 vCPU (virtual cores). PeerTube uses Node.js for the backend and FFmpeg for video transcoding, which can be resource-intensive.
• RAM: 2 GB. This is sufficient for Node.js, PostgreSQL, and Redis. More will be needed if transcoding is planned.
• Disk Space: 50-100 GB NVMe/SSD. NVMe is significantly faster and preferable for databases and frequent access to video files. The volume depends on the quantity and quality of videos you plan to store.
• Network Bandwidth: 100-200 Mbps. This will be sufficient for a small instance, but P2P technology will help reduce the outgoing traffic load.
• Operating System: Ubuntu 22.04 LTS (recommended), Debian 11/12, or CentOS 8/9.

It's important to remember that these are absolute minimums. With active use, especially when uploading new videos, transcoding, and a large number of simultaneous views, these resources will quickly be exhausted.

Recommended Configurations for Real-World Load

For a PeerTube instance that will serve a medium-sized community (50-100 active users, hundreds of videos, regular uploads) or be used for educational/corporate purposes, the following VPS configurations are recommended:

• Processor: 4 vCPU. This will provide sufficient power for parallel transcoding, Node.js request processing, and database operations.
• RAM: 4-8 GB. More RAM will allow for data caching, speeding up database operations and transcoding.
• Disk Space: 200-500 GB NVMe/SSD. Disk space is the most critical resource for video hosting. For storing large volumes of video content, consider scaling disk space or connecting external storage.
• Network Bandwidth: 500 Mbps - 1 Gbps. High network speed is important for fast video uploads and ensuring a comfortable viewing experience for all users.
• Operating System: Ubuntu 22.04 LTS.

If you plan to create a large instance with thousands of videos and hundreds of active users, you will need a dedicated server or a clustered architecture with a distributed database and object storage (e.g., S3-compatible storage) for video files. In such a case, PeerTube on a server will require a more complex architecture.

Comparison Table of Valebyte.com VPS Plans for PeerTube

Valebyte.com offers various VPS plans that are ideal for deploying PeerTube. Below is a table with recommended configurations and approximate prices to help you choose the optimal option.

Valebyte.com Plan	vCPU	RAM	Disk (NVMe)	Traffic	Price (approx.)	PeerTube Recommendation
Entry-Level	2	4 GB	100 GB	1 TB	from $15/month	Personal use, small projects (up to 20 videos, 10-20 users)
Standard	4	8 GB	250 GB	2 TB	from $30/month	Medium instance, active community (up to 100 videos, 50-100 users)
Pro	6	16 GB	500 GB	4 TB	from $60/month	Large instance, high content and user volume (hundreds of videos, 100+ users)
Enterprise (Dedicated)	8+	32+ GB	1 TB+	10 TB+	from $120/month	High-load instance, public platform, mission-critical projects

When choosing a plan, always consider the potential growth of your instance. It's better to select a VPS with a slight surplus of resources than to face performance issues in the future. All Valebyte.com plans include high-speed NVMe drives, which is critically important for PeerTube's performance.

Preparing Your VPS for PeerTube Installation via Docker

Before proceeding with the actual PeerTube Docker installation, you need to prepare your VPS. This stage includes choosing the operating system, basic security configuration, and installing necessary tools such as Docker and Docker Compose.

Choosing the Operating System and Initial Setup

For PeerTube, it is recommended to use Linux distributions with Long Term Support (LTS). The most popular and well-supported are Ubuntu Server 22.04 LTS or Debian 11/12. In this guide, we will use Ubuntu 22.04 LTS.

After deploying your VPS and logging in via SSH for the first time (usually as the root user), follow these steps for initial setup:

1. System Update: Always start by updating all packages to their latest versions.

   sudo apt update && sudo apt upgrade -y

2. Create a New User with Sudo Privileges (Optional, but Recommended): Operating as root is insecure. Create a regular user and add them to the sudo group.

   sudo adduser peertubeuser
   sudo usermod -aG sudo peertubeuser

   Then, log out from root and log in as the new user.
3. Firewall Configuration (UFW): Enable the firewall and allow the necessary ports. For PeerTube, SSH (22), HTTP (80), and HTTPS (443) ports are required.

   sudo ufw allow OpenSSH
   sudo ufw allow http
   sudo ufw allow https
   sudo ufw enable

   Ensure SSH is allowed before enabling UFW, otherwise you might lose access to the server.

Installing Docker and Docker Compose

PeerTube officially recommends PeerTube Docker deployment, as it significantly simplifies dependency management and provides an isolated environment. Let's install Docker Engine and Docker Compose.

1. Install Docker Engine:

   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 docker-ce-rootless-extras; do sudo apt remove $pkg; done

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

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

2. Add User to Docker Group:

   To avoid using sudo every time you work with Docker, add your user to the docker group:

   sudo usermod -aG docker ${USER}

   Apply changes by logging out from SSH and logging in again, or by rebooting the system.

3. Verify Docker Installation:

   docker run hello-world

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

Your VPS is now ready for PeerTube deployment. For those interested in other project management solutions on a VPS, check out the installation of Docmost on a VPS.

Step-by-Step PeerTube Docker Installation: From Image to Launch

The simplest and recommended way to install PeerTube is by using Docker Compose. This method allows you to deploy all PeerTube components (application, PostgreSQL database, Redis) in isolated containers, significantly simplifying management and updates.

Creating Directories and Configuration Files

First, create a working directory for PeerTube and subdirectories for data storage, which is important for persistence (data will not be deleted when containers are recreated).

mkdir -p ~/peertube
cd ~/peertube
mkdir -p data/postgresql data/redis data/videos data/streaming-playlists data/avatars data/tmp

Now, let's create the main PeerTube configuration file. Copy the example configuration file from the PeerTube repository. Make sure you are using the current PeerTube version. In this example, we'll use version 6.1.1 (current at the time of writing, check on the official GitHub).

wget https://github.com/Chocobozzz/PeerTube/releases/download/v6.1.1/config/production.yaml.example -O config/production.yaml

Edit the config/production.yaml file. This is the most important configuration step. Open it with any text editor (e.g., nano):

nano config/production.yaml

In this file, you need to change the following parameters:

• webserver.hostname: Specify the domain name of your PeerTube instance (e.g., my.peertube.example.com).
• webserver.port: Leave as 80 (or 443 if Nginx/Caddy are not used for SSL).
• database.hostname: Specify peertube-postgres (the Docker service name).
• database.password: Specify a strong password for the PostgreSQL user.
• redis.hostname: Specify peertube-redis (the Docker service name).
• secrets.secret: Generate a long random string (e.g., using openssl rand -base64 32) and paste it here.
• smtp: Configure SMTP server parameters if you want PeerTube to send emails (e.g., for user registration, password resets).
• storage: Verify the directory paths; they should match those we created.

Save changes and close the file (Ctrl+X, Y, Enter for nano).

Configuring docker-compose.yml for PeerTube

Now, let's create the docker-compose.yml file, which will define all PeerTube services.

nano docker-compose.yml

Paste the following content. Ensure that the PeerTube image version (image: chopeur/peertube:6.1.1) matches the version for which you downloaded production.yaml.

version: "3.7"

services:
  peertube:
    image: chopeur/peertube:6.1.1 # Check for the latest version on Docker Hub or GitHub
    container_name: peertube
    restart: always
    environment:
      - NODE_ENV=production
      - PEERTUBE_DB_HOSTNAME=peertube-postgres
      - PEERTUBE_DB_USERNAME=peertube
      - PEERTUBE_DB_PASSWORD=${PEERTUBE_DB_PASSWORD} # Will be taken from .env
      - PEERTUBE_REDIS_HOSTNAME=peertube-redis
    volumes:
      - ./config:/app/config
      - ./data/videos:/app/data/videos
      - ./data/streaming-playlists:/app/data/streaming-playlists
      - ./data/avatars:/app/data/avatars
      - ./data/tmp:/app/data/tmp
    ports:
      - "127.0.0.1:9000:9000" # PeerTube listens on port 9000 inside the container
    depends_on:
      - peertube-postgres
      - peertube-redis

  peertube-postgres:
    image: postgres:15-alpine
    container_name: peertube-postgres
    restart: always
    environment:
      - POSTGRES_USER=peertube
      - POSTGRES_PASSWORD=${PEERTUBE_DB_PASSWORD} # Will be taken from .env
      - POSTGRES_DB=peertube
    volumes:
      - ./data/postgresql:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U peertube"]
      interval: 10s
      timeout: 5s
      retries: 5

  peertube-redis:
    image: redis:7-alpine
    container_name: peertube-redis
    restart: always
    volumes:
      - ./data/redis:/data
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 10s
      timeout: 5s
      retries: 5

Pay attention to PEERTUBE_DB_PASSWORD. For security, create an .env file in the same directory as docker-compose.yml and specify the password there:

nano .env

PEERTUBE_DB_PASSWORD=your_very_strong_database_password

Save and close .env. Ensure this password matches database.password in production.yaml.

Database Initialization and PeerTube Launch

After configuring all files, you can launch PeerTube. First, let's initialize the database. This only needs to be done once during the initial installation.

docker compose run --rm peertube yarn cli peertube:database:migrate

Then, create the first administrator. Be sure to use a strong password.

docker compose run --rm peertube yarn cli peertube:user:create --username root --password 'your_strong_admin_password' --email [email protected] --role admin

Now, start all PeerTube services in the background:

docker compose up -d

Check the status of the containers:

docker compose ps

All containers should be in Up status. PeerTube is now running on your VPS, but it's only accessible locally on port 9000 (127.0.0.1:9000). To access it from outside and ensure security, you'll need to configure a reverse proxy with HTTPS.

Configuring Reverse Proxy (Nginx/Caddy) and HTTPS for PeerTube

To ensure secure and convenient access to your PeerTube instance from the internet, as well as for automatic SSL certificate handling, it is highly recommended to use a reverse proxy. We will cover the configuration of Nginx and Caddy, two popular options.

Why is a Reverse Proxy Needed?

• Security: It hides the real IP address and port of your PeerTube server, acting as an intermediary.
• SSL/TLS Encryption (HTTPS): A reverse proxy can handle SSL certificates (e.g., from Let's Encrypt), providing a secure encrypted connection between users and PeerTube.
• Load Balancing: In more complex scenarios, a reverse proxy can distribute requests among multiple PeerTube backend servers.
• Caching: It can cache static content, reducing the load on PeerTube.

Before configuring, ensure that your domain (e.g., my.peertube.example.com) points to your VPS's IP address.

Nginx Configuration for PeerTube

If Nginx is not yet installed, install it:

sudo apt install nginx -y

Create a new Nginx configuration file for your domain:

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

Paste the following content, replacing my.peertube.example.com with your domain:

server {
    listen 80;
    listen [::]:80;
    server_name my.peertube.example.com;

    location /.well-known/acme-challenge/ {
        root /var/www/certbot;
    }

    location / {
        return 301 https://$host$request_uri;
    }
}

server {
    listen 443 ssl http2;
    listen [::]:443 ssl http2;
    server_name my.peertube.example.com;

    ssl_certificate /etc/letsencrypt/live/my.peertube.example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/my.peertube.example.com/privkey.pem;
    ssl_trusted_certificate /etc/letsencrypt/live/my.peertube.example.com/chain.pem;

    ssl_session_timeout 1d;
    ssl_session_cache shared:SSL:10m;
    ssl_session_tickets off;

    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers "ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384";
    ssl_prefer_server_ciphers on;

    add_header Strict-Transport-Security "max-age=63072000" always;
    add_header X-Content-Type-Options nosniff;
    add_header X-XSS-Protection "1; mode=block";
    add_header X-Frame-Options DENY;

    location / {
        proxy_pass http://127.0.0.1:9000;
        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";
    }
}

Create a symbolic link to sites-enabled and remove the default config:

sudo ln -s /etc/nginx/sites-available/peertube.conf /etc/nginx/sites-enabled/
sudo rm /etc/nginx/sites-enabled/default

Test the Nginx configuration and reload it:

sudo nginx -t
sudo systemctl restart nginx

Your PeerTube is now accessible via Nginx, but without HTTPS yet. We will configure it in the Let's Encrypt section.

Caddy Configuration for PeerTube

Caddy is a modern web server that automatically manages Let's Encrypt SSL certificates. This makes it very convenient for deployment. If you haven't installed Caddy yet, do so:

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

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

sudo nano /etc/caddy/Caddyfile

Remove all existing content and paste the following, replacing my.peertube.example.com with your domain:

my.peertube.example.com {
    reverse_proxy 127.0.0.1:9000 {
        # WebSocket support
        header_up Upgrade {http.request.header.Upgrade}
        header_up Connection {http.request.header.Connection}
    }
}

Save and close the file. Test the Caddy configuration and restart it:

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

Caddy will automatically obtain and configure SSL certificates for your domain. For those using a VPS for other web applications, such as Wiki.js on a VPS, configuring a reverse proxy is also standard practice.

Obtaining and Automatically Renewing Let's Encrypt SSL Certificates

If you are using Nginx, you will need Certbot to obtain and manage Let's Encrypt SSL certificates. Caddy handles this automatically.

For Nginx:

1. Install Certbot:

   sudo apt install certbot python3-certbot-nginx -y

2. Obtain Certificate:

   sudo certbot --nginx -d my.peertube.example.com

   Follow the on-screen instructions. Certbot will automatically configure Nginx for HTTPS and add a rule for automatic certificate renewal to Cron.

3. Verify Automatic Renewal:

   sudo systemctl status certbot.timer

   You should see that the timer is active. This ensures that your certificates will automatically renew before expiration.

Your PeerTube should now be accessible via HTTPS through your domain.

PeerTube Maintenance: Backups, Updates, and Monitoring

Effective maintenance of a PeerTube instance on a VPS is critically important for its long-term stability and security. This includes regular data backups, timely updates, and continuous performance monitoring.

PeerTube Backup Strategies

Backups are your insurance against data loss. For PeerTube, several key components need to be backed up:

1. PostgreSQL Database: Contains all information about users, videos, comments, and instance settings.
2. PeerTube Configuration Files: The config/production.yaml file and other settings.
3. Video Files: Directories data/videos, data/streaming-playlists, data/avatars. These are the largest data volumes.

Recommended backup strategy:

Step 1: Stop PeerTube (for data consistency)

cd ~/peertube
docker compose stop peertube

Step 2: Create a PostgreSQL Database Dump

docker compose exec -T peertube-postgres pg_dumpall -U peertube > ~/peertube_backup/peertube_db_$(date +%F).sql

Step 3: Archive Configuration and Media Files

tar -czvf ~/peertube_backup/peertube_config_$(date +%F).tar.gz ~/peertube/config
tar -czvf ~/peertube_backup/peertube_media_$(date +%F).tar.gz ~/peertube/data/videos ~/peertube/data/streaming-playlists ~/peertube/data/avatars

Step 4: Start PeerTube

cd ~/peertube
docker compose start peertube

Step 5: Move Backups to Remote Storage

It is critically important not to store backups on the same server where PeerTube is located. Use remote storage such as S3-compatible services, SFTP servers, or specialized tools. To automate this process, you can use Restic on a VPS, which provides incremental and encrypted backups.

Configure a backup script and add it to Cron for daily or weekly execution.

PeerTube and Docker Image Update Process

Updating PeerTube involves updating Docker images and performing database migrations. Always check the official PeerTube documentation on GitHub before updating, as the process may change.

General Update Process:

1. Stop PeerTube:

   cd ~/peertube
   docker compose stop

2. Create a Backup: Always perform a full backup before updating!
3. Update Docker Images: Edit docker-compose.yml and change the PeerTube image version (e.g., from 6.1.1 to 6.2.0). Then, pull the new images:

   docker compose pull

4. Perform Database Migrations:

   docker compose run --rm peertube yarn cli peertube:database:migrate

5. Start PeerTube:

   docker compose up -d

6. Clean Up Old Images (Optional):

   docker image prune

Also, don't forget to update the operating system itself and its packages:

sudo apt update && sudo apt upgrade -y

Monitoring VPS Performance and Resources

Continuous monitoring of your VPS will help you promptly identify performance issues, bottlenecks, and potential security threats. Key metrics for monitoring include:

• CPU Usage: High CPU load can indicate active transcoding, a large number of requests, or application issues.
• RAM Usage: Insufficient RAM will lead to swap usage, which will significantly slow down server performance.
• Disk Usage: Ensure you have enough free space, especially for video files. Monitoring disk I/O operations is also important.
• Network Traffic: Monitoring inbound and outbound traffic will help understand network load and P2P distribution efficiency.
• Service Availability: Ensure that PeerTube, PostgreSQL, and Redis containers are always running.

For monitoring, you can use tools such as:

• htop, glances: For interactive real-time resource monitoring.
• Prometheus + Grafana: For comprehensive metric collection and visualization.
• Netdata on VPS: A lightweight yet powerful tool for real-time monitoring with a user-friendly web interface.

Regularly check the logs of PeerTube, PostgreSQL, and Nginx/Caddy containers for errors or warnings:

docker compose logs -f peertube

This will help you respond promptly to any issues that arise.

Optimizing PeerTube on the Server and Scaling

As your PeerTube instance grows, performance optimization and scaling become increasingly relevant. Efficient resource management will ensure stable platform operation even under high load.

Configuring Video Transcoding and Storage

Video transcoding is one of the most resource-intensive processes in PeerTube. When a video is uploaded, PeerTube creates several versions of the file in different resolutions and formats for compatibility with various devices and network speeds.

• Using GPU for Transcoding: If your VPS supports GPU passthrough or you are using a dedicated server with a GPU, you can configure FFmpeg to use hardware acceleration for transcoding. This will significantly reduce CPU load and speed up video processing. However, this requires more complex Docker and driver configuration.
• Limiting Concurrent Transcodes: In the config/production.yaml file, you can configure transcoding parameters, including the number of concurrent tasks. Reducing this number will lower peak CPU load but increase waiting times for uploaded videos.
• Configuring Transcoding Quality: You can define which resolutions and bitrates will be generated. If you don't need 4K video, you can disable these options to save space and resources.
• External Object Storage: For scalable video file storage, it is recommended to use S3-compatible object storage (e.g., Amazon S3, DigitalOcean Spaces, MinIO). PeerTube supports such integration, allowing media files to be stored separately from the main server, significantly saving VPS disk space and simplifying backups.

Example object_storage configuration in config/production.yaml:

object_storage:
  enabled: true
  endpoint: 's3.eu-central-1.amazonaws.com' # or your endpoint
  bucket_name: 'peertube-videos'
  access_key_id: 'YOUR_ACCESS_KEY_ID'
  secret_access_key: 'YOUR_SECRET_ACCESS_KEY'
  # ... other settings, e.g., region, force_path_style, etc.

Also, remember to configure the corresponding environment variables in docker-compose.yml for PeerTube so it can access your S3 keys.

Expanding Disk Space and Network

As your video collection grows, disk space will become the primary bottleneck. If you are not using external object storage, you will need to:

• VPS Scaling: Upgrade your VPS plan on Valebyte.com to a larger one that offers more NVMe disk space.
• Attaching Additional Disks: Some providers allow attaching additional disks (Block Storage) to an existing VPS. You can mount them to the data/videos directory.

Network bandwidth is also critical. Although PeerTube uses P2P for distribution, the server will still handle a significant amount of traffic, especially for the first viewer or if the P2P network is not dense enough. Ensure that your VPS plan offers sufficient bandwidth (minimum 500 Mbps, ideally 1 Gbps) and adequate monthly traffic volume.

Using CDN and Other Scaling Solutions

For global content distribution and to reduce the load on your server, consider using a CDN (Content Delivery Network). A CDN caches your content (e.g., video files) on servers located closer to users, which speeds up downloads and reduces latency.

PeerTube can be configured to work with a CDN by redirecting media file requests through a CDN provider. This is especially useful if your audience is geographically distributed.

In cases of very high load and the need for maximum fault tolerance, more complex architectures can be considered:

• Docker Swarm or Kubernetes Cluster: For container orchestration and horizontal scaling of PeerTube.
• Dedicated Servers: For maximum performance and control over hardware resources.

However, for most users and communities, a well-configured PeerTube VPS with sufficient resources and external object storage will be more than adequate.

Conclusion

Installing PeerTube on a VPS using Docker Compose is a reliable and flexible way to deploy your own decentralized video platform. Choosing a suitable VPS plan with NVMe drives and sufficient RAM, along with proper reverse proxy and HTTPS configuration, ensures stable and secure operation. Regular backups and monitoring guarantee the longevity of your instance, while optimizing transcoding and using external storage will allow you to scale as your community grows.