Beszel on VPS: installation, setup, and and maintenance

Beszel on VPS — this is the deployment and configuration of a decentralized platform for creating social networks and forums on your own virtual server, which provides full control over data, privacy, and functionality without reliance on third-party services.

In the era of digital communications, when issues of privacy, data control, and censorship are becoming increasingly acute, the demand for decentralized and self-hosted solutions is growing. Beszel is precisely such a platform. It provides tools for creating your own independent social networks, forums, or micro-communities, where you fully manage the rules, data, and infrastructure. Hosting Beszel on a Virtual Private Server (VPS) from Valebyte.com allows for maximum flexibility, performance, and security, transforming your VPS into a full-fledged node of a decentralized network.

This article will serve as a comprehensive guide to installing, configuring, and maintaining Beszel on a VPS. We will delve into what Beszel is, what system resources it requires, how to perform Beszel installation using Docker and Docker Compose, set up secure access via a reverse proxy with HTTPS, and how to ensure the platform's uninterrupted operation with backups and regular updates. Special attention will be paid to choosing the optimal VPS configuration for various load scenarios to ensure your Beszel project is stable and performant.

The goal of this guide is to provide you with all the necessary knowledge and practical steps to successfully launch your own Beszel instance on a server, whether for personal use, a small community, or a large project.

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

Beszel is a relatively new but rapidly developing platform for creating decentralized and federated social networks. Unlike traditional centralized social media giants, Beszel gives users and administrators full control over their data and communications. The main idea behind Beszel is to provide everyone with the ability to run their own "instance" or "server" that can interact with other Beszel instances (federation) while maintaining its independence.

Features and Benefits of Beszel Self-Hosted

When you choose Beszel self-hosted on a VPS, you gain a number of significant advantages:

• Full Data Control: All data (posts, profiles, media files) are stored on your VPS, not on third-party servers. This is critically important for privacy and security.
• No Censorship: You set the moderation rules for your instance. This provides freedom of speech within your community.
• Flexibility and Customization: Beszel offers extensive options for customizing its appearance and functionality. You can adapt the platform to the unique needs of your community.
• Resilience to Failures: The decentralized nature means that a failure of one instance does not lead to the shutdown of the entire Beszel network.
• Cost-Effectiveness: In the long run, hosting Beszel on your own VPS can be more cost-effective than using paid centralized platforms, especially for actively growing communities.

Use Cases for Beszel on a Server

Beszel on a server opens up many possibilities for various users and organizations:

• Private Communities and Forums: Create a closed space for family, friends, colleagues, or like-minded individuals to communicate safely, exchange information, and share media files. Unlike traditional forums such as Flarum or Discourse, Beszel offers a more modern, federated approach.
• Alternative to Centralized Social Networks: If you are dissatisfied with the privacy or moderation policies of large social networks, Beszel can become your personal or corporate alternative, allowing you to control your digital identity.
• Blogs and Micro-communities: Use Beszel as a platform for publishing short notes, news, and ideas, where users can comment and interact, forming small but active communities.
• Development and Testing: Developers can use Beszel as a sandbox for experimenting with decentralized technologies, testing new features, or integrations.
• Educational Projects: Create a platform for sharing knowledge and experience within an educational institution or a group of students, providing a safe and controlled environment.

By choosing Beszel on VPS, you are betting on independence, control, and scalability, which is especially relevant in today's digital landscape. This allows you not just to be a part of the internet, but to actively shape it, creating your own corners of the digital world.

System Requirements for Beszel: How to Choose the Optimal VPS?

Choosing the right VPS for Beszel on a server is a crucial step to ensure stable and performant operation of your platform. While Beszel can run on relatively modest resources for a small number of users, scaling requires a careful approach to VPS configuration. We will cover minimum and recommended requirements, and provide recommendations for choosing the disk subsystem and network.

Minimum and Recommended VPS Resources

Resource requirements for Beszel installation largely depend on the expected load — the number of active users, frequency of publications, volume of media content, and degree of federation with other instances.

For Personal Use or Small Community (up to 10-20 active users):

• Processor (vCPU): 1-2 cores. Beszel is not extremely resource-intensive for small loads, but multiple cores will provide better responsiveness.
• Random Access Memory (RAM): 2 GB. This is sufficient for Beszel, the database (PostgreSQL), and Docker containers.
• Disk Space: 25-50 GB NVMe SSD. For storing the OS, Beszel, the database, and a small amount of user data. NVMe is critically important for database performance and fast file access.
• Network Bandwidth: 100 Mbps. This will be more than enough for light traffic.

For a Medium Community (up to 50-100 active users):

• Processor (vCPU): 2-4 cores. This will allow for efficient processing of a larger number of requests and background tasks.
• Random Access Memory (RAM): 4-8 GB. This will provide sufficient cache for the database and allow Beszel to operate without slowdowns during peak loads.
• Disk Space: 50-100 GB NVMe SSD. Considering the growth of user content and potential storage of media files.
• Network Bandwidth: 200-500 Mbps. For more active data exchange and federation.

For a Large Community or High-Load Project (over 100 active users):

• Processor (vCPU): 4-8+ cores. The more cores, the better the parallel processing of requests.
• Random Access Memory (RAM): 8-16+ GB. A key factor for database performance and scalability.
• Disk Space: 100-200+ GB NVMe SSD. Disk scaling or the use of object storage for media files may be required.
• Network Bandwidth: 1 Gbps. High bandwidth is necessary for active federation, a large number of uploads, and downloads.

The Importance of NVMe SSD and Network Bandwidth

NVMe SSD: This is not just a recommendation, but practically a mandatory requirement for any modern web platform, including Beszel. The database (PostgreSQL) used by Beszel actively works with the disk. A slow disk (e.g., a regular HDD or even a SATA SSD) will be a bottleneck, leading to interface delays, slow page loading, and poor responsiveness. NVMe SSD provides significantly higher read/write speeds and low latency, which is critically important for database performance and the overall speed of Beszel.

Network Bandwidth: For Beszel VPS, especially in the case of federation with other instances and active media content exchange, high network speed plays an important role. Low bandwidth can lead to slow loading of images and videos, delays in synchronization with other servers, and a general deterioration of the user experience. Valebyte.com offers VPS with high-speed network channels, which is a significant advantage for platforms like Beszel.

When choosing a VPS, it's always wise to allow for a small reserve of resources, especially RAM and disk space, to avoid problems during unexpected growth in activity. Valebyte.com offers flexible plans that allow you to easily scale resources as your Beszel project grows.

Preparing Your VPS for Beszel Installation

Before proceeding with Beszel installation, your VPS must be properly prepared. This stage includes choosing the operating system, initial security setup, and installing necessary dependencies such as Docker. We will use the Ubuntu Server 22.04 LTS distribution, as it is one of the most popular and well-supported for server tasks.

Operating System Selection and Initial Setup

For Beszel, a stable Linux distribution is recommended. Ubuntu Server LTS (Long Term Support) versions 20.04 or 22.04 are excellent choices due to their reliability, large community, and up-to-date packages.

1. Connecting to your VPS:

Log in to your VPS via SSH using the root account or a user with sudo privileges.

ssh root@your_ip_address

2. Updating the System:

First, update all installed packages to their latest versions:

sudo apt update
sudo apt upgrade -y

3. Creating a New User with Sudo Privileges (Recommended):

Working as root is unsafe. Create a new user and add them to the sudo group:

sudo adduser beszeluser
sudo usermod -aG sudo beszeluser

Now you can log out of root and log in as the new user:

exit
ssh beszeluser@your_ip_address

4. Configuring the Firewall (UFW):

A firewall is necessary to protect your server from unauthorized access. Allow SSH, HTTP, and HTTPS traffic:

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

Confirm activation (y). Check the firewall status:

sudo ufw status

You should see that SSH, HTTP, and HTTPS rules are allowed.

Installing Docker and Docker Compose for Beszel Docker

Beszel is ideally suited for deployment using Docker, which simplifies dependency management and provides isolation. For Beszel Docker, you will need to install Docker Engine and Docker Compose.

1. Installing Docker Engine:

Install the necessary packages for Docker:

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, Docker CLI, and containerd:

sudo apt update
sudo apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin -y

2. Adding a User to the Docker Group:

To use Docker without sudo, add your user to the docker group:

sudo usermod -aG docker ${USER}

Log out and log back into SSH for the changes to take effect:

exit
ssh beszeluser@your_ip_address

3. Verifying Docker Installation:

Run a test container:

docker run hello-world

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

4. Installing Docker Compose (if not installed as a plugin):

In newer Docker versions, Docker Compose is usually installed as a docker-compose-plugin, which is invoked with the command docker compose (without a hyphen). If you have an older version or want to install a separate docker-compose executable (with a hyphen), do the following:

sudo curl -L "https://github.com/docker/compose/releases/download/v2.24.5/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose

Check the Docker Compose version:

docker-compose --version

or for the plugin:

docker compose version

Your VPS is now fully prepared for deploying Beszel using Docker Compose.

Installing Beszel on a VPS using Docker and Docker Compose

The simplest and recommended way to install Beszel on a VPS is by using Docker and Docker Compose. This approach provides isolation, ease of updates, and dependency management. We will create a docker-compose.yml file that will define all necessary services: Beszel itself, the PostgreSQL database, and other auxiliary components.

Creating the Project Structure and docker-compose.yml File

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

mkdir ~/beszel
cd ~/beszel

Now, let's create the docker-compose.yml file. This is the main file that will describe all the services, networks, and volumes required for Beszel to run. Open it for editing:

nano docker-compose.yml

Paste the following content. This example includes Beszel, PostgreSQL, and Redis. Don't forget to replace your_domain.com, YOUR_DB_PASSWORD, YOUR_SECRET_KEY_BASE, YOUR_SMTP_HOST, and other variables with your actual values.

version: '3.8'

services:
  # PostgreSQL Database Service
  db:
    image: postgres:15-alpine
    restart: always
    environment:
      POSTGRES_DB: beszel
      POSTGRES_USER: beszel
      POSTGRES_PASSWORD: YOUR_DB_PASSWORD # Be sure to replace with a strong password
    volumes:
      - db_data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U beszel -d beszel"]
      interval: 10s
      timeout: 5s
      retries: 5

  # Redis service for caching and queues
  redis:
    image: redis:7-alpine
    restart: always
    volumes:
      - redis_data:/data
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 10s
      timeout: 5s
      retries: 5

  # Main Beszel service
  app:
    build:
      context: .
      dockerfile: Dockerfile # Use local Dockerfile for Beszel
    restart: always
    environment:
      RAILS_ENV: production
      DATABASE_URL: postgres://beszel:YOUR_DB_PASSWORD@db:5432/beszel
      REDIS_URL: redis://redis:6379/0
      # Secret key for Rails. Generated by `rails secret` command inside the container or on a local machine.
      SECRET_KEY_BASE: YOUR_SECRET_KEY_BASE # Be sure to generate a unique key
      # Domain where Beszel will be accessible
      BESZEL_DOMAIN: your_domain.com # Replace with your domain
      # Email sending settings (required for registration, password reset, and notifications)
      SMTP_HOST: YOUR_SMTP_HOST
      SMTP_PORT: YOUR_SMTP_PORT # Usually 587 or 465
      SMTP_USERNAME: YOUR_SMTP_USERNAME
      SMTP_PASSWORD: YOUR_SMTP_PASSWORD
      SMTP_FROM_ADDRESS: no-reply@your_domain.com
      # Optional: other Beszel settings
      BESZEL_TITLE: "My Beszel Community"
      BESZEL_DESCRIPTION: "Welcome to our decentralized community!"
    ports:
      - "3000:3000" # Beszel runs on port 3000 by default
    depends_on:
      db:
        condition: service_healthy
      redis:
        condition: service_healthy
    volumes:
      - ./public/uploads:/app/public/uploads # For storing uploaded files
      - ./log:/app/log # For storing logs
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3000/health"] # Assumes a healthcheck endpoint exists
      interval: 30s
      timeout: 10s
      retries: 5

volumes:
  db_data:
  redis_data:

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

Creating a Dockerfile for Beszel

Since Beszel typically doesn't provide a ready-made Docker Hub image, we'll need to create a simple Dockerfile to build the image from source code. This will allow us to use the latest version of Beszel.

nano Dockerfile

Paste the following content:

# Use Ruby base image
FROM ruby:3.2.2-alpine

# Install system dependencies
RUN apk add --no-cache \
    build-base \
    postgresql-dev \
    git \
    nodejs \
    yarn \
    tzdata

# Set working directory
WORKDIR /app

# Clone Beszel repository
RUN git clone https://github.com/beszel/beszel.git .

# Install RubyGems dependencies
COPY Gemfile Gemfile.lock ./
RUN bundle install --jobs $(nproc) --without development test

# Install JavaScript dependencies
COPY package.json yarn.lock ./
RUN yarn install --immutable

# Precompile assets
RUN bundle exec rails assets:precompile

# Expose port
EXPOSE 3000

# Command to run the application
CMD ["bundle", "exec", "rails", "server", "-b", "0.0.0.0"]

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

Configuring Environment Variables and Launching Beszel

1. Generating SECRET_KEY_BASE:

A unique SECRET_KEY_BASE is critically important for Rails applications. You can generate it by temporarily running a Rails console:

docker run --rm ruby:3.2.2-alpine bundle exec rails secret

Copy the generated key and paste it into your docker-compose.yml in place of YOUR_SECRET_KEY_BASE.
For example: SECRET_KEY_BASE: 0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef

2. Configuring SMTP:

Beszel uses email for registration, password reset, and notifications. Specify your SMTP server details (e.g., from SendGrid, Mailgun, Gmail, or your hosting provider) in docker-compose.yml. If you do not configure SMTP, email-related functions will not work.

3. Launching Docker Compose:

Once you have configured docker-compose.yml, ensured all environment variables are set, and created the Dockerfile, you can launch Beszel:

docker compose up -d --build

This command will build the Beszel image (--build), then start all services in the background (-d).

4. Initializing the Database:

After the initial launch of the containers, you need to run database migrations and populate it with initial data. Wait until the app container is up (you can check with the command docker compose ps).

docker compose exec app bundle exec rails db:migrate
docker compose exec app bundle exec rails db:seed # Optional, for initial data

5. Creating an Administrator Account:

To log into Beszel, you need an administrator account. You can create one via the Rails console:

docker compose exec app bundle exec rails console

In the Rails console, execute:

User.create!(email: "admin@your_domain.com", password: "YOUR_ADMIN_PASSWORD", password_confirmation: "YOUR_ADMIN_PASSWORD", username: "admin", admin: true)
exit

Replace admin@your_domain.com and YOUR_ADMIN_PASSWORD with your own details.

Your Beszel self-hosted should now be running and accessible via your VPS's IP address on port 3000 (e.g., http://your_ip_address:3000). However, for full functionality and security, you will need to configure a reverse proxy and HTTPS.

Configuring Reverse Proxy (Nginx or Caddy) and HTTPS for Beszel

Direct access to Beszel via port 3000 is not secure or convenient for a production environment. For this, reverse proxies such as Nginx or Caddy are used, which will redirect requests from ports 80 (HTTP) and 443 (HTTPS) to port 3000 of your Beszel container. This will also allow for easy HTTPS setup using Let's Encrypt.

Before you begin, ensure that your domain (e.g., your_domain.com) points to your VPS's IP address via an A-record in DNS.

Option 1: Nginx with Certbot for HTTPS

Nginx is a powerful and widely used reverse proxy. Certbot (from Let's Encrypt) automates the process of obtaining and renewing SSL certificates.

1. Installing Nginx:

sudo apt update
sudo apt install nginx -y

2. Configuring Nginx for Beszel:

Create a new Nginx configuration file for your domain:

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

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

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

    location / {
        proxy_pass http://localhost:3000; # Port on which Beszel runs
        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;
    }
}

Save and close the file.

3. Activating Nginx Configuration:

Create a symbolic link to the configuration file and check Nginx syntax:

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

If there are no errors, reload Nginx:

sudo systemctl restart nginx

4. Installing Certbot and Obtaining an SSL Certificate:

sudo apt install certbot python3-certbot-nginx -y
sudo certbot --nginx -d your_domain.com -d www.your_domain.com

Follow Certbot's instructions: enter your email, agree to the terms, and choose whether you want to redirect HTTP to HTTPS. Certbot will automatically modify the Nginx configuration and set up automatic certificate renewal.

5. Checking the Firewall:

Ensure that ports 80 and 443 are open:

sudo ufw allow 'Nginx Full'
sudo ufw delete allow 'Nginx HTTP' # If you previously only allowed HTTP

Your Beszel should now be accessible at https://your_domain.com.

Option 2: Caddy with Automatic HTTPS

Caddy is a modern web server renowned for its ease of configuration and automatic acquisition of Let's Encrypt SSL certificates. It's an excellent choice for those who want to minimize configuration.

1. Installing Caddy:

Add the Caddy repository:

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. Configuring Caddy for Beszel:

Create or edit the Caddyfile:

sudo nano /etc/caddy/Caddyfile

Remove or comment out existing content and paste the following, replacing your_domain.com with your domain:

your_domain.com {
    reverse_proxy localhost:3000 # Port on which Beszel runs
}

Save and close the file.

3. Restarting Caddy:

sudo systemctl reload caddy

Caddy will automatically obtain an SSL certificate for your domain and configure HTTP to HTTPS redirection. This is significantly simpler than manual Nginx and Certbot configuration.

4. Checking the Firewall:

Ensure that ports 80 and 443 are open:

sudo ufw allow http
sudo ufw allow https

Your Beszel on the server should now be accessible at https://your_domain.com with automatically configured HTTPS.

Beszel Maintenance: Backups, Updates, and Monitoring

Maintaining the functionality and security of your Beszel instance requires regular maintenance, including creating backups, timely updates, and monitoring. These steps are critically important for protecting your data and ensuring the stable operation of the platform.

Beszel Data Backup Strategies

Data loss can be catastrophic. Therefore, a reliable backup strategy is mandatory. For Beszel deployed via Docker Compose, you need to back up two main types of data: the PostgreSQL database and user uploads (media files).

1. PostgreSQL Database Backup

The database is the heart of Beszel. To create a database dump from within a Docker container, use pg_dump:

# Create a directory for backups on the host system
mkdir -p ~/beszel_backups/db

# Perform database backup
docker compose exec -T db pg_dump -U beszel -d beszel > ~/beszel_backups/db/beszel_db_$(date +%Y%m%d%H%M%S).sql

This command will create an SQL file with a database dump in the `~/beszel_backups/db/` directory. It is recommended to automate this process using a Cron job.

2. User Uploads (Media Files) Backup

Users can upload images, videos, and other files. This data is stored in the volume you mounted to the Beszel container (./public/uploads in our docker-compose.yml). You can simply copy this directory:

# Create a directory for file backups on the host system
mkdir -p ~/beszel_backups/uploads

# Copy the uploads directory
cp -r ~/beszel/public/uploads ~/beszel_backups/uploads/uploads_$(date +%Y%m%d%H%M%S)

3. Full Docker Volume Backup

For a more comprehensive approach, you can back up all Docker volumes you created (`db_data` and `redis_data`). This can be done using a temporary container:

# db_data backup
docker run --rm --volumes-from beszel-db-1 -v ~/beszel_backups/db_volume:/backup alpine tar cvf /backup/db_data_$(date +%Y%m%d%H%M%S).tar /var/lib/postgresql/data

# redis_data backup
docker run --rm --volumes-from beszel-redis-1 -v ~/beszel_backups/redis_volume:/backup alpine tar cvf /backup/redis_data_$(date +%Y%m%d%H%M%S).tar /data

Replace beszel-db-1 and beszel-redis-1 with the actual names of your containers, which you can find using `docker compose ps`. This method is more reliable for restoring volume states.

Backup Recommendations:

• Automation: Set up Cron jobs for daily or weekly backup execution.
• Offsite Storage: Store backups not only on the same VPS but also on a remote server (S3, Dropbox, another VPS) to protect against total server loss.
• Testing: Periodically test the restoration process from backups to ensure their functionality.

Beszel and Docker Image Update Procedures

Regular updates are critically important for security and gaining new features.

1. Updating Beszel

Since we cloned Beszel from a Git repository, updating involves pulling the latest changes and rebuilding the image:

cd ~/beszel
git pull # Get the latest changes from the Beszel repository
docker compose stop # Stop current containers
docker compose build --no-cache # Rebuild the Beszel image
docker compose up -d # Start new containers
docker compose exec app bundle exec rails db:migrate # Run database migrations, if any
docker compose exec app bundle exec rails assets:precompile # Recompile assets

Always check the official Beszel documentation for specific update instructions before performing these steps.

2. Updating Docker Images (PostgreSQL, Redis, etc.)

To update base images (PostgreSQL, Redis), simply execute:

docker compose pull # Downloads the latest versions of images specified in docker-compose.yml
docker compose down # Stops and removes current containers (data volumes are preserved)
docker compose up -d # Starts new containers with updated images

Before updating critically important images, such as the database, always perform a full backup.

3. Updating the VPS System

Don't forget to regularly update your VPS's operating system:

sudo apt update
sudo apt upgrade -y
sudo apt autoremove -y
sudo reboot # A reboot may be required after updating the kernel or critical packages

Performance and Log Monitoring

Monitoring will help you promptly react to issues and optimize resources.

• Docker Logs: View container logs to identify errors:

  docker compose logs -f app
  docker compose logs -f db

  Dozzle can be a useful tool for centralized viewing of Docker container logs via a web interface.
• Docker Stats: Monitor resource usage (CPU, RAM, Disk I/O) by containers:

  docker stats

• System Monitoring: Use utilities such as htop, glances, df -h to monitor overall VPS performance, CPU, RAM, and disk space usage.
• Notifications: Set up notifications (e.g., via Prometheus/Grafana or simple scripts) for critical resource usage or errors in logs.

Regularly performing these procedures will ensure the long-term stability and security of your Beszel platform on a VPS.

Choosing a VPS for Beszel under Real Load: Configurations and Plans

Choosing the right VPS for Beszel on a VPS is one of the most important decisions, directly impacting the performance, stability, and total cost of ownership of your platform. Valebyte.com offers various plans that can be optimally selected for specific Beszel use cases.

Defining Real Load and Its Impact on Configuration

The real load on Beszel is determined by several key factors:

1. Number of Active Users: How many users are simultaneously interacting with the platform? An "active" user is one who views pages, publishes posts, or comments.
2. Volume and Type of Content: Primarily text-based content requires fewer resources than active exchange of images, videos, and other media files.
3. Degree of Federation: If your Beszel instance actively federates with a large number of other instances (as, for example, with Lemmy), this increases network traffic and database load.
4. Frequency of Operations: How often do users publish, read, and search for content? A high frequency of operations requires a more powerful CPU and a fast disk subsystem.

Based on these factors, several typical VPS configurations can be identified.

Table: Recommended VPS Configurations for Beszel from Valebyte.com

This table will help you choose a suitable VPS plan from Valebyte.com depending on the anticipated load on your Beszel instance. All Valebyte.com plans include NVMe SSD and a high-speed network channel, which is critically important for Beszel's performance.

Use Case	Number of Active Users	vCPU	RAM	NVMe SSD	Approximate Cost/Month (Valebyte.com)	Recommendations
Personal/Test	1-10	1-2 cores	2 GB	50 GB	From $5-7	For learning Beszel, a personal blog, or a very small group.
Small Community	10-50	2 cores	4 GB	80-100 GB	From $10-15	For small workgroups, family communities, hobby projects.
Medium Community	50-200	4 cores	8 GB	100-160 GB	From $20-30	For active thematic forums, small companies, educational platforms.
Large Community/Production	200-500+	6-8+ cores	16-32+ GB	200-400+ GB	From $40-70+	For large public communities, actively federating instances, projects with large media volumes.

Note: Prices are approximate and may vary depending on current promotions and Valebyte.com tariff plans.

Additional Recommendations for Choosing a VPS

1. Start Small, Scale as You Grow: You can always start with a more modest plan and then easily upgrade your VPS to a more powerful configuration without reinstallation if your project begins to grow actively. Valebyte.com provides this option.
2. Prioritize NVMe SSD: Regardless of community size, always choose a VPS with NVMe SSD. This is the most significant factor for database performance and overall Beszel responsiveness.
3. Assess Traffic Consumption: If you expect active media file exchange or extensive federation, ensure your plan includes sufficient monthly traffic volume or offers unlimited traffic.
4. Server Location: Choose a data center that is geographically closer to your primary audience to minimize latency.
5. Support: Pay attention to the quality of the provider's technical support. Valebyte.com offers 24/7 support, which can be critically important if issues arise.

A careful approach to choosing a VPS for Beszel on a server will allow you to create a fast, reliable, and scalable platform capable of meeting the needs of your community.

Conclusion

Deploying Beszel on your own VPS from Valebyte.com provides full control over your decentralized social platform, ensuring privacy, flexibility, and scalability. Using Docker Compose, you can easily install and maintain Beszel, and ensure security with Nginx or Caddy with automatic HTTPS. For optimal Beszel performance under load, it is recommended to choose a VPS with NVMe SSD and sufficient RAM, which will allow your platform to function quickly and stably for any number of users.