DEV Community: Vultr

Deploying JupyterLab Interactive Notebook IDE on Ubuntu 24.04

Sanskriti Harmukh — Tue, 02 Jun 2026 12:06:48 +0000

JupyterLab is the next-generation web-based IDE for the Jupyter ecosystem, with notebook editing, file browsing, a terminal, and rich interactive outputs in one workspace. This guide deploys JupyterLab using Docker Compose with Traefik handling automatic HTTPS, backed by persistent notebook and data volumes. By the end, you'll have JupyterLab running securely at your domain, ready for Python development.

Set Up the Directory Structure

1. Create the project directory structure:

$ mkdir -p ~/jupyter-lab/{notebooks,data}
$ cd ~/jupyter-lab

2. Set ownership for the notebook and data directories:

$ sudo chown -R 1000:1000 notebooks data

3. Create the environment file:

$ nano .env

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

Deploy with Docker Compose

1. Create the Docker Compose manifest:

$ nano docker-compose.yaml

services:
  traefik:
    image: traefik:v3.6
    container_name: traefik
    command:
      - "--providers.docker=true"
      - "--providers.docker.exposedbydefault=false"
      - "--entrypoints.web.address=:80"
      - "--entrypoints.websecure.address=:443"
      - "--entrypoints.web.http.redirections.entrypoint.to=websecure"
      - "--entrypoints.web.http.redirections.entrypoint.scheme=https"
      - "--certificatesresolvers.letsencrypt.acme.httpchallenge=true"
      - "--certificatesresolvers.letsencrypt.acme.httpchallenge.entrypoint=web"
      - "--certificatesresolvers.letsencrypt.acme.email=${LETSENCRYPT_EMAIL}"
      - "--certificatesresolvers.letsencrypt.acme.storage=/letsencrypt/acme.json"
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - "letsencrypt:/letsencrypt"
      - "/var/run/docker.sock:/var/run/docker.sock:ro"
    restart: unless-stopped

  jupyter:
    image: jupyter/scipy-notebook:latest
    container_name: jupyter
    hostname: jupyter
    expose:
      - "8888"
    volumes:
      - "./notebooks:/home/jovyan/work"
      - "./data:/home/jovyan/data"
    environment:
      - JUPYTER_ENABLE_LAB=yes
    command: start-notebook.sh --NotebookApp.token='' --NotebookApp.password=''
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.jupyter.rule=Host(`${DOMAIN}`)"
      - "traefik.http.routers.jupyter.entrypoints=websecure"
      - "traefik.http.routers.jupyter.tls.certresolver=letsencrypt"
      - "traefik.http.services.jupyter.loadbalancer.server.port=8888"
    restart: unless-stopped

volumes:
  letsencrypt:

2. Start the services:

$ docker compose up -d

3. Verify the services are running:

$ docker compose ps
$ docker compose logs

Access JupyterLab

Open https://jupyter.example.com in a browser. JupyterLab loads directly into the workspace. Try a quick plot in a new notebook to verify the kernel is healthy:

import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(0, 10, 100)
plt.plot(x, np.sin(x))
plt.title('Test Plot')
plt.show()

Note: The Compose file above disables the token for simplicity. In production, set --NotebookApp.token=$(openssl rand -hex 32) and share the token only with authorized users, or front JupyterLab with HTTP basic auth at the Traefik layer.

Next Steps

JupyterLab is running and served securely over HTTPS. From here you can:

pip install extra packages directly in a notebook with !pip install <pkg>
Mount additional data sources or S3 buckets as /home/jovyan/data subfolders
Re-enable token or password auth and run multi-user instances via JupyterHub

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

Deploying Plex Home Media Streaming on Ubuntu 24.04

Sanskriti Harmukh — Tue, 02 Jun 2026 12:06:10 +0000

Plex is a personal media server that organizes and streams your movies, TV shows, music, and photos to clients on every major platform, with metadata, transcoding, and remote access built in. This guide deploys Plex using Docker Compose with Traefik handling automatic HTTPS, claimed against your Plex account at first run. By the end, you'll have a Plex Media Server streaming securely at your domain.

Prerequisite: Get a Plex claim token from plex.tv/claim. It's valid for 4 minutes, so generate it just before starting the stack.

Set Up the Directory Structure

1. Create the project directory structure:

$ mkdir -p ~/plex-media-server/{config,transcode,media}
$ cd ~/plex-media-server

2. Create the environment file:

$ nano .env

TZ=YOUR_TIMEZONE
PLEX_CLAIM=YOUR_PLEX_CLAIM_TOKEN
DOMAIN=plex.example.com
LETSENCRYPT_EMAIL=admin@example.com

Deploy with Docker Compose

1. Create the Docker Compose manifest:

$ nano docker-compose.yaml

services:
  traefik:
    image: traefik:v3.6
    container_name: traefik
    command:
      - "--providers.docker=true"
      - "--providers.docker.exposedbydefault=false"
      - "--entrypoints.web.address=:80"
      - "--entrypoints.websecure.address=:443"
      - "--entrypoints.web.http.redirections.entrypoint.to=websecure"
      - "--entrypoints.web.http.redirections.entrypoint.scheme=https"
      - "--certificatesresolvers.letsencrypt.acme.httpchallenge=true"
      - "--certificatesresolvers.letsencrypt.acme.httpchallenge.entrypoint=web"
      - "--certificatesresolvers.letsencrypt.acme.email=${LETSENCRYPT_EMAIL}"
      - "--certificatesresolvers.letsencrypt.acme.storage=/letsencrypt/acme.json"
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - "letsencrypt:/letsencrypt"
      - "/var/run/docker.sock:/var/run/docker.sock:ro"
    restart: unless-stopped

  plex:
    image: plexinc/pms-docker:latest
    container_name: plex
    hostname: plex
    expose:
      - "32400"
    volumes:
      - "./config:/config"
      - "./transcode:/transcode"
      - "./media:/data"
    environment:
      - TZ=${TZ}
      - PLEX_CLAIM=${PLEX_CLAIM}
      - ADVERTISE_IP=https://${DOMAIN}:443/
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.plex.rule=Host(`${DOMAIN}`)"
      - "traefik.http.routers.plex.entrypoints=websecure"
      - "traefik.http.routers.plex.tls.certresolver=letsencrypt"
      - "traefik.http.services.plex.loadbalancer.server.port=32400"
    restart: unless-stopped

volumes:
  letsencrypt:

2. Start the services:

$ docker compose up -d

3. Verify the services are running:

$ docker compose ps
$ docker compose logs

Configure Plex Media Server

Open https://plex.example.com in a browser.
Sign in with the Plex account that generated the claim token.
Name the server and add libraries pointing to folders under /data (your ./media mount).
Let Plex scan and fetch metadata. Install client apps on your devices to start streaming.

Next Steps

Plex is running and streaming securely over HTTPS. From here you can:

Add Movies, TV, Music, and Photos libraries with custom agents and scanners
Enable hardware-accelerated transcoding with a Plex Pass subscription
Set up managed users and parental controls for shared access

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

Deploying Redis In-Memory Data Store on Ubuntu 24.04

Sanskriti Harmukh — Tue, 02 Jun 2026 12:05:20 +0000

Redis is an open-source in-memory data store used as a cache, message broker, and primary database for low-latency workloads. This guide deploys Redis using Docker Compose with both RDB snapshots and AOF persistence enabled, password authentication, and a tuned host kernel setting. By the end, you'll have Redis accepting authenticated clients on your server.

Set Up the Directory Structure

1. Create the project directory structure:

$ mkdir -p ~/redis-stack/{data,conf}
$ cd ~/redis-stack

2. Create the environment file:

$ nano .env

REDIS_PASSWORD=STRONG_REDIS_PASSWORD
REDIS_PORT=6379

3. Create the Redis configuration file:

$ nano conf/redis.conf

bind 0.0.0.0
protected-mode yes
port 6379

save 900 1
save 300 10
save 60 10000

dir /data
dbfilename dump.rdb

appendonly yes
appendfilename "appendonly.aof"

Prepare the Host

Redis recommends vm.overcommit_memory=1 to avoid background-save failures under memory pressure.

1. Append the sysctl setting:

$ echo "vm.overcommit_memory = 1" | sudo tee -a /etc/sysctl.conf

2. Apply it immediately:

$ sudo sysctl -p

Deploy with Docker Compose

1. Create the Docker Compose manifest:

$ nano docker-compose.yaml

services:
  redis:
    image: redis:7.2
    container_name: redis
    command: [
      "redis-server",
      "/usr/local/etc/redis/redis.conf",
      "--requirepass", "${REDIS_PASSWORD}"
    ]
    ports:
      - "${REDIS_PORT}:6379"
    volumes:
      - "./data:/data"
      - "./conf/redis.conf:/usr/local/etc/redis/redis.conf:ro"
    environment:
      - REDIS_PASSWORD=${REDIS_PASSWORD}
    restart: unless-stopped

    healthcheck:
      test: ["CMD", "redis-cli", "-a", "${REDIS_PASSWORD}", "PING"]
      interval: 10s
      timeout: 3s
      retries: 5
      start_period: 5s

2. Start the service:

$ docker compose up -d

3. Verify the service is running:

$ docker compose ps
$ docker compose logs

Verify Connectivity

1. Install the redis-cli tool:

$ sudo apt install redis-tools -y

2. Ping the server with the password:

$ redis-cli -h REDIS_HOST -p REDIS_PORT -a REDIS_PASSWORD PING

A PONG response confirms Redis is accepting authenticated clients.

Next Steps

Redis is running with persistence and password auth. From here you can:

Tune maxmemory and the eviction policy to match your workload
Configure replication (replicaof) for read scaling and warm standbys
Bind Redis to 127.0.0.1 and front it via a VPN or stunnel for remote access

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

Deploying RabbitMQ Message Broker System on Ubuntu 24.04

Sanskriti Harmukh — Tue, 02 Jun 2026 12:04:41 +0000

RabbitMQ is an open-source message broker implementing AMQP and other protocols, used to decouple producers and consumers across distributed applications. This guide deploys RabbitMQ using Docker Compose with Traefik handling automatic HTTPS for the management UI, with persistent queue storage. By the end, you'll have RabbitMQ running with a secured management dashboard at your domain.

Set Up the Directory Structure

1. Create the project directory:

$ mkdir -p ~/rabbitmq-stack
$ cd ~/rabbitmq-stack

2. Create the environment file:

$ nano .env

DOMAIN=rabbitmq.example.com
LETSENCRYPT_EMAIL=admin@example.com
RABBITMQ_DEFAULT_USER=admin
RABBITMQ_DEFAULT_PASS=STRONG_PASSWORD

Deploy with Docker Compose

1. Create the Docker Compose manifest:

$ nano docker-compose.yaml

services:
  traefik:
    image: traefik:v3.6
    container_name: traefik
    command:
      - "--providers.docker=true"
      - "--providers.docker.exposedbydefault=false"
      - "--entrypoints.web.address=:80"
      - "--entrypoints.websecure.address=:443"
      - "--entrypoints.web.http.redirections.entrypoint.to=websecure"
      - "--entrypoints.web.http.redirections.entrypoint.scheme=https"
      - "--certificatesresolvers.letsencrypt.acme.httpchallenge=true"
      - "--certificatesresolvers.letsencrypt.acme.httpchallenge.entrypoint=web"
      - "--certificatesresolvers.letsencrypt.acme.email=${LETSENCRYPT_EMAIL}"
      - "--certificatesresolvers.letsencrypt.acme.storage=/letsencrypt/acme.json"
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - "letsencrypt:/letsencrypt"
      - "/var/run/docker.sock:/var/run/docker.sock:ro"
    restart: unless-stopped

  rabbitmq:
    image: rabbitmq:4.2-management
    container_name: rabbitmq
    hostname: rabbitmq
    ports:
      - "5672:5672"
    expose:
      - "15672"
    volumes:
      - "./data:/var/lib/rabbitmq"
      - "./logs:/var/log/rabbitmq"
    environment:
      - RABBITMQ_DEFAULT_USER=${RABBITMQ_DEFAULT_USER}
      - RABBITMQ_DEFAULT_PASS=${RABBITMQ_DEFAULT_PASS}
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.rabbitmq.rule=Host(`${DOMAIN}`)"
      - "traefik.http.routers.rabbitmq.entrypoints=websecure"
      - "traefik.http.routers.rabbitmq.tls.certresolver=letsencrypt"
      - "traefik.http.services.rabbitmq.loadbalancer.server.port=15672"
    restart: unless-stopped

volumes:
  letsencrypt:

2. Start the services:

$ docker compose up -d

3. Verify the services are running:

$ docker compose ps
$ docker compose logs

Access the RabbitMQ Management Dashboard

Open https://rabbitmq.example.com in a browser. Sign in with RABBITMQ_DEFAULT_USER and RABBITMQ_DEFAULT_PASS from .env. Application clients connect to AMQP on port 5672 at the server's address.

Next Steps

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

Create vhosts, users, and policies to isolate teams or environments
Define queues, exchanges, and bindings via the UI or rabbitmqctl
Enable shovel/federation plugins to bridge clusters across regions

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

Deploying Kafka Distributed Event Streaming on Ubuntu 24.04

Sanskriti Harmukh — Tue, 02 Jun 2026 12:04:03 +0000

Apache Kafka is an open-source distributed event streaming platform used for real-time pipelines, log aggregation, and event-driven architectures. This guide deploys a single-node Kafka 4.x cluster in KRaft mode (no ZooKeeper) using Docker Compose with persistent storage, then verifies producer/consumer flow with the Kafka CLI tools. By the end, you'll have Kafka accepting produced events and serving them to consumers on your server.

Set Up the Directory Structure

1. Create the project directory:

$ mkdir -p ~/kafka-stack/kafka-data
$ sudo chown 1000:1000 ~/kafka-stack/kafka-data
$ cd ~/kafka-stack

2. Generate a Kafka cluster ID:

$ uuidgen | tr -d '-'

Note the value — it goes into the .env file below.

3. Create the environment file:

$ nano .env

KAFKA_NODE_ID=1
KAFKA_CLUSTER_ID=YOUR_KAFKA_CLUSTER_ID
KAFKA_PORT=9092
KAFKA_ADVERTISED_HOST=localhost

Deploy with Docker Compose

1. Create the Docker Compose manifest:

$ nano docker-compose.yaml

services:
  kafka:
    image: apache/kafka:4.1.1
    container_name: kafka
    ports:
      - "${KAFKA_PORT}:9092"
    environment:
      KAFKA_NODE_ID: ${KAFKA_NODE_ID}
      KAFKA_PROCESS_ROLES: broker,controller
      KAFKA_LISTENERS: PLAINTEXT://0.0.0.0:9092,CONTROLLER://0.0.0.0:9093
      KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://${KAFKA_ADVERTISED_HOST}:9092
      KAFKA_CONTROLLER_QUORUM_VOTERS: 1@kafka:9093
      KAFKA_CONTROLLER_LISTENER_NAMES: CONTROLLER
      KAFKA_INTER_BROKER_LISTENER_NAME: PLAINTEXT
      KAFKA_LOG_DIRS: /kafka/data
      KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: 1
      KAFKA_TRANSACTION_STATE_LOG_REPLICATION_FACTOR: 1
      KAFKA_TRANSACTION_STATE_LOG_MIN_ISR: 1
      KAFKA_CLUSTER_ID: ${KAFKA_CLUSTER_ID}
    volumes:
      - "./kafka-data:/kafka/data"
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "kafka-broker-api-versions", "--bootstrap-server=localhost:9092"]
      interval: 10s
      timeout: 5s
      retries: 5

2. Start the service:

$ docker compose up -d

3. Verify the service is running:

$ docker compose ps
$ docker compose logs

Install the Kafka CLI Tools

1. Install Java and download the Kafka tools:

$ sudo apt update && sudo apt install -y default-jdk
$ wget https://downloads.apache.org/kafka/4.1.1/kafka_2.13-4.1.1.tgz
$ sudo tar -xzf kafka_2.13-4.1.1.tgz -C /opt

2. Put the Kafka CLI on your PATH:

$ echo 'export PATH=$PATH:/opt/kafka_2.13-4.1.1/bin' | sudo tee /etc/profile.d/kafka.sh
$ source /etc/profile.d/kafka.sh

Test Message Production and Consumption

1. Create a topic:

$ kafka-topics.sh --bootstrap-server localhost:9092 --create --topic test-topic --partitions 3 --replication-factor 1

2. Produce messages:

$ kafka-console-producer.sh --bootstrap-server localhost:9092 --topic test-topic

Type a few lines and press Ctrl+D to send.

3. Consume from the beginning:

$ kafka-console-consumer.sh --bootstrap-server localhost:9092 --topic test-topic --from-beginning

4. Describe the topic:

$ kafka-topics.sh --bootstrap-server localhost:9092 --describe --topic test-topic

Next Steps

Kafka is running in KRaft mode with persistent storage. From here you can:

Add more brokers and set replication factors > 1 for production durability
Enable SASL/SSL listeners to authenticate and encrypt client traffic
Wire in Kafka Connect, Schema Registry, or ksqlDB for richer pipelines

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

Deploying Elasticsearch Search and Analytics Engine on Ubuntu 24.04

Sanskriti Harmukh — Tue, 02 Jun 2026 12:03:24 +0000

Elasticsearch is an open-source distributed search and analytics engine built on Apache Lucene, used for full-text search, structured queries, and log analytics. This guide deploys a single-node Elasticsearch instance using Docker Compose with Traefik handling automatic HTTPS, then verifies it via cluster health and index APIs. By the end, you'll have Elasticsearch serving indexed data over HTTPS at your domain.

Set Up the Directory Structure

1. Create the project directory structure:

$ mkdir -p ~/elasticsearch-logging/{elasticsearch-data,elasticsearch-config}
$ cd ~/elasticsearch-logging

2. Set ownership for the Elasticsearch data directory:

$ sudo chown -R 1000:1000 elasticsearch-data

3. Create the environment file:

$ nano .env

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

4. Create the Elasticsearch configuration file:

$ nano elasticsearch-config/elasticsearch.yml

cluster.name: logging-cluster
node.name: node-1
network.host: 0.0.0.0
http.port: 9200
discovery.type: single-node
xpack.security.enabled: false

Deploy with Docker Compose

1. Create the Docker Compose manifest:

$ nano docker-compose.yaml

services:
  traefik:
    image: traefik:v3.6
    container_name: traefik
    command:
      - "--providers.docker=true"
      - "--providers.docker.exposedbydefault=false"
      - "--entrypoints.web.address=:80"
      - "--entrypoints.websecure.address=:443"
      - "--entrypoints.web.http.redirections.entrypoint.to=websecure"
      - "--entrypoints.web.http.redirections.entrypoint.scheme=https"
      - "--certificatesresolvers.letsencrypt.acme.httpchallenge=true"
      - "--certificatesresolvers.letsencrypt.acme.httpchallenge.entrypoint=web"
      - "--certificatesresolvers.letsencrypt.acme.email=${LETSENCRYPT_EMAIL}"
      - "--certificatesresolvers.letsencrypt.acme.storage=/letsencrypt/acme.json"
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - "letsencrypt:/letsencrypt"
      - "/var/run/docker.sock:/var/run/docker.sock:ro"
    restart: unless-stopped

  elasticsearch:
    image: docker.elastic.co/elasticsearch/elasticsearch:latest
    container_name: elasticsearch
    hostname: elasticsearch
    expose:
      - "9200"
    volumes:
      - "./elasticsearch-data:/usr/share/elasticsearch/data"
      - "./elasticsearch-config/elasticsearch.yml:/usr/share/elasticsearch/config/elasticsearch.yml"
    environment:
      - ES_JAVA_OPTS=-Xms1g -Xmx1g
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.elasticsearch.rule=Host(`${DOMAIN}`)"
      - "traefik.http.routers.elasticsearch.entrypoints=websecure"
      - "traefik.http.routers.elasticsearch.tls.certresolver=letsencrypt"
      - "traefik.http.services.elasticsearch.loadbalancer.server.port=9200"
    restart: unless-stopped

volumes:
  letsencrypt:

2. Start the services:

$ docker compose up -d

3. Verify the services are running:

$ docker compose ps
$ docker compose logs

Access Elasticsearch

1. Check cluster health:

$ curl https://elasticsearch.example.com/_cluster/health?pretty

2. Create a test index:

$ curl -X PUT "https://elasticsearch.example.com/test-index" \
    -H 'Content-Type: application/json' \
    -d '{"settings":{"number_of_shards":1,"number_of_replicas":0}}'

A {"acknowledged":true} response confirms the index was created.

Next Steps

Elasticsearch is running and serving over HTTPS. From here you can:

Re-enable xpack.security and configure built-in users for production access
Ship logs into indices with Filebeat, Logstash, or Vector
Add Kibana to visualize and query indexed data through the browser

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

Deploying Cassandra Distributed NoSQL Database on Ubuntu 24.04

Sanskriti Harmukh — Tue, 02 Jun 2026 12:02:53 +0000

Apache Cassandra is an open-source distributed NoSQL database designed for high write throughput and linear horizontal scaling across many nodes. This guide deploys a single-node Cassandra instance using Docker Compose with persistent storage, then runs basic CQL operations to verify it. By the end, you'll have Cassandra accepting CQL queries on your server.

Set Up the Directory Structure

1. Create the project directory structure:

$ mkdir -p ~/cassandra-logging/cassandra-data
$ cd ~/cassandra-logging

2. Set ownership for the Cassandra data directory:

$ sudo chown -R 999:999 cassandra-data

3. Create the environment file:

$ nano .env

CASSANDRA_CLUSTER_NAME=LogCluster
CASSANDRA_DC=datacenter1
CASSANDRA_RACK=rack1

Deploy with Docker Compose

1. Create the Docker Compose manifest:

$ nano docker-compose.yaml

services:
  cassandra:
    image: cassandra:latest
    container_name: cassandra
    hostname: cassandra
    ports:
      - "9042:9042"
    volumes:
      - "./cassandra-data:/var/lib/cassandra"
    environment:
      - CASSANDRA_CLUSTER_NAME=${CASSANDRA_CLUSTER_NAME}
      - CASSANDRA_DC=${CASSANDRA_DC}
      - CASSANDRA_RACK=${CASSANDRA_RACK}
      - CASSANDRA_ENDPOINT_SNITCH=GossipingPropertyFileSnitch
    restart: unless-stopped

2. Start the service:

$ docker compose up -d

3. Verify the service is running:

$ docker compose ps
$ docker compose logs

Cassandra takes a minute or two to fully come up. Wait until logs report Starting listening for CQL clients.

Access Cassandra

1. Open a CQL shell inside the container:

$ docker exec -it cassandra cqlsh

2. Inspect the cluster, create a keyspace, and run sample DDL/DML:

DESCRIBE CLUSTER;

CREATE KEYSPACE logs WITH replication = {'class': 'SimpleStrategy', 'replication_factor': 1};

USE logs;

CREATE TABLE application_logs (
  log_id UUID PRIMARY KEY,
  timestamp TIMESTAMP,
  level TEXT,
  message TEXT,
  service TEXT,
  host TEXT
);

INSERT INTO application_logs (log_id, timestamp, level, message, service, host)
VALUES (uuid(), toTimestamp(now()), 'INFO', 'Application started successfully', 'web-server', 'app-01');

SELECT * FROM application_logs;
SELECT COUNT(*) FROM application_logs;
EXIT;

Next Steps

Cassandra is running and serving CQL queries. From here you can:

Add more nodes and switch the replication strategy to NetworkTopologyStrategy
Enable authentication and authorization via PasswordAuthenticator
Tune concurrent_writes, compaction, and JVM heap for your write workload

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

Deploying ComfyUI AI Workflow Builder on Ubuntu 24.04

Sanskriti Harmukh — Tue, 02 Jun 2026 12:02:19 +0000

ComfyUI is an open-source, node-based interface for Stable Diffusion and other diffusion models, giving you a visual graph to compose image generation pipelines. This guide deploys ComfyUI using Docker Compose with Traefik handling automatic HTTPS, with persistent volumes for models, inputs, and outputs. By the end, you'll have a ComfyUI workflow editor running securely at your domain.

Set Up the Directory Structure

1. Create the project directory structure:

$ mkdir -p ~/comfyui/{storage,models,output,input}
$ cd ~/comfyui

2. Create the environment file:

$ nano .env

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

Deploy with Docker Compose

1. Create the Docker Compose manifest:

$ nano docker-compose.yaml

services:
  traefik:
    image: traefik:v3.6
    container_name: traefik
    command:
      - "--providers.docker=true"
      - "--providers.docker.exposedbydefault=false"
      - "--entrypoints.web.address=:80"
      - "--entrypoints.websecure.address=:443"
      - "--entrypoints.web.http.redirections.entrypoint.to=websecure"
      - "--entrypoints.web.http.redirections.entrypoint.scheme=https"
      - "--certificatesresolvers.letsencrypt.acme.httpchallenge=true"
      - "--certificatesresolvers.letsencrypt.acme.httpchallenge.entrypoint=web"
      - "--certificatesresolvers.letsencrypt.acme.email=${LETSENCRYPT_EMAIL}"
      - "--certificatesresolvers.letsencrypt.acme.storage=/letsencrypt/acme.json"
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - "letsencrypt:/letsencrypt"
      - "/var/run/docker.sock:/var/run/docker.sock:ro"
    restart: unless-stopped

  comfyui:
    image: yanwk/comfyui-boot:cu121
    container_name: comfyui
    hostname: comfyui
    expose:
      - "8188"
    volumes:
      - "./storage:/root"
      - "./models:/root/ComfyUI/models"
      - "./input:/root/ComfyUI/input"
      - "./output:/root/ComfyUI/output"
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.comfyui.rule=Host(`${DOMAIN}`)"
      - "traefik.http.routers.comfyui.entrypoints=websecure"
      - "traefik.http.routers.comfyui.tls.certresolver=letsencrypt"
      - "traefik.http.services.comfyui.loadbalancer.server.port=8188"
    restart: unless-stopped

volumes:
  letsencrypt:

2. Start the services:

$ docker compose up -d

3. Verify the services are running:

$ docker compose ps
$ docker compose logs

Access ComfyUI

Open https://comfyui.example.com in a browser. The node graph editor loads in the canvas — drag nodes from the right-click menu to build workflows. Place Stable Diffusion checkpoints under models/checkpoints/ to make them available in the loader nodes.

Next Steps

ComfyUI is running and served securely over HTTPS. From here you can:

Drop checkpoints, LoRAs, and VAE files into the respective models/ subfolders
Install ComfyUI-Manager to browse and install custom nodes from the UI
Save and share workflows as JSON files for reproducible pipelines

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

Deploying NATS High-Performance Messaging on Ubuntu 24.04

Sanskriti Harmukh — Tue, 02 Jun 2026 12:01:49 +0000

NATS is a high-performance, open-source messaging system built for cloud-native and edge workloads, with JetStream providing durable streams and key-value storage. This guide deploys NATS using Docker Compose with JetStream persistence and hashed-password authentication, then verifies connectivity with the NATS CLI. By the end, you'll have a NATS server accepting authenticated clients on your server.

Set Up the Directory Structure

1. Create the project directory structure:

$ mkdir -p ~/nats-stack/{data,config}
$ cd ~/nats-stack

2. Create the environment file:

$ nano .env

NATS_CLIENT_PORT=4222
NATS_CLUSTER_PORT=6222

Install the NATS CLI and Generate Password Hashes

1. Install the NATS CLI:

$ curl -sf https://binaries.nats.dev/nats-io/natscli/nats@latest | sh
$ sudo mv nats /usr/local/bin/
$ nats --version

2. Generate hashed passwords for the system and admin users:

$ nats server passwd
$ nats server passwd

Save each hash output — they're needed in nats.conf below.

3. Create the NATS configuration file:

$ nano config/nats.conf

# Client port
port: 4222
monitor_port: 8222
server_name: "NATS_SERVER_NAME"

# System account
system_account: SYS

accounts {
  SYS {
    users = [
      { user: "sysadmin", password: "SYSTEM_PASSWORD_HASH" }
    ]
  }
}

# JetStream
jetstream {
  store_dir: "/data/jetstream"
  max_mem_store: 1GB
  max_file_store: 5GB
}

authorization {
  default_permissions = {
    publish = "SANDBOX.*"
    subscribe = ["PUBLIC.>", "_INBOX.>"]
  }
  ADMIN = {
    publish = ">"
    subscribe = ">"
  }
  users = [
    {user: USERNAME, password: "USER_PASSWORD_HASH", permissions: $ADMIN}
  ]
}

Replace SYSTEM_PASSWORD_HASH, USER_PASSWORD_HASH, USERNAME, and NATS_SERVER_NAME with your values.

Deploy with Docker Compose

1. Create the Docker Compose manifest:

$ nano docker-compose.yaml

services:
  nats:
    image: nats:2.12
    container_name: nats
    command:
      - "-c"
      - "/etc/nats/nats.conf"

    ports:
      - "${NATS_CLIENT_PORT}:4222"
      - "${NATS_CLUSTER_PORT}:6222"

    volumes:
      - "./data:/data"
      - "./config/nats.conf:/etc/nats/nats.conf:ro"

    restart: unless-stopped

    healthcheck:
      test: ["CMD", "nats", "server", "ping"]
      interval: 10s
      timeout: 5s
      retries: 5

2. Start the service:

$ docker compose up -d

3. Verify the service is running:

$ docker compose ps
$ docker compose logs

Verify Connectivity

Ping the server with the CLI using the system account credentials:

$ nats --server nats://sysadmin:SYS_USER_PASSWORD@SERVER_IP:4222 server ping

A PONG response confirms NATS is accepting authenticated clients.

Next Steps

NATS is running with JetStream persistence and authentication. From here you can:

Create JetStream streams and consumers with nats stream add and nats consumer add
Add TLS by mounting certificates and enabling the tls block in nats.conf
Cluster multiple NATS servers by setting cluster routes for high availability

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

Deploying CouchDB JSON Document Store on Ubuntu 24.04

Sanskriti Harmukh — Tue, 02 Jun 2026 12:01:10 +0000

CouchDB is an open-source NoSQL document database that stores data as JSON, exposes a full RESTful HTTP API, and replicates between nodes natively. This guide deploys CouchDB using Docker Compose with Traefik handling automatic HTTPS, then verifies it with a database and document round-trip. By the end, you'll have CouchDB serving JSON documents over HTTPS at your domain.

Set Up the Directory Structure

1. Create the project directory structure:

$ mkdir -p ~/couchdb-logging/couchdb-data
$ cd ~/couchdb-logging

2. Set ownership for the CouchDB data directory:

$ sudo chown -R 5984:5984 couchdb-data

3. Create the environment file:

$ nano .env

DOMAIN=couchdb.example.com
LETSENCRYPT_EMAIL=admin@example.com
COUCHDB_USER=admin
COUCHDB_PASSWORD=changeme

Deploy with Docker Compose

1. Create the Docker Compose manifest:

$ nano docker-compose.yaml

services:
  traefik:
    image: traefik:v3.6
    container_name: traefik
    command:
      - "--providers.docker=true"
      - "--providers.docker.exposedbydefault=false"
      - "--entrypoints.web.address=:80"
      - "--entrypoints.websecure.address=:443"
      - "--entrypoints.web.http.redirections.entrypoint.to=websecure"
      - "--entrypoints.web.http.redirections.entrypoint.scheme=https"
      - "--certificatesresolvers.letsencrypt.acme.httpchallenge=true"
      - "--certificatesresolvers.letsencrypt.acme.httpchallenge.entrypoint=web"
      - "--certificatesresolvers.letsencrypt.acme.email=${LETSENCRYPT_EMAIL}"
      - "--certificatesresolvers.letsencrypt.acme.storage=/letsencrypt/acme.json"
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - "letsencrypt:/letsencrypt"
      - "/var/run/docker.sock:/var/run/docker.sock:ro"
    restart: unless-stopped

  couchdb:
    image: couchdb:latest
    container_name: couchdb
    hostname: couchdb
    expose:
      - "5984"
    volumes:
      - "./couchdb-data:/opt/couchdb/data"
    environment:
      - COUCHDB_USER=${COUCHDB_USER}
      - COUCHDB_PASSWORD=${COUCHDB_PASSWORD}
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.couchdb.rule=Host(`${DOMAIN}`)"
      - "traefik.http.routers.couchdb.entrypoints=websecure"
      - "traefik.http.routers.couchdb.tls.certresolver=letsencrypt"
      - "traefik.http.services.couchdb.loadbalancer.server.port=5984"
    restart: unless-stopped

volumes:
  letsencrypt:

2. Start the services:

$ docker compose up -d

3. Verify the services are running:

$ docker compose ps
$ docker compose logs

Access CouchDB

1. Create a database:

$ curl -X PUT https://admin:changeme@couchdb.example.com/logs

2. Insert a document:

$ curl -X POST https://admin:changeme@couchdb.example.com/logs \
    -H "Content-Type: application/json" \
    -d '{"level":"info","message":"first entry"}'

3. List all documents:

$ curl https://admin:changeme@couchdb.example.com/logs/_all_docs

The built-in admin UI (Fauxton) is available at https://couchdb.example.com/_utils/.

Next Steps

CouchDB is running and serving JSON documents over HTTPS. From here you can:

Create design documents with map/reduce views for structured queries
Set up continuous replication between CouchDB nodes or to PouchDB clients
Add per-database security objects to scope read/write access

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

Deploying Unbound Validating DNS Resolver on Ubuntu 24.04

Sanskriti Harmukh — Tue, 26 May 2026 15:22:46 +0000

Unbound is a validating, recursive, and caching DNS resolver that performs DNSSEC validation locally and answers queries without relying on third-party resolvers. This guide deploys Unbound using Docker Compose after freeing the system's port 53, with access controls that restrict who can query the resolver. By the end, you'll have a validating DNS resolver answering queries from approved clients on your server.

Free Port 53

Ubuntu's systemd-resolved binds port 53 by default. Release it before deploying.

1. Stop and disable systemd-resolved:

$ sudo systemctl stop systemd-resolved
$ sudo systemctl disable systemd-resolved

2. Replace the resolver configuration:

$ sudo rm /etc/resolv.conf
$ echo "nameserver 1.1.1.1" | sudo tee /etc/resolv.conf

Set Up the Directory Structure and Configuration

1. Create the project directory:

$ mkdir -p ~/unbound
$ cd ~/unbound

2. Create the Unbound configuration file:

$ nano unbound.conf

server:
  interface: 0.0.0.0
  interface: ::0
  port: 53

  access-control: 127.0.0.0/8 allow
  access-control: 192.168.0.0/16 allow
  access-control: 172.16.0.0/12 allow
  access-control: 10.0.0.0/8 allow
  access-control: YOUR_CLIENT_IP/32 allow
  access-control: 0.0.0.0/0 refuse

  hide-identity: yes
  hide-version: yes
  use-caps-for-id: yes
  prefetch: yes

  num-threads: 2
  msg-cache-slabs: 4
  rrset-cache-slabs: 4
  infra-cache-slabs: 4
  key-cache-slabs: 4
  rrset-cache-size: 100m
  msg-cache-size: 50m
  so-rcvbuf: 1m

remote-control:
  control-enable: no

Replace YOUR_CLIENT_IP/32 with the IP allowed to query the resolver.

Deploy with Docker Compose

1. Create the Docker Compose manifest:

$ nano docker-compose.yml

services:
  unbound:
    image: mvance/unbound:latest
    container_name: unbound
    restart: unless-stopped
    environment:
      TZ: UTC
    ports:
      - "53:53/tcp"
      - "53:53/udp"
    volumes:
      - ./unbound.conf:/opt/unbound/etc/unbound/unbound.conf:ro

2. Start the service:

$ docker compose up -d

3. Verify the service is running:

$ docker compose ps

Test Resolution

From an allowed client, query the resolver:

$ dig @SERVER_IP vultr.com

A valid answer section confirms Unbound is resolving queries.

Next Steps

Unbound is running with DNSSEC validation and tight access controls. From here you can:

Point your network's clients at the resolver to gain DNSSEC validation
Tune cache sizes and thread counts for your traffic volume
Layer block lists into unbound.conf to filter ads and malicious domains

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

Deploying Prometheus Metrics Collection Server on Ubuntu 24.04

Sanskriti Harmukh — Tue, 26 May 2026 15:22:17 +0000

Prometheus is an open-source systems monitoring and alerting toolkit that scrapes targets over HTTP and stores time-series metrics in a local TSDB. It exposes a powerful query language (PromQL) and pairs natively with Grafana for visualization. This guide deploys Prometheus using Docker Compose with Traefik handling automatic HTTPS, and verifies the server via a sample scrape config. By the end, you'll have Prometheus collecting and serving metrics over HTTPS at your domain.

Set Up the Directory Structure

1. Create the project directory structure:

$ mkdir -p ~/prometheus-monitoring/{prometheus-data,prometheus-config}
$ cd ~/prometheus-monitoring

2. Set ownership for the Prometheus data directory:

$ sudo chown -R 65534:65534 prometheus-data

3. Create the environment file:

$ nano .env

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

4. Create the Prometheus configuration file:

$ nano prometheus-config/prometheus.yml

global:
  scrape_interval: 15s
  evaluation_interval: 15s

scrape_configs:
  - job_name: 'prometheus'
    static_configs:
      - targets: ['localhost:9090']

Deploy with Docker Compose

1. Create the Docker Compose manifest:

$ nano docker-compose.yaml

services:
  traefik:
    image: traefik:v3.6
    container_name: traefik
    command:
      - "--providers.docker=true"
      - "--providers.docker.exposedbydefault=false"
      - "--entrypoints.web.address=:80"
      - "--entrypoints.websecure.address=:443"
      - "--entrypoints.web.http.redirections.entrypoint.to=websecure"
      - "--entrypoints.web.http.redirections.entrypoint.scheme=https"
      - "--certificatesresolvers.letsencrypt.acme.httpchallenge=true"
      - "--certificatesresolvers.letsencrypt.acme.httpchallenge.entrypoint=web"
      - "--certificatesresolvers.letsencrypt.acme.email=${LETSENCRYPT_EMAIL}"
      - "--certificatesresolvers.letsencrypt.acme.storage=/letsencrypt/acme.json"
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - "letsencrypt:/letsencrypt"
      - "/var/run/docker.sock:/var/run/docker.sock:ro"
    restart: unless-stopped

  prometheus:
    image: prom/prometheus:latest
    container_name: prometheus
    hostname: prometheus
    expose:
      - "9090"
    volumes:
      - "./prometheus-config/prometheus.yml:/etc/prometheus/prometheus.yml"
      - "./prometheus-data:/prometheus"
    command:
      - "--config.file=/etc/prometheus/prometheus.yml"
      - "--storage.tsdb.path=/prometheus"
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.prometheus.rule=Host(`${DOMAIN}`)"
      - "traefik.http.routers.prometheus.entrypoints=websecure"
      - "traefik.http.routers.prometheus.tls.certresolver=letsencrypt"
      - "traefik.http.services.prometheus.loadbalancer.server.port=9090"
    restart: unless-stopped

volumes:
  letsencrypt:

2. Start the services:

$ docker compose up -d

3. Verify the services are running:

$ docker compose ps

4. View the logs:

$ docker compose logs

Access Prometheus

Open https://prometheus.example.com in a browser. Try a basic PromQL query in the expression bar to confirm scraping:

up — scrape status of every target
process_cpu_seconds_total — Prometheus's own CPU usage
process_resident_memory_bytes — Prometheus's own memory usage

Next Steps

Prometheus is running and scraping metrics over HTTPS. From here you can:

Add scrape targets for your application, node exporters, and infrastructure
Connect Prometheus as a data source in Grafana for dashboards
Configure alerting rules and route them through Alertmanager

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