Forem: Sanskriti Harmukh

Setting Up WireGuard VPN on Ubuntu 26.04

Sanskriti Harmukh — Fri, 08 May 2026 15:57:16 +0000

WireGuard is a modern VPN protocol built into the Linux kernel since version 5.6, offering a significantly smaller codebase, faster handshakes, and lower latency compared to OpenVPN or IPsec. This guide sets up a WireGuard server on Ubuntu 26.04, generates key pairs for the server and a client, configures IP forwarding, and walks through connecting a client device with a verified tunnel.

Install WireGuard

WireGuard is available directly from Ubuntu 26.04's default APT repository.

1. Update the APT package index:

$ sudo apt update

2. Install WireGuard:

$ sudo apt install wireguard -y

Configure the WireGuard Server

The server configuration requires generating a key pair, identifying the active network interface, and creating the wg0 interface configuration file.

1. Generate the server private key:

$ wg genkey | sudo tee /etc/wireguard/server_private.key
$ sudo chmod 600 /etc/wireguard/server_private.key

2. Derive the server public key:

$ sudo cat /etc/wireguard/server_private.key | wg pubkey | sudo tee /etc/wireguard/server_public.key

3. Identify the main network interface:

$ ip route | grep default

Note the interface name in the output, commonly eth0 or ens3.

4. Create the server interface configuration:

$ sudo nano /etc/wireguard/wg0.conf

[Interface]
Address = 10.0.0.1/24
ListenPort = 51820
PrivateKey = <paste server private key here>
PostUp = iptables -A FORWARD -i wg0 -j ACCEPT; iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
PostDown = iptables -D FORWARD -i wg0 -j ACCEPT; iptables -t nat -D POSTROUTING -o eth0 -j MASQUERADE

Replace eth0 with your actual interface name.

Generate a Client Configuration

Each client requires its own key pair and a configuration file that references the server's public key and endpoint.

1. Generate the client key pair:

$ wg genkey | tee client_private.key
$ cat client_private.key | wg pubkey | tee client_public.key

2. Get the server public key:

$ sudo cat /etc/wireguard/server_public.key

3. Create the client configuration file:

$ nano client.conf

[Interface]
Address = 10.0.0.2/32
PrivateKey = <client private key>
DNS = 8.8.8.8

[Peer]
PublicKey = <server public key>
Endpoint = YOUR-SERVER-IP:51820
AllowedIPs = 0.0.0.0/0
PersistentKeepalive = 25

4. Register the client as a peer on the server:

Add the following block to /etc/wireguard/wg0.conf:

[Peer]
PublicKey = <client public key>
AllowedIPs = 10.0.0.2/32

Configure IP Forwarding and Firewall

IP forwarding must be enabled at the kernel level for the server to route traffic between the VPN interface and the external network.

1. Enable IPv4 forwarding:

$ echo "net.ipv4.ip_forward=1" | sudo tee -a /etc/sysctl.conf
$ sudo sysctl -p

2. Open the WireGuard UDP port:

$ sudo ufw allow 51820/udp

Start WireGuard

Enable the wg0 interface as a systemd service so it starts automatically on every boot.

1. Enable and start the service:

$ sudo systemctl enable wg-quick@wg0
$ sudo systemctl start wg-quick@wg0

2. Check the service status:

$ sudo systemctl status wg-quick@wg0

3. View the interface and connected peers:

$ sudo wg show

Connect a Client

Transfer the client configuration to the target device and establish the tunnel.

1. Transfer the client configuration securely:

$ scp client.conf user@your-local-machine:~/

2. Connect from the client device:

Linux: sudo wg-quick up ~/client.conf
Windows / macOS / iOS / Android: Install the WireGuard app and import client.conf

3. Test the tunnel:

$ ping 10.0.0.1

Replies from 10.0.0.1 confirm the VPN tunnel is active and traffic is flowing through the encrypted interface.

Next Steps

WireGuard is running and accepting client connections. From here you can:

Add more clients by generating additional key pairs and adding new [Peer] blocks to wg0.conf
Restrict each client to specific subnets by adjusting AllowedIPs per peer
Reload the configuration without restarting using sudo wg syncconf wg0 <(sudo wg-quick strip wg0)

For the complete guide, visit the original article on Vultr Docs.

Installing Webmin on Ubuntu 26.04

Sanskriti Harmukh — Fri, 08 May 2026 15:57:07 +0000

Webmin is an open-source web-based administration panel for Linux servers, providing a graphical interface for managing users, packages, firewall rules, cron jobs, and services without requiring command-line access. This guide installs Webmin on Ubuntu 26.04 from the official repository and secures the panel with a Let's Encrypt certificate for trusted HTTPS access.

Install Webmin

Webmin provides an official setup script that registers its APT repository and signing key before installation.

1. Update the APT package index:

$ sudo apt update

2. Download the setup script:

$ curl -o webmin-setup-repo.sh https://raw.githubusercontent.com/webmin/webmin/master/webmin-setup-repo.sh

3. Run the setup script:

$ sudo bash webmin-setup-repo.sh

4. Install Webmin:

$ sudo apt install --install-recommends webmin -y

Manage the Webmin Service

Enable Webmin as a systemd service so it starts automatically on every boot.

1. Enable and start the service:

$ sudo systemctl enable webmin
$ sudo systemctl start webmin

2. Check the service status:

$ sudo systemctl status webmin

3. Stop or restart the service when needed:

$ sudo systemctl stop webmin
$ sudo systemctl restart webmin

Configure Firewall Rules

Open the ports required for HTTP, HTTPS, and the Webmin dashboard.

$ sudo ufw allow 80/tcp
$ sudo ufw allow 443/tcp
$ sudo ufw allow 10000/tcp

Secure Webmin with Let's Encrypt SSL

Webmin ships with a self-signed certificate by default. Replacing it with a Let's Encrypt certificate removes browser security warnings and establishes a trusted connection.

1. Install Certbot:

$ sudo apt install certbot -y

2. Generate the certificate:

$ sudo certbot certonly --standalone -d webmin.example.com --agree-tos -m your@email.com

3. Combine the certificate files into the format Webmin expects:

$ sudo cat /etc/letsencrypt/live/webmin.example.com/privkey.pem \
    /etc/letsencrypt/live/webmin.example.com/fullchain.pem \
    | sudo tee /etc/webmin/webmin.pem

4. Update the Webmin configuration to reference the certificate:

$ sudo nano /etc/webmin/miniserv.conf

Find the keyfile= line and update it to:

keyfile=/etc/webmin/webmin.pem

5. Restart Webmin to apply the change:

$ sudo systemctl restart webmin

Access the Dashboard

Open the Webmin dashboard in a browser at the following URL:

https://webmin.example.com:10000

Log in with the server's Linux username and password, the same credentials used for SSH. The dashboard provides access to modules for package updates, user and group management, file management, firewall rules, cron job scheduling, and server software such as Apache and MySQL.

Next Steps

Webmin is running and accessible over HTTPS. From here you can:

Install additional modules such as MySQL, ProFTPD, and Bind DNS from the module installer
Set up Usermin to give individual users access to their own mail and files
Install Virtualmin on top of Webmin for full web hosting control panel functionality

For the complete guide, visit the original article on Vultr Docs.

Installing Python and pip on Ubuntu 26.04

Sanskriti Harmukh — Fri, 08 May 2026 15:56:56 +0000

Ubuntu 26.04 ships Python 3.14 in its default APT repository, making it available without any external sources or version management overhead. This guide covers installing Python and pip, verifying the interpreter, and setting up virtual environments to keep project dependencies isolated from the system installation and from each other.

Install Python

Python 3.14 is available directly from Ubuntu 26.04's default APT repository.

1. Update the APT package index:

$ sudo apt update

2. Install Python:

$ sudo apt install python3 -y

3. Verify the installed version:

$ python3 --version

Install pip

pip is the standard package manager for Python, used to install and manage packages from the Python Package Index.

1. Install pip:

$ sudo apt install python3-pip -y

2. Verify the installed version:

$ pip3 --version

Test the Python Interpreter

The interactive shell confirms the interpreter is installed and responding correctly.

$ python3

>>> print("Hello, Python!")
Hello, Python!
>>> import sys; print(sys.version)
>>> exit()

Create a Virtual Environment

Virtual environments provide isolated Python installations where each project maintains its own set of dependencies, preventing version conflicts across projects and protecting the system Python installation.

1. Install the venv module:

$ sudo apt install python3-venv -y

2. Create a new virtual environment:

$ python3 -m venv example_env

3. Activate the environment:

$ source example_env/bin/activate

The prompt changes to (example_env) to indicate the environment is active.

4. Install a package inside the environment:

$ pip install requests

5. List installed packages:

$ pip list

6. Deactivate the environment:

$ deactivate

The requests package remains scoped to example_env and does not affect any other project or the system Python installation.

Next Steps

Python and pip are now installed and ready for development. From here you can:

Use pipx to install CLI tools in isolated environments without affecting project dependencies
Try uv for faster package management and built-in virtual environment support
Set up a Jupyter Notebook server for interactive data science and analysis workflows

For the complete guide, visit the original article on Vultr Docs.

Installing Node.js and npm on Ubuntu 26.04

Sanskriti Harmukh — Fri, 08 May 2026 15:56:46 +0000

Ubuntu's default APT repository ships an outdated Node.js build that is not suitable for modern JavaScript development. This guide installs Node.js 24.x from the NodeSource repository and covers NVM as an alternative for managing multiple versions side by side, verified with a running Express application confirming the setup.

Install Node.js via NodeSource

NodeSource maintains a Debian/Ubuntu repository that tracks current Node.js major releases, providing a single pinned version installed system-wide.

1. Update the APT package index:

$ sudo apt update

2. Download the NodeSource setup script:

$ curl -fsSL https://deb.nodesource.com/setup_24.x -o nodesource_setup.sh

3. Run the setup script:

$ sudo bash nodesource_setup.sh

4. Install Node.js:

$ sudo apt install nodejs -y

5. Verify the installation:

$ node -v
$ npm -v

Manage Multiple Versions with NVM

NVM allows installing and switching between Node.js versions without affecting system-wide packages, making it suitable for environments where different projects require different runtimes.

1. Download and run the NVM installer:

$ curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.1/install.sh | bash

2. Reload the shell environment:

$ source ~/.bashrc

3. Install the latest LTS release:

$ nvm install --lts

4. Install a specific version:

$ nvm install 24

5. Switch to that version:

$ nvm use 24

6. Set it as the default:

$ nvm alias default 24

7. Verify the active version:

$ node -v

Test the Installation

A minimal Express application confirms Node.js and npm are installed and working correctly.

1. Create a project directory:

$ mkdir ~/example-app && cd ~/example-app

2. Initialize the project:

$ npm init -y

3. Install Express:

$ npm install express

4. Create the application file:

$ nano index.js

Add the following:

const express = require('express')
const app = express()
const port = 3000

app.get('/', (req, res) => {
    res.send('Hello World from Node.js')
})

app.listen(port, () => {
    console.log(`Application listening on port ${port}`)
})

5. Open port 3000 in the firewall:

$ sudo ufw allow 3000/tcp

6. Start the application:

$ node index.js

7. Test in a second terminal:

$ curl http://localhost:3000

The response Hello World from Node.js confirms the server is running correctly.

Next Steps

Node.js and npm are now installed and serving requests. From here you can:

Deploy your application with PM2 for process management and automatic restarts on failure
Configure Nginx as a reverse proxy to serve the application on port 80
Use nvm ls-remote to browse all available Node.js releases

For the complete guide, visit the original article on Vultr Docs.

Installing MySQL on Ubuntu 26.04

Sanskriti Harmukh — Fri, 08 May 2026 15:56:38 +0000

Ubuntu 26.04 includes MySQL 8.4 in its default APT repository with no third-party sources required. This guide covers installation, service configuration, security hardening with mysql_secure_installation, and creating a database with a scoped user ready for application use.

Install MySQL

MySQL 8.4 is available directly from Ubuntu 26.04's default APT repository.

1. Update the APT package index:

$ sudo apt update

2. Install the MySQL server package:

$ sudo apt install mysql-server -y

3. Verify the installed version:

$ mysql --version

Manage the MySQL Service

Enable MySQL as a systemd service so it starts automatically on every boot.

1. Enable and start the service:

$ sudo systemctl enable mysql
$ sudo systemctl start mysql

2. Check the service status:

$ sudo systemctl status mysql

3. Stop or restart the service when needed:

$ sudo systemctl stop mysql
$ sudo systemctl restart mysql

Secure MySQL

The mysql_secure_installation script removes default configuration risks including anonymous users, remote root login, and the test database.

1. Run the security script:

$ sudo mysql_secure_installation

2. Open the MySQL configuration file:

$ sudo nano /etc/mysql/mysql.conf.d/mysqld.cnf

Add the following line under [mysqld]:

mysql_native_password=ON

3. Restart MySQL to apply the change:

$ sudo systemctl restart mysql

4. Set the root password in the MySQL shell:

$ sudo mysql

mysql> ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY 'your_strong_password';
mysql> FLUSH PRIVILEGES;
mysql> EXIT;

Create a Database and User

$ mysql -u root -p

mysql> CREATE DATABASE myapp_db;
mysql> CREATE USER 'myapp_user'@'localhost' IDENTIFIED BY 'user_password';
mysql> GRANT ALL PRIVILEGES ON myapp_db.* TO 'myapp_user'@'localhost';
mysql> FLUSH PRIVILEGES;
mysql> EXIT;

Create a Sample Table

$ mysql -u myapp_user -p myapp_db

mysql> CREATE TABLE services (
    id INT AUTO_INCREMENT PRIMARY KEY,
    name VARCHAR(100),
    status VARCHAR(50)
);
mysql> INSERT INTO services (name, status) VALUES
    ('web', 'active'),
    ('db', 'active'),
    ('cache', 'idle');
mysql> SELECT * FROM services;
mysql> EXIT;

All three rows in the query output confirm the database, user, and table are working correctly.

Next Steps

MySQL is now installed and accepting connections. From here you can:

Integrate MySQL with an Apache and PHP stack to serve dynamic web applications
Configure replication for read scaling and high availability
Automate backups with mysqldump or Percona XtraBackup

For the full guide with additional tips, visit the original article on Vultr Docs.

Installing MariaDB on Ubuntu 26.04

Sanskriti Harmukh — Fri, 08 May 2026 15:56:23 +0000

MariaDB is a drop-in replacement for MySQL that remains fully open source under the GPL license, available directly from Ubuntu 26.04's default APT repository with no external sources required. This guide covers installation, service configuration, security hardening with mariadb-secure-installation, and basic database operations to confirm a working setup.

Install MariaDB

MariaDB is available directly in Ubuntu 26.04's default APT repository.

1. Update the APT package index:

$ sudo apt update

2. Install the MariaDB server package:

$ sudo apt install mariadb-server -y

3. Verify the installed version:

$ mariadb --version

Manage the MariaDB Service

Enable MariaDB as a systemd service so it starts automatically on every boot.

1. Enable and start the service:

$ sudo systemctl enable mariadb
$ sudo systemctl start mariadb

2. Check the service status:

$ sudo systemctl status mariadb

3. Stop or restart the service when needed:

$ sudo systemctl stop mariadb
$ sudo systemctl restart mariadb

Secure MariaDB

The mariadb-secure-installation script removes default configuration risks including anonymous users, remote root login, and the test database.

$ sudo mariadb-secure-installation

Restart MariaDB to apply the changes:

$ sudo systemctl restart mariadb

Create a Database and User

$ sudo mariadb -u root -p

MariaDB [(none)]> CREATE DATABASE myapp_db;
MariaDB [(none)]> CREATE USER 'myapp_user'@'localhost' IDENTIFIED BY 'secure_password';
MariaDB [(none)]> GRANT ALL PRIVILEGES ON myapp_db.* TO 'myapp_user'@'localhost';
MariaDB [(none)]> FLUSH PRIVILEGES;
MariaDB [(none)]> EXIT;

Create a Sample Table

$ mariadb -u myapp_user -p myapp_db

MariaDB [myapp_db]> CREATE TABLE employees (
    id INT AUTO_INCREMENT PRIMARY KEY,
    name VARCHAR(100) NOT NULL,
    role VARCHAR(100),
    department VARCHAR(100)
);
MariaDB [myapp_db]> MariaDB [myapp_db]> INSERT INTO employees (name, role, department) VALUES
    ('Alice', 'Engineer', 'Backend'),
    ('Bob', 'Designer', 'Frontend'),
    ('Carol', 'DevOps', 'Infrastructure');
MariaDB [myapp_db]> SELECT * FROM employees;
MariaDB [myapp_db]> EXIT;

All three rows in the query output confirm the database, user, and table are working correctly.

Next Steps

MariaDB is now installed and accepting connections. From here you can:

Use MariaDB as the database layer in a LAMP or LEMP stack
Set up Galera Cluster for multi-master replication
Automate backups with mariadb-dump

For the full guide with additional tips, visit the original article on Vultr Docs.

Installing the LAMP Stack on Ubuntu 26.04

Sanskriti Harmukh — Fri, 08 May 2026 15:56:02 +0000

The LAMP stack — Linux, Apache, MySQL, and PHP — powers a large portion of the web, including WordPress, Laravel, and Drupal. Ubuntu 26.04 ships with PHP 8.5, giving you a modern base to build on. This guide sets up a production-ready stack using Apache with PHP-FPM, secures it with a Let's Encrypt certificate, and verifies the full setup with a PHP page that reads from MySQL. By the end, you'll have a fully operational LAMP server ready to host web applications.

Install Apache

Apache is available directly from Ubuntu 26.04's default APT repository.

1. Update the APT package index:

$ sudo apt update

2. Install Apache:

$ sudo apt install apache2 -y

3. Enable and start the service:

$ sudo systemctl enable apache2
$ sudo systemctl start apache2

Install MySQL

MySQL is installed from Ubuntu's default repository and secured with the built-in security script before any application connects to it.

1. Install the MySQL server package:

$ sudo apt install mysql-server -y

2. Enable and start the service:

$ sudo systemctl enable mysql
$ sudo systemctl start mysql

3. Run the security script:

$ sudo mysql_secure_installation

4. Set the root password in the MySQL shell:

$ sudo mysql

mysql> ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY 'your_strong_password';
mysql> FLUSH PRIVILEGES;
mysql> EXIT;

Install PHP and PHP-FPM

PHP-FPM handles PHP execution through a FastCGI process pool, offering better performance and process isolation compared to the traditional mod_php approach.

1. Install PHP and required extensions:

$ sudo apt install php php-fpm php-mysql php-cli libapache2-mod-php -y

2. Enable and start PHP-FPM:

$ sudo systemctl enable php8.5-fpm
$ sudo systemctl start php8.5-fpm

Configure Firewall Rules

Open ports 80 and 443 to allow HTTP and HTTPS traffic through the firewall.

$ sudo ufw allow 80/tcp
$ sudo ufw allow 443/tcp

Configure a Virtual Host

Virtual hosts allow Apache to serve domain-specific content and are required before issuing an SSL certificate. Replace app.example.com with your actual domain throughout this section.

1. Create the web root directory:

$ sudo mkdir -p /var/www/app.example.com
$ sudo chown -R www-data:www-data /var/www/app.example.com

2. Create a test HTML page:

$ echo "<h1>Hello from LAMP on Ubuntu 26.04</h1>" | sudo tee /var/www/app.example.com/index.html

3. Disable the default Apache site:

$ sudo a2dissite 000-default.conf

4. Create the virtual host configuration:

$ sudo nano /etc/apache2/sites-available/app.example.com.conf

<VirtualHost *:80>
    ServerName app.example.com
    DocumentRoot /var/www/app.example.com

    <Directory /var/www/app.example.com>
        AllowOverride All
        Require all granted
    </Directory>

    ErrorLog ${APACHE_LOG_DIR}/app.example.com-error.log
    CustomLog ${APACHE_LOG_DIR}/app.example.com-access.log combined
</VirtualHost>

5. Enable the site and reload Apache:

$ sudo a2ensite app.example.com.conf
$ sudo apachectl configtest
$ sudo systemctl restart apache2

Secure with Let's Encrypt SSL

Certbot automates certificate issuance and renewal through Let's Encrypt, with an Apache plugin that handles virtual host configuration directly.

1. Install Certbot with the Apache plugin:

$ sudo apt install certbot python3-certbot-apache -y

2. Generate and install the certificate:

$ sudo certbot --apache -d app.example.com --agree-tos

Certbot updates the virtual host to redirect HTTP to HTTPS automatically.

3. Test the auto-renewal timer:

$ sudo certbot renew --dry-run

A dry run without errors confirms automatic renewal is configured correctly.

Test the LAMP Stack

A PHP script that connects to MySQL and retrieves data confirms all three layers of the stack are communicating correctly.

1. Create the test database:

$ mysql -u root -p

mysql> CREATE DATABASE lamp_test;
mysql> CREATE USER 'lamp_user'@'localhost' IDENTIFIED BY 'secure_password';
mysql> GRANT ALL PRIVILEGES ON lamp_test.* TO 'lamp_user'@'localhost';
mysql> USE lamp_test;
mysql> CREATE TABLE greetings (id INT AUTO_INCREMENT PRIMARY KEY, message VARCHAR(255));
mysql> INSERT INTO greetings (message) VALUES ('LAMP stack is working!');
mysql> FLUSH PRIVILEGES;
mysql> EXIT;

2. Create the PHP test page:

$ sudo nano /var/www/app.example.com/test.php

<?php
$conn = new mysqli('localhost', 'lamp_user', 'secure_password', 'lamp_test');
if ($conn->connect_error) { die('Connection failed: ' . $conn->connect_error); }
$result = $conn->query('SELECT message FROM greetings');
while ($row = $result->fetch_assoc()) { echo $row['message']; }
$conn->close();
?>

3. Visit the test page:

Open https://app.example.com/test.php in a browser. The text LAMP stack is working! confirms Apache, PHP, and MySQL are communicating correctly.

4. Remove the test file:

$ sudo rm /var/www/app.example.com/test.php

Next Steps

The LAMP stack is now running and serving requests over HTTPS. From here you can:

Deploy WordPress or Laravel on this stack
Add phpMyAdmin for a browser-based database management interface
Enable mod_rewrite for clean URL support with sudo a2enmod rewrite

For the full guide with additional tips, visit the original article on Vultr Docs.

Installing Docker Engine on Ubuntu 26.04

Sanskriti Harmukh — Fri, 08 May 2026 15:55:41 +0000

Running containers on a fresh Ubuntu 26.04 server? The default repositories do not ship a production-ready version of Docker. This guide installs Docker Engine directly from the official Docker repository, with Compose and Buildx included. By the end, you'll have Docker running as a system service with a live Nginx container confirming the install.

Install Docker

The official Docker repository gives you the most current Docker Engine builds. Follow these steps to add the GPG key and repo, then install.

1. Install dependency packages:

$ sudo apt install apt-transport-https ca-certificates curl -y

2. Add Docker's GPG key:

$ sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc

3. Register the Docker repository:

$ echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/ubuntu $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

4. Refresh APT:

$ sudo apt update

5. Install Docker Engine and plugins:

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

What you just installed:

docker-ce: Docker Engine (community edition)
docker-ce-cli: CLI client
containerd.io: container runtime
docker-buildx-plugin: multi-platform image builds
docker-compose-plugin: multi-container orchestration via YAML

6. Verify the install:

$ docker --version

Configure Docker as a System Service

Enable Docker to start automatically when the server boots.

1. Enable and start the service:

$ sudo systemctl enable docker
$ sudo systemctl start docker

2. Check the service status:

$ sudo systemctl status docker

3. Stop or restart the service when needed:

$ sudo systemctl stop docker
$ sudo systemctl restart docker

Add Your User to the Docker Group

Adding your user to the docker group allows you to run Docker commands without sudo.

$ sudo usermod -aG docker $USER
$ newgrp docker

Verify the group change took effect:

$ docker ps

If you see a permission denied error, log out and back in to apply the group change.

Run a Containerized Application

Pull the official Nginx image and run it as a container to verify the installation.

1. Pull the image:

$ docker pull nginx:latest

2. Run the container:

$ docker run --name example-nginx -d -p 80:80 nginx:latest

Flags:

--name example-nginx: human-readable container name
-d: run detached (background)
-p 80:80: map host port 80 to container port 80

3. Verify the container is running:

$ docker ps

4. Open the firewall:

$ sudo ufw allow 80/tcp

Open http://YOUR-SERVER-IP in a browser. The Nginx welcome page confirms the container is running.

Next Steps

Docker is now installed and running. From here you can:

Build custom images with a Dockerfile
Orchestrate multi-container apps with docker compose
Push images to Docker Hub or a private registry

For the full guide with additional tips, visit the original article on Vultr Docs.

Installing Apache Web Server on Ubuntu 26.04

Sanskriti Harmukh — Fri, 08 May 2026 15:55:31 +0000

Apache is one of the most widely deployed web servers, with native support in Ubuntu 26.04's default APT repository requiring no external sources. This guide covers the full setup from installation to production readiness, including virtual host configuration for domain-based routing and SSL termination with a free Let's Encrypt certificate backed by automatic renewal.

Install Apache

Apache is available directly from Ubuntu 26.04's default APT repository.

1. Update the APT package index:

$ sudo apt update

2. Install Apache:

$ sudo apt install apache2 -y

3. Verify the installed version:

$ apachectl -v

Manage the Apache Service

Enable Apache as a systemd service so it starts automatically on every boot.

1. Enable and start the service:

$ sudo systemctl enable apache2
$ sudo systemctl start apache2

2. Check the service status:

$ sudo systemctl status apache2

3. Stop or restart the service when needed:

$ sudo systemctl stop apache2
$ sudo systemctl restart apache2

Configure Firewall Rules

Open ports 80 and 443 to allow HTTP and HTTPS traffic through the firewall.

$ sudo ufw allow 80/tcp
$ sudo ufw allow 443/tcp

Open http://YOUR-SERVER-IP in a browser. The Apache default page confirms the service is running.

Create a Virtual Host

Virtual hosts allow Apache to serve multiple domains from the same server. Replace app.example.com with your actual domain throughout this section.

1. Create the web root directory:

$ sudo mkdir -p /var/www/app.example.com
$ sudo chown -R www-data:www-data /var/www/app.example.com

2. Create a sample HTML page:

$ sudo nano /var/www/app.example.com/index.html

<!DOCTYPE html>
<html>
<head><title>My App</title></head>
<body><h1>Hello World from Apache on Ubuntu 26.04</h1></body>
</html>

3. Disable the default site:

$ sudo a2dissite 000-default.conf

4. Create the virtual host configuration:

$ sudo nano /etc/apache2/sites-available/app.example.com.conf

<VirtualHost *:80>
    ServerName app.example.com
    DocumentRoot /var/www/app.example.com
    <Directory /var/www/app.example.com>
        AllowOverride All
        Require all granted
    </Directory>
    ErrorLog ${APACHE_LOG_DIR}/app.example.com-error.log
    CustomLog ${APACHE_LOG_DIR}/app.example.com-access.log combined
</VirtualHost>

5. Enable the site, test the configuration, and reload:

$ sudo a2ensite app.example.com.conf
$ sudo apachectl configtest
$ sudo systemctl restart apache2

Verify the virtual host is serving correctly:

$ curl http://app.example.com

Secure with Let's Encrypt SSL

Certbot automates certificate issuance and renewal through Let's Encrypt, with an Apache plugin that handles virtual host configuration directly.

1. Install Certbot with the Apache plugin:

$ sudo apt install certbot python3-certbot-apache -y

2. Generate and install the certificate:

$ sudo certbot --apache -d app.example.com --agree-tos

Certbot obtains the certificate, updates the virtual host to enable HTTPS, and configures an HTTP-to-HTTPS redirect automatically.

3. Test the auto-renewal timer:

$ sudo certbot renew --dry-run

A dry run without errors confirms automatic renewal is configured correctly.

Next Steps

Apache is now running and serving your domain over HTTPS. From here you can:

Add PHP via PHP-FPM to serve dynamic content alongside Apache
Configure Apache as a reverse proxy in front of a Node.js or Python application
Enable HTTP/2 support with sudo a2enmod http2

For the complete guide, visit the original article on Vultr Docs.

Adding Swap Memory on Ubuntu 26.04

Sanskriti Harmukh — Fri, 08 May 2026 15:54:54 +0000

Servers with limited RAM are vulnerable to out-of-memory kills during traffic spikes or memory-intensive workloads. Swap provides an overflow area on disk, giving the kernel room to move inactive memory pages before resorting to terminating processes. This guide configures a 2 GB swap file on Ubuntu 26.04, mounts it persistently via /etc/fstab, and sets the swappiness value to a level appropriate for server workloads.

Check Current Swap

Verify memory and swap status before making any changes:

$ free -h

A Swap: 0B line confirms no swap is currently configured.

Create a Swap File

Allocate a 2 GB file, set the correct permissions, and format it as swap:

1. Create a 2 GB file:

$ sudo fallocate -l 2G /swapfile

2. Restrict file permissions:

$ sudo chmod 600 /swapfile

The chmod 600 restricts access to root only. Swap files with world-readable permissions will be rejected by the kernel.

3. Format the file as swap:

$ sudo mkswap /swapfile

Enable Swap

Activate the swap file and confirm it is recognized by the system:

1. Activate the swap file:

$ sudo swapon /swapfile

2. Verify swap is active:

$ sudo swapon --show

3. Confirm the allocation:

$ free -h

The Swap line should now show 2.0Gi total.

Configure Automatic Mounting at Boot

Swap activated with swapon does not persist across reboots without an /etc/fstab entry.

1. Back up the fstab file:

$ sudo cp /etc/fstab /etc/fstab.bak

2. Add the swap entry:

$ echo '/swapfile swap swap defaults 0 0' | sudo tee -a /etc/fstab

3. Verify the entry was written correctly:

$ grep swap /etc/fstab

Tune Swappiness

Swappiness controls how aggressively the kernel moves memory pages to swap. The value ranges from 0 to 100.

0 — only swap when RAM is critically full
10 — recommended for servers (keeps more data in RAM)
60 — Ubuntu default (more aggressive)
100 — swap as aggressively as possible

1. Check the current value:

$ cat /proc/sys/vm/swappiness

2. Set the swappiness value:

$ sudo nano /etc/sysctl.conf

Add the following line:

vm.swappiness=10

3. Apply the change immediately:

$ sudo sysctl -p

Next Steps

Swap is now active and persists across reboots. From here you can:

Monitor swap usage in real time with vmstat 1 during peak load periods
Increase swap size by repeating these steps with a larger fallocate value
Explore zswap or zram for in-memory compression as an alternative to disk-backed swap

For the complete guide, visit the original article on Vultr Docs.