Guides & Tutorials

How to Secure Nginx with Fail2Ban

2026-07-28T00:00:00Z

Introduction

Exposing an Nginx web server to the public internet invites a constant stream of automated probes. Bots hunt for vulnerabilities, attempt credential stuffing, and flood your logs with malformed requests. If you are running your services on a VPS, you need a proactive defense mechanism that works without constant manual intervention.

Fail2Ban is the industry standard for this task. It monitors your server logs in real-time, identifies suspicious patterns-such as repeated 404 errors or failed login attempts-and automatically updates your firewall to block offending IP addresses. While Nginx handles your traffic, Fail2Ban acts as your automated gatekeeper.

This guide focuses on a clean, maintainable installation on Ubuntu. We avoid the common trap of editing default configuration files directly, which ensures your security rules survive system updates. By the end of this tutorial, you will have a hardened Nginx environment configured to use the systemd backend for optimal performance and minimal resource overhead. We assume you have a base Ubuntu installation with root or sudo access. If you are starting from scratch, ensure your system is patched and your firewall is enabled before proceeding.

Prerequisites

Before beginning, ensure your VPS server meets the following requirements. Running these services requires a minimum of 1GB RAM and 1 CPU core to maintain stable performance during log parsing operations.

Access to a terminal with sudo privileges on an Ubuntu 24.04 LTS or newer distribution.
An active firewall, such as UFW, to manage network traffic effectively. If you have not yet set up your firewall, check out our guide: How to Configure UFW Firewall on Ubuntu & Debian: The Complete Server Guide.
Nginx installed and running. If you need to perform a fresh install, refer to How to Install Nginx on Ubuntu & Debian: The Complete Server Guide.
Basic familiarity with text editors like nano or vim for modifying configuration files.

Verify that your system clock is synchronized using NTP, as Fail2Ban relies on accurate timestamps to calculate the duration of bans. You can check this by running timedatectl status. Finally, ensure that your Nginx access logs are enabled and accessible, as Fail2Ban will need read permissions to monitor incoming traffic for malicious activity.

Step 1: Install Nginx and Fail2Ban

To begin, we need to ensure your package list is up to date and install the necessary software components. Using the official Ubuntu repositories ensures that you receive security updates and maintain compatibility with your system architecture.

Execute the following commands to update your package index and install both Nginx and Fail2Ban:

## Update package list and install Nginx and Fail2Ban
sudo apt update
sudo apt install -y nginx fail2ban

Once the installation finishes, Fail2Ban creates a default configuration file located at /etc/fail2ban/jail.conf. Modifying this file directly is discouraged because package updates can overwrite your changes. Instead, we create a local copy that takes precedence.

## Create the local configuration file to preserve settings
sudo cp /etc/fail2ban/jail.conf /etc/fail2ban/jail.local

Modern Ubuntu distributions utilize systemd to manage logs. For optimal performance and to reduce the latency between a malicious event and a ban, we must configure Fail2Ban to use the systemd backend rather than the default log file polling method. Run this command to update your configuration:

## Set the Fail2Ban backend to systemd
sudo sed -i 's/backend = auto/backend = systemd/g' /etc/fail2ban/jail.local

With these settings applied, your environment is ready for specific Nginx protection rules. In the next steps, we will define the jails that monitor your web traffic.

Step 2: Configure the Fail2Ban Jail

Now that the backend is set, we need to create a specific jail configuration for Nginx. A jail defines which log files to monitor and what actions to take when a threshold is met. By default, Fail2Ban does not actively monitor Nginx unless you explicitly enable the corresponding jail in your jail.local file.

To define your custom Nginx protection, open the local configuration file in your preferred text editor:

## Open the local configuration file
sudo nano /etc/fail2ban/jail.local

Scroll through the file until you find the [nginx-http-auth] or [nginx-botsearch] sections. You can enable these by changing the enabled parameter from false to true. For a robust setup, ensure the following lines are present and uncommented within your file:

[nginx-http-auth]
enabled = true
port    = http,https
filter  = nginx-http-auth
logpath = /var/log/nginx/error.log

[nginx-botsearch]
enabled = true
port    = http,https
filter  = nginx-botsearch
logpath = /var/log/nginx/access.log

The nginx-http-auth jail protects your site against brute-force attacks on pages secured with Basic Auth, while nginx-botsearch blocks malicious scanners attempting to find hidden administrative directories. After adding these blocks, save the file by pressing Ctrl + O, followed by Enter, and exit with Ctrl + X.

Note: If you are running a VPS with a high volume of traffic, ensure your log paths match your actual Nginx configuration. If you have customized your log directory, update the logpath value accordingly to prevent the service from failing to start.

Step 3: Enable the Nginx Jails

With the jail.local configuration updated, the final step is to apply these changes. Fail2Ban must be instructed to reload its configuration so that the new Nginx jails are initialized and the monitoring service starts tracking your log files for suspicious activity.

Because we have modified the core configuration, we need to restart the service to commit these changes to memory. Execute the following commands to enable the service, restart it, and verify that it is running correctly:

## Enable, restart, and verify the status of the Fail2Ban service
sudo systemctl enable fail2ban
sudo systemctl restart fail2ban
sudo systemctl status fail2ban

The status output should indicate that the service is active (running). You can also verify that your specific Nginx jails are active by using the fail2ban-client utility. This tool interacts directly with the running daemon and confirms that the jails are successfully parsing your log files:

## Verify that the nginx-http-auth and nginx-botsearch jails are active
sudo fail2ban-client status nginx-http-auth
sudo fail2ban-client status nginx-botsearch

If the status returns "Currently failed: 0" and "Total failed: 0," your setup is ready. The service is now actively scanning your /var/log/nginx/ files for patterns matching the default filters. If you notice any issues with log parsing, ensure that the permissions on your Nginx log files allow the Fail2Ban user to read them. For most standard installations on a VoxiHost VPS, the default permissions are sufficient.

Step 4: Verify Fail2Ban Functionality

Now that the service is running and the jails are initialized, you need to confirm that Fail2Ban is actually watching your logs and ready to block malicious traffic. The most reliable way to test this is by checking the jail status and simulating a failed login attempt.

First, verify that Fail2Ban is actively monitoring the Nginx log files by checking the jail summary:

## Display the list of currently active jails
sudo fail2ban-client status

You should see nginx-http-auth and nginx-botsearch listed under the "Jail list" section. If they appear there, the daemon has successfully linked the filters to your Nginx logs.

To test if the filter is working, intentionally trigger a failed authentication request against your server. If you have an Nginx location block protected by Basic Auth, attempt to log in with the wrong credentials multiple times. If you do not have a protected page, you can simulate a bot attack by requesting a non-existent file that triggers the nginx-botsearch filter.

After triggering the failure, check the jail status again to see if the counter has incremented:

## Check the status of a specific jail to see failed attempts
sudo fail2ban-client status nginx-http-auth

If the "Currently failed" count reflects your attempts, Fail2Ban is parsing your logs correctly. Once your predefined threshold (the maxretry setting in jail.local) is reached, Fail2Ban will automatically insert a rule into your firewall to drop incoming traffic from that IP. You can confirm the ban by inspecting the logs:

## Tail the Fail2Ban log to see real-time ban actions
sudo tail -f /var/log/fail2ban.log

You should see entries indicating that an IP has been banned.

Conclusion

Securing your web server with Fail2Ban provides a critical layer of defense against automated attacks. By monitoring your Nginx logs in real-time and dynamically updating your firewall, you effectively neutralize brute-force attempts and malicious bot traffic before they can impact your system resources.

On a VoxiHost VPS, this proactive security approach ensures that your services remain performant and available for legitimate users. Remember that security is not a one-time configuration. Periodically review your jail.local settings and monitor your logs to ensure your filters remain effective against evolving threats.

If you decide to modify your security policies, always remember to check the syntax of your configuration files before restarting the service:

## Validate your configuration syntax for errors
sudo fail2ban-client -t

Should you need to apply updates to your security configuration, stop the service first to ensure a clean state, apply your changes, and then reload:

## Safely stop and reload Fail2Ban after configuration changes
sudo systemctl stop fail2ban
sudo systemctl start fail2ban

With Fail2Ban operational, you have significantly reduced the attack surface of your Linux environment. For further hardening, consider pairing this with a properly configured UFW firewall, as detailed in our guide on how to Configure UFW Firewall on Ubuntu & Debian: The Complete Server Guide. Staying vigilant and keeping your software updated remains the best way to maintain a secure and reliable server infrastructure.

How to Install Node.js on Ubuntu & Debian

2026-07-27T00:00:00Z

Introduction

Running JavaScript on the server side requires a reliable and up-to-date runtime environment. While many Linux distributions include Node.js in their default package managers, these versions are often outdated, which can lead to compatibility issues with modern frameworks or security vulnerabilities. For developers deploying applications on a VoxiHost VPS, maintaining a current environment is essential for performance and stability.

The most effective way to manage your runtime is by using the official NodeSource binary distribution repositories. This approach ensures you are not limited by the older software versions found in standard system repositories. By configuring the official repository, you gain seamless access to the latest Long Term Support (LTS) releases, ensuring your production server remains stable while supporting modern ECMAScript features.

This guide focuses on a clean, professional setup on Ubuntu and Debian systems. We will move beyond default package lists to install a production-ready Node.js environment. Whether you are hosting a lightweight API or a complex real-time application, the steps provided will ensure your server is correctly configured for long-term reliability. We assume you have a fresh instance running at least 1GB of RAM to ensure the build process completes without memory bottlenecks.

Prerequisites

You must have root or sudo access to the server. Since we will be configuring external repositories, your system needs to be up to date to avoid conflicts with existing library versions. If you have not performed a system update recently, consider running sudo apt update && sudo apt upgrade -y before proceeding.

Additionally, this guide assumes you are working with a clean installation of Ubuntu 24.04 or later, or Debian 12 or later. If you are managing your firewall, ensure you have already configured it to allow traffic on the ports your application will eventually use.

Finally, ensure that you have access to a terminal or SSH client. We will be using curl to fetch the setup scripts, so verify that your environment is ready to handle these network requests. If you plan to manage multiple server instances or need enhanced protection for your applications, you might also consider our Shield DDoS protection to secure your traffic at the network edge.

Step 1: Update System Packages and Install Dependencies

Before we pull the Node.js binaries, we must prepare the environment. Standard distribution repositories often contain outdated versions of Node.js, which can cause compatibility issues with modern frameworks. To avoid this, we will use the official NodeSource repository.

The setup script requires curl to fetch the necessary GPG keys and repository configuration files. If your server is a minimal installation, this utility might not be present. Run the following command to refresh your package list and install the required dependency:

## Update local package index and install curl
sudo apt update && sudo apt install -y curl

Once the installation finishes, your system is ready to communicate with the NodeSource servers. Keeping your package list updated ensures that you are pulling the most recent security patches for your OS libraries alongside the new Node.js environment. We have verified that this approach minimizes dependency conflicts on both Ubuntu and Debian systems.

Step 2: Add the NodeSource Repository

Now that your system has the necessary tools to handle remote requests, we will configure the NodeSource repository. This repository acts as a bridge, allowing your package manager to track and install the official Long Term Support (LTS) releases directly from the source.

Using the automated setup script is the most reliable way to handle the GPG key imports and repository file generation. By using the -E flag with sudo, we ensure that your current environment variables are preserved during the execution of the script, which is critical for correctly detecting your system architecture and distribution version.

Execute the following commands to download the setup script and apply the configuration to your server:

## Download the NodeSource LTS setup script
curl -fsSL https://deb.nodesource.com/setup_lts.x -o nodesource_setup.sh

## Execute the script to configure the repository
sudo -E bash nodesource_setup.sh

The script will automatically update your local package lists once the repository is added. You will see a series of logs in your terminal indicating that the package sources have been refreshed and that the GPG keys have been successfully imported. If you encounter any warnings regarding missing keys, verify that your internet connection is stable and that no firewall is blocking outbound traffic to deb.nodesource.com. Once this process finishes, your server is primed to pull the latest stable Node.js binaries.

Step 3: Install Node.js and NPM

With the NodeSource repository now active on your system, the final installation phase is straightforward. Since the previous step already triggered an automatic update of your package lists, you can proceed directly to installing the Node.js runtime and the Node Package Manager (NPM).

Using the official repository ensures you receive a modern, supported version of Node.js, which is significantly more stable and feature-rich than the legacy versions often found in default distribution archives. Execute the following command to install the package:

## Install Node.js and NPM from the NodeSource repository
sudo apt install -y nodejs

The nodejs package includes both the binary for running your applications and the npm tool for managing your project dependencies. The installation process is typically fast, as it only requires pulling the binaries from the repository you just configured.

Once the command finishes, you have successfully set up the core environment. You are now ready to verify that everything is correctly linked and identify the specific version of the runtime active on your VoxiHost VPS server.

Step 4: Verify the Installation

Now that the binaries are installed, you need to confirm that the system is correctly pointing to the NodeSource versions. This is a critical check to ensure your VoxiHost VPS server is not accidentally using an older, cached, or system-default version of the runtime.

Run the following commands to output the currently active versions:

## Check the installed Node.js version
node -v

## Check the installed NPM version
npm -v

The node -v command should return a version string starting with v20 or higher, depending on the current LTS release. If you see an output like v26.x.x, your server is correctly configured to use the latest long-term support release. The npm -v command will return the version of the package manager, confirming that it is also ready for use.

Note: If you encounter a "command not found" error, it usually indicates that the shell path was not updated. Simply log out and log back in to your SSH session to refresh your environment variables.

Everything is now set up for your development environment. You have successfully bypassed outdated system repositories and secured a stable foundation for your JavaScript applications on your VPS.

Conclusion

You have successfully configured a reliable Node.js environment on your Linux server. By utilizing the official NodeSource repository instead of default distribution packages, you ensure that your VoxiHost VPS server receives timely security patches and access to modern JavaScript features. This setup provides the stability required for production workloads, whether you are running a lightweight API on a Budget VPS or a high-traffic application on a Premium VPS.

Going forward, remember that keeping your runtime updated is essential for both performance and security. When a new LTS version is released, you can keep your environment current by updating your package lists and upgrading the binary:

## Update local package lists
sudo apt update

## Upgrade the Node.js package to the latest version
sudo apt upgrade -y nodejs

If you plan to deploy complex applications, consider using a process manager like PM2 to keep your services running after a reboot. You may also want to explore our guides on How to Install Nginx on Ubuntu & Debian: The Complete Server Guide if you intend to set up a reverse proxy for your Node.js application. Your server is now ready for development, testing, or production deployment. Happy coding.

How to Setup Python Venv on Ubuntu

2026-07-21T00:00:00Z

Introduction

Managing Python dependencies on a production server often leads to conflicts. When you install packages globally using pip, you risk breaking system-level tools that rely on specific library versions. On modern Ubuntu distributions, this issue is further addressed by PEP 668, which restricts global package installations to ensure system stability.

The industry-standard solution is the virtual environment, or venv. By isolating your project dependencies into a local directory, you ensure that your application has exactly what it needs without interfering with the underlying operating system or other projects hosted on your VoxiHost Premium VPS.

This guide provides a direct, no-nonsense approach to setting up isolated Python environments. We will walk through installing the necessary module, creating a clean workspace, and activating your environment to start installing packages safely. Whether you are running a lightweight microservice on a Budget VPS or managing complex data pipelines, this setup is the foundation of professional Python development on Linux.

Prerequisites

Before beginning, ensure your server meets the minimum requirements for a stable development environment. We recommend a minimum of 512MB of RAM and 1 CPU core, which is standard for our Budget VPS and Premium VPS instances.

You should have access to an Ubuntu 22.04 LTS or newer server with a non-root user that has sudo privileges. If you have not yet set up your administrative user, refer to our guide on How to Create a Sudo User on Ubuntu & Debian: The Complete Server Guide to ensure you are not running development tasks as the root user.

Additionally, confirm that your system clock is synchronized to avoid SSL errors when fetching packages. You should also ensure that your APT package list is current to avoid dependency resolution issues. While no specific Python code is required at this stage, having basic familiarity with the command line is expected.

Finally, check that you have enough disk space available in your project directory to accommodate the virtual environment structure, which typically consumes a few megabytes for the core files plus the size of any project-specific dependencies you intend to install later.

Step 1: Install the Python Venv Module

Modern versions of Ubuntu include Python by default, but the module required for creating isolated environments is often excluded from the core installation to save space. To manage your project dependencies without polluting the global system packages, you must install the python3-venv package. This ensures you comply with PEP 668, which restricts global pip installations on newer Ubuntu releases to prevent conflicts with system-level software.

Execute the following commands to update your local package index and pull the necessary module into your system:

## Update the package index and install the virtual environment module
sudo apt update
sudo apt install -y python3-venv

This installation provides the venv module, which allows you to create lightweight, isolated Python environments. Once the process finishes, verify the installation by checking the Python version. While this doesn't explicitly confirm the module's presence, it ensures your environment is ready for the next steps:

## Verify Python installation
python3 --version

If you are using a VoxiHost Premium VPS, this operation will complete in seconds. You are now prepared to initialize your first virtual environment within a dedicated project directory.

Step 2: Create a Project Directory

Before you initialize your environment, you need a clean workspace to host your application code and its dependencies. Keeping your projects in separate directories prevents file clutter and makes it easier to manage multiple environments on your VoxiHost server.

Navigate to your home directory or a dedicated folder for your development projects, then create a new directory for your specific task:

## Create a new project directory and move into it
mkdir -p ~/my_python_project
cd ~/my_python_project

Step 3: Create and Activate the Virtual Environment

With the project directory ready, you can now initialize the virtual environment. We will use the venv module to generate a local directory named venv. This folder will contain a standalone Python binary and its own pip installer, effectively sandboxing your project from the rest of the operating system.

## Initialize the virtual environment in the current folder
python3 -m venv venv

After running this command, you will notice a new venv directory in your current path. This directory holds everything needed to run your project without requiring root privileges. Do not use sudo for this step or any subsequent package management within this environment, as it can cause ownership issues that break your project configuration. Next, activate the environment to start using the local binaries:

## Activate the virtual environment
source venv/bin/activate

Once activated, you will notice that your terminal prompt changes to include (venv) at the beginning. This visual indicator confirms that any subsequent commands, such as python or pip, are now pointing to the binaries located inside your project folder rather than the system defaults.

Note: If you find that pip is not available after activation, you can ensure it is installed by running python3 -m ensurepip --upgrade. This will safely install the package manager directly into your virtual environment without affecting your host system.

At this point, your VoxiHost server is correctly configured for local development. You can now safely install project-specific libraries using pip install <package_name>. Because you are using a virtual environment, these packages will remain contained within your ~/my_python_project/venv directory, keeping your system clean and avoiding conflicts with other applications.

Step 4: Manage Packages Within the Environment

Now that your environment is active, you can manage project dependencies without requiring root access. The primary tool for this is pip, the standard package installer for Python. Because your shell is currently pointed at the isolated venv binaries, any library you install will be saved exclusively to your project folder.

To install a package, such as requests, simply run:

## Install a package within the virtual environment
pip install requests

You can verify that the library is installed correctly by listing the currently available packages in your environment:

## List all installed packages in the current venv
pip list

If you are working on a collaborative project or moving your code to a production VoxiHost server, you should generate a requirements file. This allows you to track exactly which versions of libraries your project needs:

## Export the current environment dependencies to a file
pip freeze > requirements.txt

This requirements.txt file is the industry standard for maintaining consistent environments across different machines. If you ever need to recreate this environment on another server, you can install all dependencies at once using pip install -r requirements.txt.

Warning: Never use sudo when running pip inside your virtual environment. Using sudo can cause file permission errors and may inadvertently install packages to the system-wide Python directory, which violates the isolation you have just established.

Conclusion

You have successfully established a robust, isolated Python environment on your system. By moving away from global package management, you have eliminated the risk of dependency conflicts and ensured that your projects remain portable and stable. This workflow is particularly vital when deploying applications on your Premium VPS or Budget VPS, where maintaining a clean system state is essential for long-term server health.

Remember that virtual environments are ephemeral. If you ever need to update your dependencies, simply reactivate the environment using the source venv/bin/activate command and run your updates. If you find your project requirements have changed significantly, it is often cleaner to delete the venv directory and recreate it from your requirements.txt file rather than manually uninstalling dozens of individual packages.

As your projects grow, you might consider containerizing them with Docker or implementing automated deployment scripts to handle these environment setups. For now, you have a solid foundation for local development and production deployment. Keep your server secure, keep your dependencies pinned, and continue building on your infrastructure with confidence.

How to Install PHP-FPM with Nginx on Ubuntu

2026-07-20T00:00:00Z

Introduction

Running a high-performance web server requires a stack that balances speed with resource efficiency. While Apache has served the web for decades, Nginx combined with PHP-FPM has become the standard for modern, high-traffic applications. By offloading PHP processing to a dedicated FastCGI Process Manager, you gain significant improvements in memory consumption and request handling compared to older execution methods.

This guide focuses on setting up a stable, production-ready environment on Ubuntu 26.04 LTS. We will walk through the installation of Nginx and the default PHP 8.5 version (PHP-FPM) available on your system, ensuring they communicate correctly via Unix sockets. This configuration is ideal for developers hosting dynamic sites on a VoxiHost Premium VPS, where every millisecond of latency reduction matters.

We prioritize a clean, minimal installation. We avoid bloated bundles in favor of package-managed, official repositories that ensure security updates are just an apt upgrade away. By the end of this tutorial, you will have a functional web server capable of serving dynamic PHP content, complete with the configuration tweaks required to avoid common bottlenecks. Whether you are migrating an existing application or spinning up a fresh project, this setup provides a rock-solid foundation for your infrastructure.

Prerequisites

Before beginning the installation, ensure your server meets the baseline requirements for a stable production environment. We recommend a minimum of 1GB of RAM and at least one dedicated CPU core to handle the overhead of Nginx and the PHP-FPM worker processes without performance degradation. This guide assumes you are running a fresh installation of Ubuntu 26.04 LTS.

You must have root access or a user account with sudo privileges to execute administrative commands. If you are using a VoxiHost Budget VPS, ensure your firewall is correctly configured to allow incoming traffic on ports 80 and 443. If you have not yet set up your firewall, follow our guide on securing-ubuntu-server-with-ufw to prevent unauthorized access to your management ports.

Verify that your package list is current and that your system is fully updated to avoid dependency conflicts during the installation process. Although we will install specific packages in the following steps, having a clean, updated environment prevents common library mismatch errors. Ensure you are logged into your server via SSH and have your domain or server IP address ready for testing the final configuration.

Step 1: Install Nginx and PHP-FPM

To begin the setup, you must fetch the latest package metadata from the official repositories and install the Nginx web server alongside the PHP-FPM interpreter. We will install the default php-fpm package, which automatically resolves to PHP 8.5 on Ubuntu 26.04 LTS (or PHP 8.3 if you are running Ubuntu 24.04 LTS).

Run the following commands to initialize the installation:

## Update the local package index to ensure you pull the latest versions
sudo apt update

## Install Nginx and the default PHP FastCGI Process Manager
sudo apt install nginx php-fpm

Once the installation is complete, you should check which PHP version was installed as the default on your system. This determines the exact service and socket names you will use in subsequent steps. Run:

## Check the installed PHP version
php -v

For example, if the output shows PHP 8.5.x, your PHP-FPM service name is php8.5-fpm and the socket file is php8.5-fpm.sock (if you are on Ubuntu 24.04 LTS, it will show PHP 8.3.x with php8.3-fpm and php8.3-fpm.sock). Note this version - you will use it in the Nginx configuration in the next step.

Step 2: Configure the Nginx Server Block

By default, Nginx is not configured to process PHP files. You must modify the default server block to pass requests for .php files to the PHP-FPM socket. Open the configuration file using the text editor:

## Open the default site configuration file for editing
sudo nano /etc/nginx/sites-available/default

Locate the location / block and ensure the index directive includes index.php. Then, uncomment or add the location ~ \.php$ { ... } block to handle PHP requests. Your configuration should resemble the following structure:

server {
    listen 80 default_server;
    listen [::]:80 default_server;

    root /var/www/html;
    index index.php index.html index.htm index.nginx-debian.html;

    server_name _;

    location / {
        try_files $uri $uri/ =404;
    }

    # Pass PHP scripts to the PHP-FPM socket
    location ~ \.php$ {
        include snippets/fastcgi-php.conf;
        fastcgi_pass unix:/var/run/php/php8.x-fpm.sock;
    }
}

Check the fastcgi_pass directive carefully. The path /var/run/php/php8.x-fpm.sock (where 8.x is your PHP version, e.g., 8.5 on Ubuntu 26.04 LTS or 8.3 on Ubuntu 24.04 LTS) must match the actual socket file on your system. If you encounter errors later, verify that the version number in the path aligns with the php8.x-fpm service you verified in the previous step. Save your changes by pressing Ctrl + O, then Enter, and exit with Ctrl + X.

Step 3: Create a PHP Test Script and Verify Setup

To verify that Nginx is correctly passing requests to the PHP-FPM processor, create a simple information page. This script uses the phpinfo() function, which displays the current PHP configuration, loaded modules, and environment variables.

Navigate to the default web root directory and create a new file named info.php:

## Create the test file in the default web root
sudo nano /var/www/html/info.php

Insert the following PHP code into the file:

<?php
phpinfo();
?>

Save the file by pressing Ctrl + O, then Enter, and exit using Ctrl + X.

Before testing the file in your browser, validate your Nginx configuration to ensure there are no syntax errors from the previous step. Then, apply the changes by reloading the service:

## Test the configuration syntax
sudo nginx -t

## Apply the changes to the Nginx service
sudo systemctl reload nginx

If the syntax test returns successful, open your web browser and navigate to http://your_server_ip/info.php. You should see a page detailing your PHP installation (which will show PHP 8.5 on a fresh Ubuntu 26.04 setup). If you see the raw code instead of the rendered page, double-check that the location ~ \.php$ block in your Nginx configuration matches the socket path exactly. Once you have confirmed that everything is working correctly, delete the test file to prevent unauthorized users from viewing sensitive server information:

## Remove the test script for security
sudo rm /var/www/html/info.php

After verifying the PHP integration through the browser, perform a final status check on the services to ensure both Nginx and PHP-FPM are operating without errors. Run:

## Check the status of the Nginx web server
sudo systemctl status nginx

## Check the status of the PHP-FPM service (replace 8.x with your version)
sudo systemctl status php8.x-fpm

Verify that both services display an "active (running)" status. If a service shows as "failed" or "inactive," check the system logs using journalctl -u nginx or journalctl -u php8.x-fpm (replacing 8.x with your installed PHP version). Periodically checking the Nginx error logs at /var/log/nginx/error.log is also highly recommended to proactively catch file permission issues or missing PHP modules before they affect your users.

Conclusion

You now have a fully functional LEMP stack running on your Ubuntu server. By pairing Nginx with PHP-FPM 8.5, you have established a high-performance foundation capable of handling dynamic web traffic with minimal overhead. Whether you are deploying a custom application or a content management system, this configuration provides the necessary control over your server environment.

Maintaining this stack involves more than just the initial setup. As your application grows, you may need to adjust the worker processes in your Nginx configuration or tune the PHP-FPM pool settings to better suit your resource allocation. If you ever need to perform a system update, remember to stop the services first to ensure data integrity:

## Safely stop services before system updates (replace 8.x with your version)
sudo systemctl stop nginx
sudo systemctl stop php8.x-fpm

## Run your system package updates
sudo apt update && sudo apt upgrade -y

## Restart the services after the update (replace 8.x with your version)
sudo systemctl start nginx
sudo systemctl start php8.x-fpm

For those managing critical workloads, monitoring is the next logical step. Keep an eye on system resource usage through your VoxiHost dashboard, especially if you are scaling your Premium VPS or Budget VPS environments. Regularly checking your logs and keeping your packages current will ensure that your web server remains both fast and secure against emerging vulnerabilities.

If you decide to expand your infrastructure further, consider looking into How to Set Up SSL with Let's Encrypt & Certbot on Ubuntu & Debian: The Complete Guide to encrypt your traffic and improve your search engine rankings.

How to Install Portainer on Ubuntu & Debian VPS

2026-07-14T00:00:00Z

Introduction

Docker is an amazing tool, but typing commands into a black terminal can be overwhelming for beginners. Enter Portainer - a graphical user interface (GUI) dashboard that lets you click your way through Docker straight from your web browser.

In this step-by-step tutorial, we will show you how to install Portainer on your server in just a few minutes. You don't need to be a Linux expert - just copy and paste the commands below!

Prerequisites: You will need a Premium VPS running Ubuntu or Debian and an SSH client (e.g. PuTTY or your system Terminal). If you don't have a server yet, VoxiHost offers Premium VPS and Budget VPS with Ubuntu and Debian available out of the box.

Step 1: Connect to your Server and Install Docker

First, connect to your server via SSH. Next, let's make sure Docker is installed. If you don't have it yet, simply paste this one-line installer command which will do all the heavy lifting for you:

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

Wait a few moments for the installation to finish.

Step 2: Prepare Storage for Portainer

Portainer needs a safe place on your hard drive to save your passwords and configurations. Paste the following command into your terminal and press ENTER to create a "volume":

docker volume create portainer_data

Step 3: Run Portainer

Now we will start Portainer itself. The command below will download the latest version and run it in the background. Paste the entire command into the terminal and press ENTER:

docker run -d -p 8000:8000 -p 9443:9443 --name portainer --restart=always -v /var/run/docker.sock:/var/run/docker.sock -v portainer_data:/data portainer/portainer-ce:latest

That's it! The installation on the server side is complete.

You can now close your terminal. Open your favorite web browser (like Chrome or Firefox) and type the following into the address bar:

https://YOUR_SERVER_IP:9443
(Replace "YOUR_SERVER_IP" with the actual IP address of your VPS, e.g., https://192.168.1.50:9443)

Tip: If you see the error Client sent an HTTP request to an HTTPS server., it means your browser tried to connect via standard HTTP. Make sure your address explicitly starts with https://.

Important: Your browser might show a "Your connection is not private" warning. This is completely normal because the server uses a self-signed certificate by default. Simply click "Advanced" and then "Proceed / Continue".

You will see the initial setup screen. Create a strong password for yourself, type it twice, and click the Create user button.

Important (5-minute limit!): Portainer takes security seriously. If more than 5 minutes pass between starting the container (Step 3) and setting your password, the setup will time out. To unlock it, go to your terminal and type docker restart portainer, then refresh the page. You will then be asked for a Setup Token. To get it, type docker logs portainer. Near the bottom of the logs, you will see Use the following token to setup the administrator user: followed by a long code. Copy this token and paste it into the browser.

Step 5: Managing Containers

After logging in, click the "Get Started" button, and on the next screen, click the whale icon labeled "Local" (which represents the server we are currently on).

You're all set! You now have access to the full dashboard. From now on, you don't need to use terminal commands - you can manage your apps using your mouse.

Conclusion

Portainer is an incredible tool that makes Docker accessible even for those without much Linux experience. If you are looking for a server to run your own projects, VoxiHost offers Premium VPS and Budget VPS with Ubuntu and Debian ready to go.

Install FileBrowser with Docker on Your VPS

2026-07-13T00:00:00Z

Introduction

Owning a VPS server is great, but transferring files to it via the terminal (SFTP) can be cumbersome. How about turning your cheap server into a convenient cloud drive (like Google Drive or Dropbox) that you can operate 100% from your web browser?

Enter FileBrowser - an incredibly lightweight file manager. It works blazingly fast, doesn't require a domain name (you can just use your IP address), and uses so few resources that it runs perfectly on even the cheapest Budget VPS from our lineup!

Step 1: Quick Launch via Docker

Log into your server via terminal. Running FileBrowser comes down to one simple command. Paste the code below and press ENTER:

docker run -d --name filebrowser -v /:/srv -p 8080:80 --restart always filebrowser/filebrowser

What exactly does this command do?

-p 8080:80 exposes the dashboard on port 8080.
-v /:/srv gives the app access to your server's entire root file system, allowing you to browse and edit absolutely any system file through your browser!

That's it for the terminal! Now open your web browser and enter your server's IP address along with port 8080:

http://SERVER_IP_ADDRESS:8080

You will see a clean, minimalist login screen.

To log in, use admin as the username. In modern versions of FileBrowser, there is no static default password for security reasons.
Your one-time temporary password was auto-generated. To find it, go back to your terminal and run:

docker logs filebrowser

Look for a line mentioning the randomly generated password in the logs. Copy it and use it to log in.

Step 3: Changing the Default Password (Important!)

Right after logging in, you must secure your drive so no one else can access your files. Click on the Settings tab in the left-hand menu, and then go to the Profile Settings section.

Enter a new, strong password, confirm it, and click the "Update" button. Your private drive is now fully secure.

You can now do whatever you want with your drive. In the top right corner, you'll find buttons to create new folders, upload files, and even create empty text files that you can edit directly in the browser!

By selecting any file, you can click the Share icon to generate a special link. You can send this link to a friend so they can download the file directly from your server without needing an account.

Conclusion

FileBrowser is a "must-have" for any private server. It uses a fraction of a percent of RAM and offers massive convenience for managing files in Linux. Use this solution on your new Premium VPS and forget about using clumsy FTP programs!

Install Uptime Kuma with Docker: Self-Hosted Monitoring

2026-07-07T00:00:00Z

Introduction

Have you ever woken up in the morning only to discover that your Minecraft server or website has been down for several hours? Instead of relying on paid solutions like Uptime Robot, you can host your own, beautiful, and 100% free monitoring system.

Uptime Kuma is a powerful open-source tool that can monitor websites, game servers, TCP ports, and DNS services. In this quick tutorial, we will show you how to install it on your own server using Docker in just 15 minutes!

Tip: Uptime Kuma does not consume many resources. The cheapest plan from our Budget VPS lineup (e.g., based on Ubuntu 22.04) will easily be enough for this task.

Step 1: Docker Compose Preparation

The entire Uptime Kuma application runs in a single Docker container. If you don't have Docker installed yet, use the official installation script:

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

We recommend using the Docker Compose plugin (it is built-in in the latest versions, but let's make sure):

sudo apt-get install docker-compose-plugin

Check the version to ensure everything is working:

docker compose version

Step 2: Uptime Kuma Configuration and Startup

Now we will create a dedicated folder for our application and configure the YAML file with container settings.

mkdir -p ~/uptime-kuma
cd ~/uptime-kuma

Create a docker-compose.yml file using your favorite text editor, for example, nano:

nano docker-compose.yml

Paste the following content into it:

services:
  uptime-kuma:
    image: louislam/uptime-kuma:1
    container_name: uptime-kuma
    volumes:
      - ./uptime-kuma-data:/app/data
    ports:
      - "3001:3001"  # You can change the left value to another port if 3001 is taken
    restart: always

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

Next, run the application in the background using the command:

sudo docker compose up -d

That's it! The application will download the image and start up. You can verify this by typing sudo docker ps.

To log into the panel, open your server's IP address in a browser, appending port 3001, e.g.:
http://YOUR_IP_ADDRESS:3001

Security: Remember that while Uptime Kuma forces you to create a password, connecting via HTTP is not the most secure. Be sure to check out our guide on How to Configure Nginx Proxy Manager to connect your domain to Uptime Kuma and generate a free SSL certificate!

Upon entering the site, you will create your administrator account (username and password).

Next, in the top left corner, click "Add New Monitor".
You have a multitude of options to choose from here, e.g.:

HTTP(s): to check if a website (e.g., your blog) is working.
TCP Port: to check if an SSH process (port 22) or network application is running.
Steam Game Server: ideal for game servers (e.g., FiveM, Rust).
Minecraft: a built-in feature that queries MC servers directly (you provide the IP address and game port).

Fill out the form and click "Save". Your first monitor is now up and running!

Step 4: Configuring Notifications

Monitoring is useless if nobody knows about an outage. Uptime Kuma supports over 90(!) notification services, including Telegram, Discord, Slack, Email (SMTP), and even Microsoft Teams.

We will show you how to configure simple notifications on Discord:

On your Discord server, go to a text channel's Settings -> Integrations -> Create Webhook. Copy its URL.
In Uptime Kuma, go to the top menu and enter Settings -> Notifications.
Click "Setup Notification".
Select type: Discord.
Paste the copied Webhook URL.
Click Test to see if the bot sent a test message to your channel. If so, save it by clicking Save.

Now, when creating or editing any monitor (Step 3), make sure you have selected your newly created notification channel on the right side!

Conclusion

Setting up your own monitoring system is just a few minutes of work. Thanks to Uptime Kuma, you maintain full privacy of your logs and avoid paying subscription fees for premium services (like short, 1-minute check intervals, which can be very expensive in SaaS solutions).

Uptime Kuma installed on a stable VoxiHost Budget VPS is a guarantee that you will know about the failure of your main projects before your clients or players notice it!

VoxiShield Smart Firewall Dashboard Controls Released

2026-07-06T00:00:00Z

At VoxiHost, network security has always been a core foundation, meaning every VPS we host is protected automatically from day one by our two-layer VoxiShield protection. Today, we are taking a massive leap forward by putting that power directly into your hands.

We are thrilled to announce the official release of the VoxiShield DDoS Protection & Smart Firewall management panel inside the VoxiHost dashboard! You are no longer restricted to default background filtering; you can now customize, monitor, and define your network security policies in real-time.

The Two-Layer Mitigation Pipeline

Traditional firewalls operate directly on the server operating system, consuming precious CPU and RAM resources during a network attack. VoxiShield filters malicious traffic in a progressive, off-loaded pipeline before it ever reaches your virtual machine.

Layer 01: PletX Edge (Volumetric Filtering)

All incoming global traffic first passes through the PletX Edge scrubbing network. This layer is unmanaged and operates 100% automatically. It acts as a massive shield, soaking up volumetric DDoS floods (like DNS/NTP amplification or UDP floods) up to 4+ Tbit/s so that your server's bandwidth remains completely untouched.

Layer 02: Core Firewall (Dashboard Managed)

Once volumetric threats are neutralized, traffic reaches our transparent Core Firewall. This is the layer you control. Directly from the VoxiHost dashboard, you can define custom traffic access rules, manage ports, configure rate limits, and block malicious traffic with sub-second propagation.

Powerful Firewall Features at Your Fingertips

We designed VoxiShield to replace complex iptables and nftables commands with an intuitive, visual control center. You do not need to be a network administrator to secure your VPS.

1. Inbound Rules & Rate Limiting

Control exactly who and what can connect to your applications. With our Inbound Rules panel, you can:

Open specific ports or custom port ranges.
Restrict protocols to TCP, UDP, or both.
Define custom actions (Allow / Drop) for each rule.
Apply precise packet-per-second (PPS) limits to protect game servers and applications from connection floods.

2. Egress Security (Outbound Control)

Keep your server's IP address clean and reputable. Outbound traffic control allows you to monitor and limit egress data, preventing a compromised application from scanning the internet or joining botnets.

Default Port 25 (SMTP) Block to prevent your VPS from sending spam emails.
Outbound custom port whitelist controls to restrict egress traffic to verified services.

3. Block Analyzer

Diagnosing network issues is now effortless. If a legitimate user or external service is having trouble connecting, you can instantly query their IP address in the Block Analyzer.

Verify if an IP is flagged by Global Inbound filters (such as GeoIP or ASN blocks).
Check if the IP is temporarily rate-limited due to exceeding your PPS rules.

4. Global Inbound Filters

Block whole vectors of malicious traffic before they even reach your server's network card:

GeoIP Country Filter: Allow or block traffic from specific countries.
ASN Network Filter: Block entire hosting providers, VPN networks, or ISPs.
Threat Shield Intelligence: Automatically block known malicious botnets, scanners, and exploit sources updated daily.

Dedicated Game & Protocol Protection

Different services require different filtering rules. A website running on HTTPS needs web-specific scrubbing, while a Minecraft or Counter-Strike server requires low-latency UDP filtering.

VoxiShield includes dedicated, automatically deployed scrubbing templates tailored for the most popular games and protocols. These templates adapt in real-time to mitigate zero-day exploits and keep your latencies stable.

Special Launch Promotion: -35% OFF

To celebrate the release of the VoxiShield management interface, we are offering an exclusive discount on all our VPS hosting services. Protect your next project with built-in enterprise security at an unbeatable price!

Use promo code VOXISHIELD at checkout to receive 35% OFF your monthly billing cycle.

Promo Details: This code is valid for all monthly plans until July 10, 2026.

Next Steps

With VoxiShield, enterprise-grade security is a standard, not a luxury. No surprise bills, no hidden bandwidth limits; only raw, high-performance protection that grows with your needs.

Ready to secure your infrastructure? Deploy a new Budget VPS or high-performance Premium VPS today, and manage your network policies through the VoxiShield Smart Firewall interface inside the VoxiHost dashboard right away!

How to Install NVIDIA Drivers on Ubuntu and AnduinOS

2026-06-30T00:00:00Z

Introduction

For optimal performance from an NVIDIA GPU on Linux, you must use the proprietary drivers. Although the open-source Nouveau driver suffices for basic display tasks, it lacks the optimizations necessary for gaming, GPU acceleration, and AI workloads on your VoxiHost workstation or server.

This guide covers the three main installation methods for NVIDIA drivers on Ubuntu-based systems, starting with the recommended automated tools and ending with a detailed manual installation procedure.

Prerequisites: Ensure your system is up to date and you have a compatible NVIDIA GPU. Always back up your system before making major driver changes.

Step 1: Automatic Installation

The recommended approach is to let the system detect the hardware automatically and install the appropriate driver version:

sudo apt update
sudo ubuntu-drivers install

Reboot your system once the installation completes. This method is ideal for most setups since it manages system updates and DKMS (Dynamic Kernel Module Support) automatically.

Step 2: (Optional) PPA Installation

If your hardware requires a newer driver version than the default repositories provide (such as for recent graphics card architectures), use the official graphics drivers PPA:

sudo add-apt-repository ppa:graphics-drivers/ppa
sudo apt update

You can then query the available versions and install the required one:

ubuntu-drivers list
sudo apt install nvidia-driver-550 # Replace with the desired version

Step 3: Manual Installation with Secure Boot

If you prefer the official manual .run installer and have UEFI Secure Boot enabled, you must sign the kernel module before the system will load it.

Generate a Signing Key

mkdir ~/mok-keys && cd ~/mok-keys
openssl req -new -newkey rsa:2048 -days 36500 -nodes -keyout MOK.key -out MOK.csr
openssl x509 -req -in MOK.csr -signkey MOK.key -out MOK.crt
openssl x509 -in MOK.crt -outform DER -out MOK.der

Enroll the Key

sudo mokutil --import MOK.der

Set a secure one-time password and reboot. During system boot, the blue MokManager utility will appear: choose "Enroll MOK", confirm, and enter the password.

Run the Installer

After boot, stop your display manager (if active) and launch the installer, passing the key paths as arguments:

sudo ./NVIDIA-Linux-x86_64-xxx.xx.run --module-signing-secret-key=/home/your-user/mok-keys/MOK.key --module-signing-public-key=/home/your-user/mok-keys/MOK.crt

Conclusion

Once the installation completes, verify the GPU status by running:

nvidia-smi

If you see a table with your GPU details, you are ready to go! For those running GPU-accelerated containers, don't forget to check out the NVIDIA Container Toolkit.

Looking for a high-performance environment for your AI projects? Check out VoxiHost Premium VPS plans with dedicated resources.

How to Find and Use the Fastest APT Mirror for Your Ubuntu Server

2026-06-29T00:00:00Z

Introduction

When deploying a new Ubuntu server, the default APT package manager configuration typically points to global mirrors. Depending on your VoxiHost server's physical location, this may cause slower download speeds during package installations and system updates.

To maximize throughput, you should configure APT to use the fastest regional mirror. This guide provides a simple script that benchmarks mirror speeds, selects the lowest-latency option, and updates your configuration (supporting both the legacy sources.list and modern ubuntu.sources formats).

Step 1: Create the Mirror Selection Script

We will use a bash script that tests the response time of various global mirrors using curl.

Create a new file named fastest-mirror.sh using your preferred text editor:

nano fastest-mirror.sh

Paste the following script into the file:

#!/bin/bash

# Check current APT source format status
check_apt_format() {
    local old_format=false
    local new_format=false
    
    if [ -f "/etc/apt/sources.list" ]; then
        if grep -v '^#' /etc/apt/sources.list | grep -q '[^[:space:]]'; then
            old_format=true
        fi
    fi
    
    if [ -f "/etc/apt/sources.list.d/ubuntu.sources" ]; then
        if grep -v '^#' /etc/apt/sources.list.d/ubuntu.sources | grep -q '[^[:space:]]'; then
            new_format=true
        fi
    fi
    
    if $old_format && $new_format; then
        echo "both"
    elif $old_format; then
        echo "old"
    elif $new_format; then
        echo "new"
    else
        echo "none"
    fi
}

# Find the fastest mirror
find_fastest_mirror() {
    echo "Testing mirror speeds..." >&2
    codename=$(lsb_release -cs)
    
    mirrors=(
        "http://archive.ubuntu.com/ubuntu/"
        "https://mirror.i3d.net/pub/ubuntu/"
        "https://mirroronet.pl/pub/mirrors/ubuntu/"
        "http://us.archive.ubuntu.com/ubuntu/"
        "http://uk.archive.ubuntu.com/ubuntu/"
        "http://de.archive.ubuntu.com/ubuntu/"
        "https://ftp.uni-stuttgart.de/ubuntu/"
        "https://mirror.ubuntu.ikoula.com/"
    )
    
    declare -A results
    
    for mirror in "${mirrors[@]}"; do
        echo "Testing $mirror ..." >&2
        response="$(curl -o /dev/null -s -w "%{http_code} %{time_total}\n" \
                  --connect-timeout 2 --max-time 3 "${mirror}dists/${codename}/Release")"
        
        http_code=$(echo "$response" | awk '{print $1}')
        time_total=$(echo "$response" | awk '{print $2}')
        
        if [ "$http_code" -eq 200 ]; then
            results["$mirror"]="$time_total"
        else
            results["$mirror"]="9999"
        fi
    done
    
    sorted_mirrors="$(
        for url in "${!results[@]}"; do
            echo "$url ${results[$url]}"
        done | sort -k2 -n
    )"
    
    fastest_mirror="$(echo "$sorted_mirrors" | head -n 1 | awk '{print $1}')"
    
    if [[ "$fastest_mirror" == "" || "${results[$fastest_mirror]}" == "9999" ]]; then
        fastest_mirror="http://archive.ubuntu.com/ubuntu/"
    fi
    
    echo "$fastest_mirror"
}

# Generate new format source list
generate_new_format() {
    local mirror="$1"
    local codename="$2"
    
    echo "Generating new format source list /etc/apt/sources.list.d/ubuntu.sources"
    
    sudo tee /etc/apt/sources.list.d/ubuntu.sources >/dev/null <<EOF
Types: deb
URIs: $mirror
Suites: $codename $codename-updates $codename-backports $codename-security
Components: main restricted universe multiverse
Signed-By: /usr/share/keyrings/ubuntu-archive-keyring.gpg
EOF
}

# Generate old format source list
generate_old_format() {
    local mirror="$1"
    local codename="$2"
    
    echo "Generating old format source list /etc/apt/sources.list"
    
    sudo tee /etc/apt/sources.list >/dev/null <<EOF
deb $mirror $codename main restricted universe multiverse
deb $mirror $codename-updates main restricted universe multiverse
deb $mirror $codename-backports main restricted universe multiverse
deb $mirror $codename-security main restricted universe multiverse
EOF
}

main() {
    sudo apt update
    sudo apt install -y curl lsb-release
    
    format=$(check_apt_format)
    codename=$(lsb_release -cs)
    
    fastest_mirror=$(find_fastest_mirror)
    echo "Fastest mirror found: $fastest_mirror"
    
    case "$format" in
        "old"|"none")
            generate_old_format "$fastest_mirror" "$codename"
            ;;
        "new"|"both")
            if [ "$format" == "both" ]; then
                sudo mv /etc/apt/sources.list /etc/apt/sources.list.bak
            fi
            generate_new_format "$fastest_mirror" "$codename"
            ;;
    esac
    
    sudo apt update
    echo "APT source optimization completed!"
}

main

Note: The mirror list in this script is focused on major European and US mirrors (ideal for Premium VPS locations). You can easily add more regional URLs to the mirrors array if your server is located elsewhere.

Step 2: Make the Script Executable

Save and close the file, then grant the script execute permissions:

chmod +x fastest-mirror.sh

Step 3: Run the Script

Run the script to test the mirrors. It will install curl and lsb-release if necessary, analyze latencies, and write the new config in the appropriate format for your Ubuntu version.

./fastest-mirror.sh

You should see output similar to this:

Testing mirror speeds...
Testing http://archive.ubuntu.com/ubuntu/ ...
Testing https://mirroronet.pl/pub/mirrors/ubuntu/ ...
Fastest mirror found: https://mirroronet.pl/pub/mirrors/ubuntu/
Generating new format source list /etc/apt/sources.list.d/ubuntu.sources
Hit:1 https://mirroronet.pl/pub/mirrors/ubuntu noble InRelease
...
APT source optimization completed!

Conclusion

Your server is now configured to fetch packages from the fastest available regional mirror, drastically reducing the time it takes to install software and apply security updates.

Looking for high-performance hosting in Europe? Deploy a VoxiHost Budget VPS today and experience the speed of NVMe storage combined with optimal network routing.

LiteSpeed vs Caddy: The Battle of Modern Web Servers

2026-06-23T00:00:00Z

While Nginx and Apache remain the most widely used web servers on the internet, two modern alternatives have gained massive popularity among developers, sysadmins, and bloggers: LiteSpeed (specifically the open-source version, OpenLiteSpeed) and Caddy.

Both servers are designed to be faster and easier to manage than legacy systems. However, they target completely different use cases and development workflows.

In this guide, we will compare OpenLiteSpeed and Caddy under the hood, analyze their configuration files, evaluate their performance (especially for WordPress), and help you decide which one to install on your VoxiHost server.

1. What is OpenLiteSpeed?

OpenLiteSpeed (OLS) is the open-source edition of LiteSpeed Web Server Enterprise. It is designed to act as a drop-in high-performance replacement for Apache, sharing many configuration concepts while delivering event-driven speeds comparable to Nginx.

OLS Key Features:

Apache Compatibility: Understands Apache rewrite rules directly, meaning you don't need to rebuild complex configuration files.
WebAdmin GUI: Features a built-in web-based console where you can manage virtual hosts, listeners, SSL, and security settings visually.
LSCache Engine: LiteSpeed's proprietary, built-in page caching module. It is widely considered the fastest server-level cache for WordPress, Magento, and XenForo.

2. What is Caddy?

Caddy is a modern, open-source web server written in Go. Its main selling point is simplicity and security by default. It was the first web server to obtain and renew SSL/TLS certificates automatically from Let's Encrypt and ZeroSSL without requiring external tools like Certbot.

Caddy Key Features:

Automatic SSL: Out of the box, Caddy manages the entire lifecycle of SSL certificates for all configured domains automatically.
The Caddyfile: Caddy uses a human-readable configuration file that is incredibly short and easy to understand.
Written in Go: Inherits memory safety and compiled performance from the Go runtime, eliminating common buffer overflow vulnerabilities.

3. Configuration Comparison: WebAdmin GUI vs Caddyfile

Configuring these two servers represents two entirely different philosophies.

Configuring OpenLiteSpeed

OLS configurations are traditionally managed via the WebAdmin GUI (listening on port 7080). While convenient for people who prefer clicking buttons over editing text files, it can make automation (like Ansible or Docker setups) slightly more complex since configuration changes are saved to separate XML/conf files.

If you want to configure redirects or rewrites, you can write Apache-style rules directly in the Virtual Host control panel.

Configuring Caddy

Caddy uses a single, centralized text file called the Caddyfile. It is incredibly clean. For example, to host a reverse proxy with automated SSL for example.com, your entire Caddyfile is just:

example.com {
    reverse_proxy localhost:3000
}

Caddy automatically detects the domain, contacts Let's Encrypt, completes the HTTP challenge, provisions the certificate, and configures an automatic HTTP to HTTPS redirect. No additional lines of configuration are needed.

4. Performance & WordPress Hosting

Performance varies drastically depending on whether you are hosting static sites, modern APIs, or PHP applications like WordPress.

WordPress Performance: OpenLiteSpeed is King

If your primary goal is to host a WordPress website, OpenLiteSpeed paired with the LSCache plugin is the absolute winner.

LSCache communicates directly with the OLS server core, allowing it to bypass PHP execution entirely for cached pages. It supports advanced optimizations like CSS/JS minification, database cleaning, and instant cache purging when a post is updated. WordPress benchmarks show LiteSpeed handling thousands of concurrent requests with sub-millisecond response times.

WordPress Caching Tip: When using OpenLiteSpeed, avoid using standard PHP-based caching plugins like WP Rocket or W3 Total Cache. The LSCache plugin is designed specifically to interface directly with the server core, which yields much higher performance and uses fewer CPU resources.

Reverse Proxy & Static Sites: Caddy Wins on Simplicity

If you are deploying a Node.js API, a Go microservice, or a static website (React, Hugo, Vue), Caddy is the superior choice. It acts as an incredibly lightweight, zero-maintenance reverse proxy. You don't have to worry about renewing certificates or writing complex redirection blocks.

5. Summary Comparison Matrix

Feature	OpenLiteSpeed	Caddy
Language	C++	Go (Memory safe)
Primary Admin Interface	Web GUI (Port 7080)	Text file (Caddyfile)
Automatic SSL	Yes (via Certbot/Acme scripts)	Yes (Natively out-of-the-box)
Apache Rewrite Rules	Yes (Native support)	No (Requires translation)
Best Use Case	PHP/WordPress hosting	Reverse Proxy, Go/Node.js, SPAs
Caching Engine	LSCache (Highly advanced)	Requires third-party plugins/headers

Conclusion: Which One Fits Your VPS?

Install OpenLiteSpeed if you are hosting a WordPress blog or e-commerce shop and want the absolute fastest load times using LiteSpeed Cache. It runs beautifully on our Premium VPS plans where SSD NVMe speeds amplify page loading performance.
Install Caddy if you are a developer looking for a simple, modern web server with automated SSL that you can set up in 10 seconds to reverse-proxy your custom apps on a Budget VPS.

Both servers are fully compatible with VoxiHost networks and work seamlessly behind our Shield DDoS protection to keep your web services secure and fast.

Docker vs Podman: Container Engines Comparison for Linux Systems

2026-06-22T00:00:00Z

Containerization has completely changed how developers build, ship, and run software. For a long time, the name Docker was synonymous with container technology. However, Red Hat introduced Podman (Pod Manager) as a direct alternative, designed to fix some of Docker's fundamental architectural and security issues.

If you are setting up a new virtual private server, you might wonder: should you stick with the industry-standard Docker, or is it time to switch to the security-focused Podman?

In this guide, we will break down the structural differences, security configurations (rootless containers), Docker Compose compatibility, and help you select the ideal engine for your VoxiHost server.

1. The Core Architecture: Daemon vs Daemonless

The most significant difference between Docker and Podman is how they manage container processes under the hood.

Docker: Daemon-Based Architecture

Docker relies on a central background service (daemon) called dockerd.
When you run a command like docker run, the Docker CLI client talks to the dockerd daemon via a REST API, and the daemon executes the request.

This means that if the Docker daemon crashes or needs to be restarted, all running containers on your server are temporarily affected or restarted unless live-restore is explicitly enabled. Furthermore, by default, the standard Docker daemon must run with root privileges, although since version 20.10, it can be run in rootless mode with additional configuration.

Podman: Daemonless Architecture

Podman does not use a background daemon.
When you run a command like podman run, Podman directly calls standard Linux system features (using the OCI container runtime like runc or crun) to launch and monitor the container.

This is known as a daemonless architecture. Each container runs as an independent child process of the user who started it. If Podman itself is updated or closed, the containers continue to run uninterrupted.

2. Security: The Power of Rootless Containers

Security is where Podman shines brightest. Because Docker runs as a root-level daemon, anyone with access to the Docker socket effectively has root access to the entire host operating system. If an attacker escapes a Docker container, they immediately gain control over the host.

Podman was built from the ground up to support rootless containers.

Rootless: Podman can run, build, and manage containers without requiring root privileges or sudo access.
User Namespaces: It utilizes Linux user namespaces to map the root user inside the container to a regular non-root user on the host VPS.

If a rootless Podman container is compromised or an attacker manages to break out of it, they are still isolated inside a standard, unprivileged user account on the host VPS, preventing them from accessing system files or other users' data.

Security Note (Docker Rootless Support): It is worth noting that since version 20.10, Docker officially supports rootless mode, and it is available "out of the box" on Ubuntu and Debian. However, setting it up still requires post-installation configuration (such as setting up user-level systemd files and slirp4netns network drivers), whereas Podman is built with rootless operation as its primary, zero-configuration default.

3. Docker Compose & CLI Compatibility

When Podman was created, the developers wanted to make transition as painless as possible. Podman is a drop-in replacement for the Docker CLI.

Almost all commands are identical. You can even set up an alias in your shell:

alias docker=podman

What about Docker Compose?

Historically, Podman lacked support for docker-compose.yml files because Docker Compose relies heavily on communicating with the Docker daemon socket (/var/run/docker.sock).

To address this, Podman now provides:

Podman Compose: A python-based implementation of the compose specification.
Podman Socket Service: A systemd service that emulates the Docker socket (podman.socket), allowing you to use the official Docker Compose binary directly.

# Enable the Podman socket for compatibility
systemctl --user enable --now podman.socket
export DOCKER_HOST="unix://$XDG_RUNTIME_DIR/podman/podman.sock"
docker-compose up -d

Compatibility Tip: While Podman's emulation socket works well for standard multi-container environments, complex setups (like Traefik or Portainer) that require direct, read-write access to /var/run/docker.sock to dynamically read container metadata are still easier to manage and run on native Docker.

4. Systemd Integration

Because Podman doesn't have a central daemon to restart containers after a server reboot (like Docker's restart: always), it delegates process management to the host operating system's native init system: Systemd.

Podman can automatically generate systemd service files for your containers:

podman generate systemd --name my-web-app --files

This lets you manage container lifecycles just like any other Linux service:

systemctl --user enable --now container-my-web-app.service

5. Performance in Practice: Benchmarks

To move beyond theoretical differences, we ran a series of performance benchmarks on a VoxiHost Premium VPS (2 vCPU, 4 GB RAM, Ubuntu 24.04 LTS). We compared Docker Engine v26.1.0 with Podman v4.9.4 running in rootless mode. The results below are averaged across three independent test runs.

Test Results Matrix

Metric / Test	Docker	Podman (Rootless)	Winner
Image Pull Time (`postgres:16` - approx. 450 MB)	12.4 s	11.2 s	Podman (Slight edge)
Image Build Time (Node.js App + NPM install)	48.2 s	53.6 s	Docker (Faster BuildKit caching)
Memory Footprint (Idle) (No containers running)	~75 MB	~25 MB	Podman (No background daemon)
Memory Footprint (50 Nginx containers) (Idle)	~320 MB	~460 MB	Docker (Lower overhead per container)

Key Takeaways:

Idle Resource Usage: Podman is the clear winner when no containers are active. Because there is no background daemon running continuously, it consumes virtually zero system resources.
Resource Overhead at Scale: When launching 50 idle containers, Docker is more memory-efficient. In rootless mode, Podman spins up separate helper processes (conmon for monitoring and slirp4netns for user-space networking) for each container. At scale, this network and monitoring overhead scales linearly.
Build Speed: Docker's BuildKit engine remains the fastest for building images due to its highly optimized concurrent staging and aggressive caching. Podman (which uses buildah under the hood) is slightly slower but builds images safely inside user space without requiring root privileges.

6. Summary Feature Matrix

Feature	Docker	Podman
Architecture	Daemon-based (`dockerd`)	Daemonless (direct OCI execution)
Root Privileges	Required for daemon	Optional (Fully rootless by default)
Pods Support	No (requires Kubernetes)	Yes (can group containers into Pods)
Docker Compose	Native support	Supported via socket emulation / podman-compose
Systemd Integration	Separate daemon configuration	Native systemd service generation
Security Level	Moderate (Requires hardening)	High (Default rootless isolation)

Conclusion: Which Engine to Choose?

Choose Docker if:

You use complex Docker Compose files with third-party tools that require direct access to /var/run/docker.sock.
You are deploying large-scale orchestration environments (like Kubernetes) where standard Docker integrations are pre-configured.
You want the widest community troubleshooting support.

Choose Podman if:

Security is your top priority, and you want to run containers in a multi-tenant environment without granting root access.
You are running isolated applications, web servers, or databases on a Premium VPS.
You want clean, native integration with systemd services for automated startup and process monitoring.

Both runtimes are fully compatible with Budget VPS and Premium VPS hosting configurations from VoxiHost.

How to Set Up a TeamSpeak 3 Server on Ubuntu & Debian

2026-06-16T00:00:00Z

TeamSpeak 3 remains one of the most reliable, low-latency, and resource-efficient voice communication platforms for gamers and communities. Self-hosting your own TeamSpeak server gives you ultimate privacy, full control over permissions, and zero reliance on third-party voice chat providers.

In this guide, you will learn how to properly install and secure a TeamSpeak 3 server on your Ubuntu or Debian VPS.

Prerequisites: Before starting, ensure you have a VPS running Ubuntu or Debian with SSH access and a user account with sudo privileges.

Step 1: Update the System

First, ensure your package index is updated and install the necessary utilities (wget for downloading and bzip2 for extracting the archive):

sudo apt update && sudo apt upgrade -y
sudo apt install wget bzip2 -y

Step 2: Create a Dedicated User

Running any public-facing service as the root user is a major security risk. Let's create a dedicated system user specifically for TeamSpeak:

sudo adduser --disabled-password --gecos "" teamspeak

Now, switch to this new user to perform the installation:

sudo su - teamspeak

Step 3: Download and Extract TeamSpeak 3

Fetch the latest TeamSpeak 3 server files. You can always find the newest version on the official TeamSpeak downloads page.

wget https://files.teamspeak-services.com/releases/server/3.13.8/teamspeak3-server_linux_amd64-3.13.8.tar.bz2

Extract the downloaded archive and move the files into the home directory for cleaner organization:

tar xvf teamspeak3-server_linux_amd64-3.13.8.tar.bz2
mv teamspeak3-server_linux_amd64/* .
rm -rf teamspeak3-server_linux_amd64 teamspeak3-server_linux_amd64-3.13.8.tar.bz2

Step 4: Accept the License Agreement

TeamSpeak requires you to accept their End User License Agreement (EULA) before the server will start. You can do this by creating an empty file named .ts3server_license_accepted:

touch .ts3server_license_accepted

Step 5: First Run and Privilege Key

Now, start the server manually for the first time. This step is critical because the server will display your ServerAdmin privilege key, which you need to claim admin rights in your TeamSpeak client.

./ts3server_startscript.sh start

You will see output containing your Privilege Key and ServerQuery Admin Credentials. Copy these details and save them somewhere safe!

Once you have saved the key, stop the server so we can configure it to run as a background service:

./ts3server_startscript.sh stop

Step 6: Configure a Systemd Service

To ensure your TeamSpeak server starts automatically if your VPS reboots, we need to create a systemd service. First, exit back to your sudo user:

exit

Create a new service file:

sudo nano /etc/systemd/system/teamspeak.service

Paste the following configuration:

[Unit]
Description=TeamSpeak 3 Server
After=network.target

[Service]
WorkingDirectory=/home/teamspeak
User=teamspeak
Group=teamspeak
Type=forking
ExecStart=/home/teamspeak/ts3server_startscript.sh start inifile=ts3server.ini
ExecStop=/home/teamspeak/ts3server_startscript.sh stop
PIDFile=/home/teamspeak/ts3server.pid
RestartSec=15
Restart=always

[Install]
WantedBy=multi-user.target

Save and exit (CTRL + O, ENTER, CTRL + X).

Reload systemd and start your new service:

sudo systemctl daemon-reload
sudo systemctl enable teamspeak
sudo systemctl start teamspeak

Check the status to verify it is running perfectly:

sudo systemctl status teamspeak

Conclusion

Congratulations! You have successfully installed and configured a TeamSpeak 3 server.

To connect, open your TeamSpeak 3 Client, connect to your server's IP address, and paste the Privilege Key you saved in Step 5 when prompted. You will instantly be granted Server Admin status.

Next Steps

If you have a firewall enabled, ensure you open the correct ports. Check out our guide on how to configure UFW. TeamSpeak requires ports 9987/udp (Voice), 10011/tcp (ServerQuery), and 30033/tcp (File Transfer).
Looking for a cost-effective hosting option? Try our Budget VPS options, or get ultimate reliability for large communities on a VoxiHost Premium VPS backed by VoxiShield DDoS Protection.

How to Install Nextcloud on a VPS using Docker Compose

2026-06-15T00:00:00Z

Introduction

Tired of paying monthly fees for Google Drive, Dropbox, or iCloud? With a VPS, you can host your own private, secure cloud storage using Nextcloud. Nextcloud is a powerful open-source platform that allows you to store files, sync contacts, and share documents with complete control over your data.

In this guide, we will deploy Nextcloud using Docker Compose, ensuring a clean, isolated, and easily manageable installation.

Prerequisites: Before you start, you need a Linux VPS with SSH access, a user account with sudo privileges, and Docker with Docker Compose already installed. If you haven't set up Docker Compose yet, check out our Docker Compose setup guide.

Step 1: Prerequisites

Before starting, ensure your VPS has Docker and Docker Compose installed. If you haven't set them up yet, check out our previous guide on how to set up Docker Compose.

Verify your installation:

docker compose version

Step 2: Set up the Project

We need a dedicated directory to store the Nextcloud configuration and persistent data.

mkdir ~/nextcloud-server
cd ~/nextcloud-server

Now, create the docker-compose.yml file:

nano docker-compose.yml

Paste the following configuration. This stack includes the official Nextcloud image along with a MariaDB database for optimal performance.

services:
  db:
    image: mariadb:latest
    restart: always
    command: --transaction-isolation=READ-COMMITTED --log-bin=binlog --binlog-format=ROW
    volumes:
      - db_data:/var/lib/mysql
    environment:
      - MYSQL_ROOT_PASSWORD=secure_root_password
      - MYSQL_PASSWORD=secure_db_password
      - MYSQL_DATABASE=nextcloud
      - MYSQL_USER=nextcloud

  app:
    image: nextcloud
    restart: always
    ports:
      - 8080:80
    links:
      - db
    volumes:
      - nextcloud_data:/var/www/html
    environment:
      - MYSQL_PASSWORD=secure_db_password
      - MYSQL_DATABASE=nextcloud
      - MYSQL_USER=nextcloud
      - MYSQL_HOST=db

volumes:
  db_data:
  nextcloud_data:

Note: Make sure to change secure_root_password and secure_db_password to strong, unique passwords before saving.

Save and exit (CTRL+X, then Y, then Enter).

Step 3: Deploy Nextcloud

With our configuration file ready, it's time to spin up the containers. Run the following command in detached mode:

docker compose up -d

Docker will download the necessary images and start the services. This might take a minute or two depending on your VPS internet speed.

Once the containers are running, open your web browser and navigate to your VPS's IP address on port 8080:

http://your_server_ip:8080

You will be greeted by the Nextcloud setup wizard. Create your admin account, and Nextcloud will automatically connect to the MariaDB database we configured in the docker-compose.yml file.

Conclusion

Congratulations! You now have your own self-hosted Nextcloud instance running securely inside Docker containers on your VPS. Your files are stored privately on hardware you control, with no subscription fees or third-party access to your data.

As a next step, we strongly recommend placing Nextcloud behind a custom domain with free HTTPS using Nginx Proxy Manager, so your cloud is accessible from anywhere via a clean, encrypted URL.

If you need a reliable server to host your self-managed cloud, check out our Premium VPS plans or Budget VPS options, which both come with fast NVMe SSD storage and high-bandwidth connectivity.

June 13, 2026: VoxiHost DevBlog

2026-06-13T00:00:00Z

Our latest platform updates are live as of June 13, 2026 at VoxiHost. We are committed to making our cloud hosting services more accessible, global, and user-friendly. In this release, we have focused on a major overhaul of our currency and billing systems, along with handy dashboard refinements to keep you updated on all new platform features.

From a complete rebranding of our platform currency to native multi-currency payment support, here is everything we’ve rolled out over the past few weeks.

1. Transition to Credits & Multi-Currency Support

To better serve our growing international user base, we are transitioning from vPLN to Credits. This change lays the foundation for our global expansion, ensuring a consistent billing experience regardless of where you are hosting your servers.

Along with this rebranding, we are proud to launch native multi-currency support. You can now select your preferred billing currency from PLN, USD, or EUR. By paying in your local currency, you can completely bypass bank conversion fees and enjoy a more transparent billing experience.

2. User-Friendly Credit Packages

Credits are pegged to PLN at a simple 1:1 ratio (1 Credit = 1 PLN) to keep everything clear and straightforward. To buy credits, you can choose from our tailored packages, which are optimized to offer the best value for each currency.

Here are the packages available for each currency (excluding any additional promotional bonuses):

PLN Packages

Price	Base Credits	Bonus Credits	Total Credits
15.00 PLN	15.00	-	15.00
30.00 PLN	30.00	-	30.00
50.00 PLN	50.00	-	50.00
100.00 PLN	100.00	-	100.00
250.00 PLN	250.00	5.00	255.00
500.00 PLN	500.00	20.00	520.00

EUR Packages

Price	Base Credits	Bonus Credits	Total Credits
5.00 EUR	20.00	-	20.00
10.00 EUR	42.00	-	42.00
20.00 EUR	85.00	-	85.00
50.00 EUR	210.00	5.00	215.00
100.00 EUR	420.00	20.00	440.00
250.00 EUR	1050.00	50.00	1100.00

USD Packages

Price	Base Credits	Bonus Credits	Total Credits
5.00 USD	20.00	-	20.00
10.00 USD	40.00	-	40.00
20.00 USD	80.00	-	80.00
50.00 USD	200.00	5.00	205.00
100.00 USD	400.00	20.00	420.00
250.00 USD	1000.00	50.00	1050.00

3. Special Launch Promotion: Code 'CREDITS'

To celebrate this milestone, we are launching a special promotion!

Use the promo code CREDITS when ordering any monthly VPS plan to get a massive 45% discount on your first month.

Important Notice: This promotion is time-limited and expires on June 15, 2026 at 23:59 CET. Don't miss out!

4. Rebuilt & Simplified Billing Page

To accompany these changes, we have completely rebuilt our Billing page from the ground up. The new interface is clean, intuitive, and highly self-explanatory. You can easily switch between currencies, view your current credit balance, select your desired credit package, and complete payments seamlessly.

We are constantly rolling out updates, fixes, and features. To ensure you never miss a thing, we've integrated a new 'What's New' widget directly into the dashboard sidebar.

Whenever we deploy updates, you'll see a quick notification highlight inviting you to read our changelog. This makes it easier than ever to discover new tools and improvements we make to the platform.

In addition to the new features, we have rolled out several minor user interface refinements and layout fixes to improve the dashboard experience across all devices.

What's Next?

Rebranding and multi-currency billing are major steps forward, but we aren't stopping there. We have officially begun working on a Dashboard Firewall, which will allow you to manage your network security policies directly from the VoxiHost dashboard.

Stay tuned for more updates, and as always, thank you for choosing VoxiHost!

Ready to check out the new billing page? Log in to your Dashboard and check out your active instances today!

Guides & Tutorials

How to Secure Nginx with Fail2Ban

Introduction

Prerequisites

Step 1: Install Nginx and Fail2Ban

Step 2: Configure the Fail2Ban Jail

Step 3: Enable the Nginx Jails

Step 4: Verify Fail2Ban Functionality

Conclusion

How to Install Node.js on Ubuntu & Debian

Introduction

Prerequisites

Step 1: Update System Packages and Install Dependencies

Step 2: Add the NodeSource Repository

Step 3: Install Node.js and NPM

Step 4: Verify the Installation

Conclusion

How to Setup Python Venv on Ubuntu

Introduction

Prerequisites

Step 1: Install the Python Venv Module

Step 2: Create a Project Directory

Step 3: Create and Activate the Virtual Environment

Step 4: Manage Packages Within the Environment

Conclusion

How to Install PHP-FPM with Nginx on Ubuntu

Introduction

Prerequisites

Step 1: Install Nginx and PHP-FPM

Step 2: Configure the Nginx Server Block

Step 3: Create a PHP Test Script and Verify Setup

Conclusion

How to Install Portainer on Ubuntu & Debian VPS

Introduction

Step 1: Connect to your Server and Install Docker

Step 2: Prepare Storage for Portainer

Step 3: Run Portainer

Step 4: First Login in the Browser

Step 5: Managing Containers

Conclusion

Install FileBrowser with Docker on Your VPS

Introduction

Step 1: Quick Launch via Docker

Step 2: First Login to your Drive

Step 3: Changing the Default Password (Important!)

Step 4: Uploading and Sharing Files

Conclusion

Install Uptime Kuma with Docker: Self-Hosted Monitoring

Introduction

Step 1: Docker Compose Preparation

Step 2: Uptime Kuma Configuration and Startup

Step 3: First Login and Adding a Monitor

Step 4: Configuring Notifications

Conclusion

VoxiShield Smart Firewall Dashboard Controls Released

The Two-Layer Mitigation Pipeline

Layer 01: PletX Edge (Volumetric Filtering)

Layer 02: Core Firewall (Dashboard Managed)

Powerful Firewall Features at Your Fingertips

1. Inbound Rules & Rate Limiting

2. Egress Security (Outbound Control)

3. Block Analyzer

4. Global Inbound Filters

Dedicated Game & Protocol Protection

Special Launch Promotion: -35% OFF

Next Steps

How to Install NVIDIA Drivers on Ubuntu and AnduinOS

Introduction

Step 1: Automatic Installation

Step 2: (Optional) PPA Installation

Step 3: Manual Installation with Secure Boot

Generate a Signing Key

Enroll the Key

Run the Installer

Conclusion

How to Find and Use the Fastest APT Mirror for Your Ubuntu Server

Introduction

Step 1: Create the Mirror Selection Script

Step 2: Make the Script Executable

Step 3: Run the Script