DEV Community: Aashish Chaurasiya

Installing RabbitMQ on Ubuntu 26.04

Aashish Chaurasiya — Wed, 13 May 2026 21:43:42 +0000

RabbitMQ is an open-source message broker that enables distributed applications to communicate through message queues, decoupling producers and consumers across services. This guide installs RabbitMQ on Ubuntu 26.04, enables the management plugin, creates an admin user, and secures the web dashboard with Nginx and a Let's Encrypt certificate. By the end, you'll have RabbitMQ running with a secure management interface accessible over HTTPS.

Install RabbitMQ

RabbitMQ is available in Ubuntu 26.04's default APT repository.

1. Update the APT package index:

$ sudo apt update

2. Install Erlang and RabbitMQ:

$ sudo apt install gnupg erlang rabbitmq-server -y

What you just installed:

erlang: the runtime RabbitMQ is built on
rabbitmq-server: the message broker daemon

3. Verify the installed version:

$ rabbitmq-diagnostics --version

Manage the RabbitMQ Service

Enable RabbitMQ to start automatically when the server boots.

1. Enable and start the service:

$ sudo systemctl enable rabbitmq-server
$ sudo systemctl start rabbitmq-server

2. Check the service status:

$ sudo systemctl status rabbitmq-server

3. Stop or restart the service when needed:

$ sudo systemctl stop rabbitmq-server
$ sudo systemctl restart rabbitmq-server

Configure RabbitMQ

1. Enable the management plugin:

$ sudo rabbitmq-plugins enable rabbitmq_management

2. Create an admin user:

$ sudo rabbitmqctl add_user example_admin strong_password

3. Grant the user administrator permissions:

$ sudo rabbitmqctl set_user_tags example_admin administrator

4. Set resource permissions for the default virtual host:

$ sudo rabbitmqctl set_permissions -p / example_admin ".*" ".*" ".*"

The three permission patterns grant configure, write, and read access on all resources in the / virtual host.

Configure Firewall Rules

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

Configure Nginx as a Reverse Proxy

The RabbitMQ management interface listens on port 15672. Proxy it through Nginx on port 80.

1. Install Nginx:

$ sudo apt install nginx -y

2. Enable and start Nginx:

$ sudo systemctl enable nginx
$ sudo systemctl start nginx

3. Create the reverse proxy configuration:

$ sudo nano /etc/nginx/sites-available/rabbitmq.example.com.conf

server {
    listen 80;
    server_name rabbitmq.example.com;

    location / {
        proxy_pass http://localhost:15672;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    }
}

4. Enable the site and reload Nginx:

$ sudo ln -s /etc/nginx/sites-available/rabbitmq.example.com.conf /etc/nginx/sites-enabled/
$ sudo nginx -t
$ sudo systemctl reload nginx

Secure with Let's Encrypt SSL

1. Install Certbot with the Nginx plugin:

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

2. Generate and install the certificate:

$ sudo certbot --nginx -d rabbitmq.example.com --agree-tos

Certbot updates the Nginx configuration to redirect HTTP to HTTPS automatically.

3. Test the auto-renewal timer:

$ sudo certbot renew --dry-run

Access the Dashboard

Open https://rabbitmq.example.com in a browser and log in with the admin credentials you created. The management interface shows queues, exchanges, connections, and message rates.

Next Steps

RabbitMQ is now running with a secured management interface. From here you can:

Create queues and exchanges through the management dashboard or API
Integrate RabbitMQ with a Python application using the pika library
Set up clustering with additional RabbitMQ nodes for high availability

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

Upgrading Ubuntu 24.04 to Ubuntu 26.04

Aashish Chaurasiya — Wed, 13 May 2026 21:43:40 +0000

Ubuntu 24.04 LTS remains fully supported, but Ubuntu 26.04 LTS ships the Linux 7.0 kernel and updated security defaults. This guide upgrades a live Ubuntu 24.04 server to Ubuntu 26.04 LTS in-place using do-release-upgrade, handling the auxiliary SSH daemon, configuration file conflicts, and obsolete package removal. By the end, you'll have a running Ubuntu 26.04 system with the kernel version confirmed.

Prepare for the Upgrade

1. Update the APT package index and upgrade all installed packages:

$ sudo apt update
$ sudo apt upgrade -y

2. Remove obsolete packages:

$ sudo apt autoremove -y

3. Install the upgrade manager:

$ sudo apt install update-manager-core -y

Open the Auxiliary SSH Port

The do-release-upgrade tool starts an auxiliary SSH daemon on port 1022. Opening this port prevents being locked out if the primary SSH connection drops during the upgrade.

$ sudo ufw allow 1022/tcp

Run the Upgrade

1. Launch the release upgrade tool:

$ sudo do-release-upgrade -d

2. Follow the interactive prompts:

Confirm the upgrade to Ubuntu 26.04 LTS when prompted
Allow the auxiliary SSH daemon to start on port 1022
Accept any keyboard configuration dialogs
When asked about configuration files, keep the local version
Confirm removal of obsolete packages when prompted
Reboot the server to complete the upgrade

Verify the Upgrade

1. Confirm the OS version:

$ cat /etc/os-release

The output shows VERSION_ID="26.04" and VERSION_CODENAME="resolute".

2. Verify the kernel version:

$ uname -r

The output shows kernel 7.0.0 or higher.

3. Remove the auxiliary SSH firewall rule:

$ sudo ufw delete allow 1022/tcp

Next Steps

Ubuntu 26.04 is running with the latest kernel. From here you can:

Review and update any third-party APT repositories that reference the noble codename
Install the LAMP or LEMP stack to start hosting web applications
Harden the server with fail2ban and automatic security updates

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

Installing the LEMP Stack on Ubuntu 26.04

Aashish Chaurasiya — Wed, 13 May 2026 21:43:38 +0000

The LEMP stack — Linux, Nginx, MySQL, and PHP — powers dynamic web applications with Nginx's high-concurrency architecture at the front and PHP-FPM's FastCGI process pool handling PHP execution. Ubuntu 26.04 ships with PHP 8.5, giving you a modern base to build on. This guide sets up a production-ready LEMP stack, 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 LEMP server ready to host web applications.

Install Nginx

1. Update the APT package index:

$ sudo apt update

2. Install Nginx:

$ sudo apt install nginx -y

3. Enable and start the service:

$ sudo systemctl enable nginx
$ sudo systemctl start nginx

Install MySQL

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

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

Install PHP and PHP-FPM

PHP-FPM handles PHP execution through a FastCGI process pool, offering better isolation and performance than mod_php.

1. Install PHP and required extensions:

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

What you just installed:

php: core PHP interpreter
php-fpm: FastCGI Process Manager for Nginx
php-mysql: MySQL driver for PHP database connections
php-cli: command-line PHP interpreter

2. Enable and start PHP-FPM:

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

3. Verify the installed version:

$ php --version

Configure Firewall Rules

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

Configure a Virtual Host

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 LEMP on Ubuntu 26.04</h1>" | sudo tee /var/www/app.example.com/index.html

3. Create the virtual host configuration:

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

server {
    listen 80;
    server_name app.example.com;
    root /var/www/app.example.com;
    index index.php index.html;

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

    location ~ \.php$ {
        include snippets/fastcgi-php.conf;
        fastcgi_pass unix:/run/php/php8.5-fpm.sock;
    }

    access_log /var/log/nginx/app.example.com-access.log;
    error_log /var/log/nginx/app.example.com-error.log;
}

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

$ sudo ln -s /etc/nginx/sites-available/app.example.com.conf /etc/nginx/sites-enabled/
$ sudo nginx -t
$ sudo systemctl reload nginx

Secure with Let's Encrypt SSL

1. Install Certbot with the Nginx plugin:

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

2. Generate and install the certificate:

$ sudo certbot --nginx -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

Test the LEMP Stack

1. Create the test database:

$ mysql -u root -p

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

2. Create the PHP test page:

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

<?php
$conn = new mysqli('localhost', 'lemp_user', 'secure_password', 'lemp_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 LEMP stack is working! confirms Nginx, PHP, and MySQL are communicating correctly.

4. Remove the test file:

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

Next Steps

The LEMP 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 HTTP/2 in Nginx by adding http2 to the listen directive

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

Installing Nginx Web Server on Ubuntu 26.04

Aashish Chaurasiya — Wed, 13 May 2026 21:43:36 +0000

Nginx is a high-performance web server built for concurrency, powering content delivery, reverse proxying, and load balancing at scale. This guide goes beyond a basic install: it configures a virtual host for your domain and secures it with a free Let's Encrypt SSL certificate. By the end, you'll have Nginx serving your domain over HTTPS with automatic certificate renewal in place.

Install Nginx

Nginx is available in Ubuntu 26.04's default APT repository.

1. Update the APT package index:

$ sudo apt update

2. Install Nginx:

$ sudo apt install nginx -y

3. Verify the installed version:

$ nginx -version

Configure Nginx as a System Service

Enable Nginx to start automatically when the server boots.

1. Enable and start the service:

$ sudo systemctl enable nginx
$ sudo systemctl start nginx

2. Check the service status:

$ sudo systemctl status nginx

3. Stop or restart the service when needed:

$ sudo systemctl stop nginx
$ sudo systemctl restart nginx

Configure Firewall Rules

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

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

Create a Virtual Host

Virtual hosts let Nginx serve different sites from the same server.

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 Nginx on Ubuntu 26.04</h1></body>
</html>

3. Create the virtual host configuration:

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

server {
    listen 80;
    server_name app.example.com;
    root /var/www/app.example.com;
    index index.html;

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

    access_log /var/log/nginx/app.example.com-access.log;
    error_log /var/log/nginx/app.example.com-error.log;
}

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

$ sudo ln -s /etc/nginx/sites-available/app.example.com.conf /etc/nginx/sites-enabled/
$ sudo nginx -t
$ sudo systemctl reload nginx

Verify the virtual host is serving:

$ curl http://app.example.com

Secure with Let's Encrypt SSL

1. Install Certbot with the Nginx plugin:

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

2. Generate and install the certificate:

$ sudo certbot --nginx -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

If the dry run completes without errors, automatic renewal is configured correctly.

Next Steps

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

Add PHP via PHP-FPM to serve dynamic content alongside Nginx
Configure Nginx as a reverse proxy in front of a Node.js or Python application
Enable HTTP/2 support by adding http2 to the listen directive

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

Installing PHP and PHP-FPM on Ubuntu 26.04

Aashish Chaurasiya — Wed, 13 May 2026 21:43:34 +0000

Ubuntu 26.04 ships PHP 8.5 in its default APT repository, and PHP-FPM handles PHP execution through a FastCGI process pool that scales independently of the web server. This guide installs PHP 8.5 with common extensions, configures PHP-FPM, and integrates it with Nginx so PHP requests are processed efficiently. By the end, you'll have PHP and PHP-FPM running with Nginx serving a verified PHP page.

Install PHP

PHP 8.5 is available in Ubuntu 26.04's default APT repository.

1. Update the APT package index:

$ sudo apt update

2. Install PHP:

$ sudo apt install php -y

3. Verify the installed version:

$ php --version

Install PHP Extensions

Extensions add capabilities like database connectivity, image processing, and archive handling.

1. Install common PHP extensions:

$ sudo apt install php-mysql php-mbstring php-bcmath php-zip php-gd php-curl php-xml -y

What you just installed:

php-mysql: MySQL and MariaDB database connectivity
php-mbstring: multi-byte character encoding support
php-bcmath: arbitrary precision mathematics
php-zip: ZIP archive handling
php-gd: image creation and manipulation
php-curl: HTTP client functionality
php-xml: XML parsing and formatting

2. Verify extensions are loaded:

$ php -m

Install PHP-FPM

PHP-FPM manages a pool of FastCGI worker processes that handle incoming PHP requests from the web server.

1. Install PHP-FPM:

$ sudo apt install php-fpm -y

2. Enable and start the service:

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

3. Check the service status:

$ sudo systemctl status php8.5-fpm

4. Verify the socket exists:

$ ls /run/php/php8.5-fpm.sock

Integrate with Nginx

1. Install Nginx:

$ sudo apt install nginx -y

2. 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

3. Create the virtual host configuration:

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

server {
    listen 80;
    server_name app.example.com;
    root /var/www/app.example.com;
    index index.php index.html;

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

    location ~ \.php$ {
        include snippets/fastcgi-php.conf;
        fastcgi_pass unix:/run/php/php8.5-fpm.sock;
    }
}

4. Enable the site and reload Nginx:

$ sudo ln -s /etc/nginx/sites-available/app.example.com.conf /etc/nginx/sites-enabled/
$ sudo nginx -t
$ sudo systemctl reload nginx

Verify the Installation

1. Create a PHP info page:

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

<?php phpinfo(); ?>

2. Open the page in a browser:

Visit http://app.example.com/info.php. The PHP info page confirms PHP 8.5 is running through PHP-FPM.

3. Remove the info page:

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

Next Steps

PHP and PHP-FPM are now installed and integrated with Nginx. From here you can:

Configure PHP-FPM pool settings in /etc/php/8.5/fpm/pool.d/www.conf to tune concurrency
Install Laravel or WordPress on the stack
Add Composer for PHP package management

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

Installing Podman on Ubuntu 26.04

Aashish Chaurasiya — Wed, 13 May 2026 21:43:33 +0000

Podman is a daemonless container engine compatible with Docker's CLI and OCI container formats. Unlike Docker, Podman runs without a background daemon — each container is its own process, with no single point of failure. This guide installs Podman on Ubuntu 26.04, deploys a live Nginx container, and builds a custom image from a Dockerfile. By the end, you'll have Podman running containers and a custom application image ready for use.

Install Podman

Podman is available in Ubuntu 26.04's default APT repository.

1. Update the APT package index:

$ sudo apt update

2. Install Podman:

$ sudo apt install podman -y

3. Verify the installed version:

$ podman --version

Manage the Podman Service

Enable the Podman socket for API access and compatibility with Docker-based tooling.

1. Enable and start the socket:

$ sudo systemctl enable podman.socket
$ sudo systemctl start podman.socket

2. Check the socket status:

$ sudo systemctl status podman.socket

3. Stop or restart the socket when needed:

$ sudo systemctl stop podman.socket
$ sudo systemctl restart podman.socket

Run a Containerized Application

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

1. Pull the Nginx image:

$ sudo podman pull docker.io/nginx:alpine

2. Run the container:

$ sudo podman run -d --name example-nginx -p 9090:80 docker.io/nginx:alpine

Flags:

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

3. Verify the container is running:

$ sudo podman ps

4. Test the container response:

$ curl http://localhost:9090

The Nginx welcome page in the output confirms the container is running.

Build a Custom Image

1. Create a project directory:

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

2. Create a Dockerfile:

$ nano Dockerfile

FROM python:3.12-slim
WORKDIR /app
RUN pip install fastapi uvicorn
COPY . .
CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "5000"]

3. Create a simple application file:

$ nano app.py

from fastapi import FastAPI
app = FastAPI()

@app.get("/")
def read_root():
    return {"message": "Hello from Podman on Ubuntu 26.04"}

4. Build the image:

$ sudo podman build -t example-fastapi-app .

5. Run the custom image:

$ sudo podman run -d --name example-app -p 5000:5000 example-fastapi-app

6. Test the application:

$ curl http://localhost:5000

Next Steps

Podman is now running and serving containers. From here you can:

Use podman compose for multi-container orchestration with Docker Compose files
Push images to Docker Hub or a private registry with podman push
Configure rootless Podman to run containers without sudo

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

Installing PostgreSQL on Ubuntu 26.04

Aashish Chaurasiya — Wed, 13 May 2026 21:43:31 +0000

PostgreSQL is a powerful open-source relational database known for extensibility, standards compliance, and support for advanced data types including JSON and arrays. The PostgreSQL Global Development Group maintains a dedicated APT repository with the latest releases. This guide installs PostgreSQL from the PGDG repository, secures the installation, and creates a database with a dedicated user. By the end, you'll have a hardened PostgreSQL instance with a working database ready for application use.

Install PostgreSQL

The PostgreSQL Global Development Group provides an official APT repository with the latest PostgreSQL releases.

1. Update the APT package index:

$ sudo apt update

2. Install the PostgreSQL common package:

$ sudo apt install postgresql-common -y

3. Run the repository setup script:

$ sudo /usr/share/postgresql-common/pgdg/apt.postgresql.org.sh

4. Install PostgreSQL:

$ sudo apt install postgresql -y

5. Verify the installed version:

$ psql --version

Manage the PostgreSQL Service

Enable PostgreSQL to start automatically when the server boots.

1. Enable and start the service:

$ sudo systemctl enable postgresql
$ sudo systemctl start postgresql

2. Check the service status:

$ sudo systemctl status postgresql

3. Stop or restart the service when needed:

$ sudo systemctl stop postgresql
$ sudo systemctl restart postgresql

Secure PostgreSQL

1. Log in as the postgres superuser:

$ sudo -u postgres psql

2. Set a password for the postgres account:

ALTER USER postgres WITH PASSWORD 'your_strong_password';

3. Create a new application user:

CREATE USER example_admin WITH PASSWORD 'secure_password';
\q

4. Update the authentication method in pg_hba.conf:

$ sudo nano /etc/postgresql/18/main/pg_hba.conf

Find the lines for local connections and change peer to scram-sha-256:

local   all             postgres                                scram-sha-256
local   all             all                                     scram-sha-256

5. Restart PostgreSQL to apply changes:

$ sudo systemctl restart postgresql

Create a Database and User

$ sudo -u postgres psql

CREATE DATABASE example_store OWNER example_admin;
GRANT ALL PRIVILEGES ON DATABASE example_store TO example_admin;
\q

Create a Sample Table

$ psql -U example_admin -d example_store -h localhost

CREATE TABLE products (
    product_id SERIAL PRIMARY KEY,
    product_name VARCHAR(100) NOT NULL,
    category VARCHAR(100),
    price NUMERIC(10, 2)
);

INSERT INTO products (product_name, category, price) VALUES
    ('Widget A', 'Hardware', 9.99),
    ('Widget B', 'Software', 29.99),
    ('Widget C', 'Services', 49.99);

SELECT * FROM products;
\q

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

Next Steps

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

Use PostgreSQL as the database layer in a web application with Django or Rails
Set up streaming replication for high availability
Automate backups with pg_dump and a cron job

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

Deploying OpenClaw on Ubuntu 26.04

Aashish Chaurasiya — Wed, 13 May 2026 21:43:29 +0000

OpenClaw is a self-hosted autonomous AI agent platform that connects to WhatsApp, Telegram, Slack, and Discord through a unified Gateway control plane. It maintains persistent memory across sessions and supports tool execution with any OpenAI-compatible model provider, including Vultr Serverless Inference. This guide deploys OpenClaw using the interactive setup wizard and exposes the control UI securely over HTTPS with Caddy. By the end, you'll have OpenClaw running with a live gateway and the control interface accessible at your domain.

Install Docker

The official Docker repository gives you the most current Docker Engine builds.

1. Install dependency packages:

$ sudo apt install apt-transport-https ca-certificates curl git -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 and install Docker:

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

5. Add your user to the Docker group:

$ sudo usermod -aG docker $USER
$ newgrp docker

Set Up OpenClaw

1. Create the project directory:

$ mkdir -p ~/openclaw-assistant
$ cd ~/openclaw-assistant

2. Clone the OpenClaw repository:

$ git clone https://github.com/openclaw/openclaw.git
$ cd openclaw

3. Run the interactive setup wizard:

$ ./docker-setup.sh

The wizard guides you through:

Model provider selection (Anthropic, OpenAI, Google, or Vultr Serverless Inference)
Channel configuration (Slack, Discord, Telegram, or WhatsApp)
Channel allowlists and skill setup
Gateway startup

4. Verify the gateway is running:

$ docker compose logs openclaw-gateway

A line containing [gateway] listening on ws://0.0.0.0:18789 confirms the gateway is active.

Access the Control UI

Option A: SSH Tunnel (development)

1. Allow insecure local auth in the configuration:

$ nano ~/.openclaw/openclaw.json

Find the gateway block and add:

"controlUi": {
    "allowInsecureAuth": true
}

2. Restart the gateway:

$ docker compose restart openclaw-gateway

3. Open an SSH tunnel from your local machine:

$ ssh -N -L 18789:127.0.0.1:18789 linuxuser@YOUR-SERVER-IP

Open http://localhost:18789/?token=YOUR-TOKEN in a browser.

Option B: HTTPS with Caddy (production)

1. Install Caddy:

$ curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/gpg.key' | sudo gpg --dearmor -o /usr/share/keyrings/caddy-stable-archive-keyring.gpg
$ curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/debian.deb.txt' | sudo tee /etc/apt/sources.list.d/caddy-stable.list
$ sudo apt update
$ sudo apt install caddy -y

2. Configure the Caddyfile:

$ sudo nano /etc/caddy/Caddyfile

openclaw.example.com {
    reverse_proxy localhost:18789
}

3. Open the firewall and reload Caddy:

$ sudo ufw allow 80/tcp
$ sudo ufw allow 443/tcp
$ sudo systemctl reload caddy

Open https://openclaw.example.com/?token=YOUR-TOKEN in a browser.

Configure Vultr Serverless Inference

To use Vultr's OpenAI-compatible inference endpoint as the model backend:

1. Edit the OpenClaw configuration:

$ nano ~/.openclaw/openclaw.json

Add the Vultr provider block under models.providers:

"vultr": {
    "baseUrl": "https://api.vultrinference.com/v1",
    "apiKey": "YOUR-VULTR-API-KEY",
    "api": "openai-completions",
    "models": [
        { "id": "moonshotai/Kimi-K2.5", "name": "Kimi-K2.5" }
    ]
}

2. Restart the gateway:

$ docker compose restart openclaw-gateway

3. Select the model from a connected channel:

/model vultr/moonshotai/Kimi-K2.5

Next Steps

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

Connect additional messaging channels through the control UI
Use /compact and /think commands to manage session memory
Back up persistent memory with tar -czvf openclaw-backup.tar.gz ~/.openclaw

If you prefer a one-click setup, OpenClaw is also available as a Vultr Marketplace app, no manual configuration required. See the Marketplace deployment guide for details.

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

Deploying Hermes Agent on Ubuntu 26.04

Aashish Chaurasiya — Wed, 13 May 2026 21:43:27 +0000

Hermes Agent is an open-source self-hosted AI agent framework by Nous Research that runs continuously on a server with persistent memory and tool access. It integrates with Telegram, Discord, Slack, and WhatsApp, and supports any OpenAI-compatible LLM provider including Vultr Serverless Inference. This guide deploys Hermes Agent using Docker Compose with Traefik handling automatic HTTPS, and configures an LLM backend. By the end, you'll have a self-hosted AI agent running with a secured web dashboard and verified LLM connectivity.

Install Docker

The official Docker repository gives you the most current Docker Engine builds.

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 and install Docker:

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

5. Add your user to the Docker group:

$ sudo usermod -aG docker $USER
$ newgrp docker

Set Up the Project Directory

1. Create the project directory:

$ mkdir -p ~/hermes/data
$ cd ~/hermes

2. Create the environment file:

$ nano .env

DOMAIN=hermes.example.com
LETSENCRYPT_EMAIL=admin@example.com

3. Generate dashboard authentication credentials:

$ docker run --rm httpd:2.4-alpine htpasswd -nbB admin 'your_dashboard_password' > .htpasswd

Deploy with Docker Compose

1. Create the Docker Compose file:

$ nano docker-compose.yml

services:
  traefik:
    image: traefik:v3
    command:
      - --providers.docker=true
      - --entrypoints.web.address=:80
      - --entrypoints.websecure.address=:443
      - --certificatesresolvers.letsencrypt.acme.email=${LETSENCRYPT_EMAIL}
      - --certificatesresolvers.letsencrypt.acme.storage=/data/acme.json
      - --certificatesresolvers.letsencrypt.acme.tlschallenge=true
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - ./data:/data

  hermes:
    image: nousresearch/hermes-agent:latest
    volumes:
      - ./data:/opt/data
    labels:
      - traefik.enable=true
      - traefik.http.routers.hermes.rule=Host(`${DOMAIN}`)
      - traefik.http.routers.hermes.entrypoints=websecure
      - traefik.http.routers.hermes.tls.certresolver=letsencrypt

  dashboard:
    image: nginx:alpine
    volumes:
      - ./.htpasswd:/etc/nginx/conf.d/.htpasswd
    labels:
      - traefik.enable=true
      - traefik.http.routers.dashboard.rule=Host(`${DOMAIN}`) && PathPrefix(`/dashboard`)
      - traefik.http.middlewares.dashboard-auth.basicauth.usersfile=/etc/nginx/conf.d/.htpasswd
      - traefik.http.routers.dashboard.middlewares=dashboard-auth

2. Open the firewall:

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

3. Start the services:

$ docker compose up -d

4. Verify the services are running:

$ docker compose ps

Configure the LLM

1. Run the model configuration command:

$ docker run -it --rm \
    -v ~/hermes/data:/opt/data \
    nousresearch/hermes-agent:latest model

2. Follow the prompts to select a provider and model.

The configuration supports OpenAI, Anthropic, OpenRouter, and any OpenAI-compatible endpoint. To use Vultr Serverless Inference, select the OpenAI-compatible option and provide your Vultr API key and the inference endpoint URL.

Verify the Deployment

1. Check the service logs:

$ docker compose logs hermes

2. Open the dashboard in a browser:

Visit https://hermes.example.com and log in with the credentials from the .htpasswd file.

3. Test LLM connectivity:

Send a simple query through the dashboard. A response from the model confirms the LLM connection is working.

Next Steps

Hermes Agent is running and connected to a language model. From here you can:

Connect messaging integrations for Telegram, Discord, Slack, or WhatsApp through the dashboard
Enable persistent memory so the agent retains context across sessions
Switch to Vultr Serverless Inference for a cost-effective, OpenAI-compatible LLM backend

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

Installing Caddy Web Server on Ubuntu 26.04

Aashish Chaurasiya — Wed, 13 May 2026 21:43:25 +0000

Caddy is an open-source web server written in Go that automatically provisions and renews HTTPS certificates from Let's Encrypt without any manual configuration. Unlike Apache or Nginx, Caddy makes HTTPS the default and handles certificate management entirely on its own. This guide installs Caddy on Ubuntu 26.04 from the official repository, configures a virtual host with automatic SSL, and verifies the setup. By the end, you'll have Caddy serving your domain over HTTPS with no manual certificate management required.

Install Caddy

Caddy provides an official APT repository for Debian-based systems.

1. Update the APT package index:

$ sudo apt update

2. Add the Caddy GPG key:

$ curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/gpg.key' | sudo gpg --dearmor -o /usr/share/keyrings/caddy-stable-archive-keyring.gpg

3. Add the Caddy APT repository:

$ curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/debian.deb.txt' | sudo tee /etc/apt/sources.list.d/caddy-stable.list

4. Refresh APT and install Caddy:

$ sudo apt update
$ sudo apt install caddy -y

5. Verify the installed version:

$ caddy version

Configure Caddy as a System Service

Enable Caddy to start automatically when the server boots.

1. Enable and start the service:

$ sudo systemctl enable caddy
$ sudo systemctl start caddy

2. Check the service status:

$ sudo systemctl status caddy

3. Stop or restart the service when needed:

$ sudo systemctl stop caddy
$ sudo systemctl restart caddy

Configure Firewall Rules

Port 80 is required for ACME certificate challenges.

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

Create a Virtual Host

1. Create the web root directory and set permissions:

$ sudo mkdir -p /var/www/app.example.com
$ sudo chown -R caddy:caddy /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 Caddy on Ubuntu 26.04</h1></body>
</html>

3. Create the log directory:

$ sudo mkdir -p /var/log/caddy
$ sudo chown -R caddy:caddy /var/log/caddy

4. Back up the default Caddyfile:

$ sudo mv /etc/caddy/Caddyfile /etc/caddy/Caddyfile.default

5. Create a new Caddyfile:

$ sudo nano /etc/caddy/Caddyfile

app.example.com {
    tls admin@example.com
    root * /var/www/app.example.com
    file_server {
        index index.html
    }
    log {
        output file /var/log/caddy/app.example.com.log
        format console
    }
}

Directives explained:

tls: email address for Let's Encrypt registration
root: document root directory
file_server: enables static file serving
log: routes access logs to a file

Validate and Reload

1. Format the Caddyfile:

$ sudo caddy fmt --overwrite /etc/caddy/Caddyfile

2. Validate the configuration:

$ sudo caddy validate --config /etc/caddy/Caddyfile

3. Reload Caddy:

$ sudo systemctl reload caddy

Open https://app.example.com in a browser. The page loads with a valid SSL certificate — no extra steps required.

Next Steps

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

Configure Caddy as a reverse proxy in front of a Node.js or Python application
Add multiple sites by appending additional server blocks to the Caddyfile
Enable automatic HTTP-to-HTTPS redirects — Caddy enables them by default

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

Installing Memcached on Ubuntu 26.04

Aashish Chaurasiya — Wed, 13 May 2026 21:43:22 +0000

Memcached is a high-performance distributed memory caching system that reduces database load by storing frequently accessed data in RAM. This guide installs Memcached on Ubuntu 26.04, configures SASL authentication to secure access, and verifies the setup with a PHP script that stores and retrieves a cached value. By the end, you'll have a secured Memcached instance ready for application use.

Install Memcached

Memcached is available in Ubuntu 26.04's default APT repository.

1. Update the APT package index:

$ sudo apt update

2. Install Memcached and the management tools:

$ sudo apt install memcached libmemcached-tools -y

What you just installed:

memcached: the caching server daemon
libmemcached-tools: CLI utilities for inspecting and managing Memcached

3. Verify the installed version:

$ memcached --version

Manage the Memcached Service

Enable Memcached to start automatically when the server boots.

1. Enable and start the service:

$ sudo systemctl enable memcached
$ sudo systemctl start memcached

2. Check the service status:

$ sudo systemctl status memcached

3. Stop or restart the service when needed:

$ sudo systemctl stop memcached
$ sudo systemctl restart memcached

Configure Memcached

1. Open the configuration file:

$ sudo nano /etc/memcached.conf

Verify the following settings are present:

-l 127.0.0.1
-l ::1
-p 11211
-c 1024
-S

These settings bind Memcached to localhost only, set the port to 11211, cap connections at 1024, and enable SASL support.

2. Restart Memcached to apply changes:

$ sudo systemctl restart memcached

Enable SASL Authentication

1. Install the SASL utilities:

$ sudo apt install sasl2-bin -y

2. Create the SASL configuration file:

$ sudo nano /etc/sasl2/memcached.conf

log_level: 5
mech_list: plain
sasldb_path: /etc/sasl2/memcached-sasldb2

3. Create a Memcached user:

$ sudo saslpasswd2 -a memcached -c -f /etc/sasl2/memcached-sasldb2 example_user

4. Set the correct ownership on the credential database:

$ sudo chown memcache:memcache /etc/sasl2/memcached-sasldb2

5. Restart Memcached:

$ sudo systemctl restart memcached

Test with PHP

1. Install PHP and the Memcached extension:

$ sudo apt install php php-memcached -y

2. Create a test script:

$ nano memcached_test.php

<?php
$memcached = new Memcached();
$memcached->setOption(Memcached::OPT_BINARY_PROTOCOL, true);
$memcached->addServer('127.0.0.1', 11211);
$memcached->setSaslAuthData('example_user', 'your_password');
$memcached->set('test_key', 'Hello from Memcached on Ubuntu 26.04');
echo $memcached->get('test_key');
?>

3. Run the script:

$ php memcached_test.php

The output Hello from Memcached on Ubuntu 26.04 confirms SASL authentication and caching are working correctly.

Next Steps

Memcached is running and secured with SASL authentication. From here you can:

Integrate Memcached with a PHP application using the php-memcached extension
Use memstat to monitor cache hit rates and memory usage
Deploy Memcached as a session storage backend for high-traffic web applications

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