If you’ve ever felt overwhelmed managing multiple Docker stacks or wanted a more intuitive interface than raw CLI commands—Dockge might be your new favorite tool.

Dockge is a modern, elegant, and fully self-hosted manager built specifically for docker-compose users. It’s designed for those who want power and simplicity in a single place, without losing control over their YAML files or containers.

What Makes Dockge Special?

Unlike some heavier solutions, Dockge sticks to doing one thing—and does it really well: managing your compose.yaml stacks. Whether you’re starting, stopping, editing, or updating services, Dockge keeps it real-time and responsive.

Here’s what you get out of the box:

• Create, edit, start, stop, and delete your Docker stacks from a single UI.
• Update Docker images with just a few clicks.
• Interactive YAML editor for hands-on control.
• Built-in Web Terminal for direct command-line access.
• Multiple Agent Support to manage stacks across different hosts (since v1.4.0).
• Convert docker run commands into Compose YAML in seconds.
• File-based management — Dockge never hijacks your files; they’re still on disk and usable via CLI.

It’s reactive, lightweight, and honestly—kind of fun to use. Think Uptime Kuma, but for Docker Compose.

Easy Installation with Docker

Getting started with Dockge is straightforward:

# Create folders for stacks and Dockge's own files
mkdir -p /opt/stacks /opt/dockge
cd /opt/dockge

# Download the default compose.yaml
curl https://raw.githubusercontent.com/louislam/dockge/master/compose.yaml --output compose.yaml

# Start it up
docker compose up -d

Access it via your browser at http://localhost:5001, and you’re good to go!

You can also generate a custom compose.yaml file with your preferred port and stack directory via the interactive generator here: dockge.kuma.pet

Why Dockge Exists

The developer behind Dockge originally used Portainer but wanted something snappier and more focused on stacks. Dockge doesn’t try to replace Portainer entirely—it just makes managing Docker Compose setups smoother and less frustrating.

If all your infrastructure is compose.yaml-driven, Dockge is likely the best fit. But if you need to juggle volumes, networks, or standalone containers, keeping Portainer around might still be helpful.

Use Cases and Compatibility

Dockge is a great fit if:

• You’re self-hosting multiple services with Docker Compose.
• You like visual feedback and responsive interfaces.
• You want fine control without bloated features.

Supported OS and platforms include:

• Ubuntu / Debian Bullseye+ / Raspbian Bullseye+
• CentOS, Fedora, Arch
• Not yet supported on Windows
• Architectures: armv7, arm64, amd64

Updating Dockge

Updating is easy too:

cd /opt/dockge
docker compose pull && docker compose up -d

Just like that, you’re on the latest version.

Whether you’re a seasoned homelabber or just getting started with Docker, Dockge brings clarity and simplicity to Compose stack management. The UI is gorgeous, performance is fast, and setup is a breeze. You’ll wonder why you didn’t use it sooner.

Explore the GitHub repo: github.com/louislam/dockge
Watch the overview video: Dockge Demo

Bonus: Frequently Asked Questions

• Can I use Dockge with Portainer? Yes, they can run side-by-side.
• Can I manage existing stacks? Absolutely—just move your YAML files into /opt/stacks/<stack-name>/compose.yaml and click Scan Stacks Folder.
• Does it support single container management? Not directly—Dockge is purpose-built for Compose.

Final Thoughts

Dockge is a powerful tool that does one thing extremely well: give you full visual control of your Docker Compose stacks. It doesn’t try to be everything—and that’s what makes it great.

The post Dockge: A Sleek, Self-Hosted Docker Stack Manager for Compose Lovers appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

I’ve been looking for a good self-hosted media server, and after trying out a few, I landed on Jellyfin. It’s free, open-source, and doesn’t nag you with subscriptions or locked features. Exactly what I needed.

Instead of going the traditional apt install route, I decided to install Jellyfin using Flatpak — it keeps things clean and isolated, which I prefer on my Debian setup. Here’s how I got it up and running, including setting up access to my media folder.

Step 1: Installing Flatpak (if you don’t have it)

Flatpak wasn’t installed on my machine by default, so I ran:

sudo apt update
sudo apt install flatpak -y

After that, I added the Flathub repo:

flatpak remote-add --if-not-exists flathub https://flathub.org/repo/flathub.flatpakrepo

Quick tip: After setting up Flatpak, it’s best to log out and log back in — or just reboot — to make sure everything works smoothly.

Step 2: Installing Jellyfin Server via Flatpak

The Flatpak version of Jellyfin is available on Flathub, and installing it was simple:

flatpak install flathub org.jellyfin.JellyfinServer -y

To start the server, I ran:

flatpak run org.jellyfin.JellyfinServer

You’ll see some logs in the terminal, which means Jellyfin is doing its thing. Keep this terminal open for now — or later you can make it run in the background.

Step 3: Open It in Your Browser

Once it’s running, just go to:

http://localhost:8096

That’ll open the setup wizard where you pick a language, create your user, and set up your libraries.

If you’re running this on a different machine, just replace localhost with that machine’s IP.

Step 4: Giving Jellyfin Access to Your Media

Here’s where I got stuck for a minute: Jellyfin (via Flatpak) can’t see my media folders by default because of Flatpak’s sandboxing. Took me a second to figure this out.

Let’s say your movies are in /mnt/media/movies. You’ll need to give Jellyfin permission to see that folder:

flatpak override org.jellyfin.JellyfinServer --filesystem=/mnt/media:ro

The :ro part means read-only — safe if you don’t want Jellyfin messing with your files.

If you want it to write metadata, subtitles, etc., drop the :ro:

flatpak override org.jellyfin.JellyfinServer --filesystem=/mnt/media

Then just restart Jellyfin:

flatpak run org.jellyfin.JellyfinServer

Step 5: Add Media Libraries

Back in the web interface:

• Go to Dashboard > Libraries
• Click Add Media Library
• Pick what kind of content it is (Movies, TV, Music…)
• Point it to your folder, e.g., /mnt/media/movies
• Save and let Jellyfin do its magic

It’ll start scanning and building up your media library.

That’s It!

Jellyfin’s now up and running on my Debian system via Flatpak, and it’s happily indexing my media. The Flatpak approach keeps everything tidy, and it works great so far.

If you’re like me and prefer simple, no-nonsense tools that respect your setup, Jellyfin’s worth a try. And Flatpak makes it dead simple to install without touching your system packages.

The post How I Installed Jellyfin on Debian Using Flatpak appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

If you’ve ever needed to run multiple operating systems or servers on a single machine — whether for testing, development, or production — you’ve probably come across the idea of virtualization. And if you’ve explored the open-source side of things, chances are you’ve heard of Proxmox.

So, what exactly is Proxmox?
What can you do with it?
And why are so many people using it — from home lab tinkerers to big companies?

Proxmox in Simple Terms

Proxmox Virtual Environment (Proxmox VE) is a free and open-source platform that allows you to run virtual machines (VMs) and containers on a single server or across multiple servers.

Imagine being able to run Windows, Ubuntu, pfSense, and even your media server — all on the same physical machine — each in its own little bubble. That’s what Proxmox lets you do.

It comes with a clean web interface, built-in backup tools, clustering support, and lots of flexibility with storage and networking.

What Can You Use Proxmox For?

One of the best things about Proxmox is how versatile it is. Here are some real-world examples of how people use it:

1. Home Labs & Learning

Proxmox is hugely popular in the home lab community. Whether you’re studying for IT certifications, testing new software, or just learning how servers work, Proxmox gives you a safe space to experiment.

You can spin up virtual machines in minutes, try out different operating systems, and tear them down when you’re done — all without needing separate computers.

2. Small Business Infrastructure

Running a small business? Proxmox can help you do more with less.

You can host your:

• Web server
• Email system
• File sharing services
• Internal tools
• Backup systems

…all on one physical machine, saving money on hardware and power. Plus, it’s open-source — no expensive licensing fees.

3. Testing & Development

If you’re a developer, tester, or just someone who likes breaking things (on purpose), Proxmox is perfect for setting up test environments.

You can:

• Test code in different OS environments
• Clone a setup instantly
• Roll back to a snapshot if something breaks

It’s a great tool for agile workflows, automation testing, and staging environments.

4. Education & Training Labs

Schools, universities, and training centers use Proxmox to provide virtual labs for students.

Why? Because it’s:

• Cost-effective
• Easy to manage
• Supports remote access

It lets students experiment with servers, networking, firewalls, and more — without touching physical machines.

5. Self-Hosted Cloud & Services

Want to break free from big cloud providers? With Proxmox, you can build your own private cloud.

Set up things like:

• Nextcloud for file syncing
• Jellyfin or Plex for media streaming
• OpenVPN for secure remote access
• A custom DNS or firewall with something like pfSense

It’s your own cloud — under your control.

6. Enterprise Virtualization & Clusters

Proxmox isn’t just for home users. It’s used in production by companies, too.

With features like:

• High availability (HA)
• Live VM migration
• Multi-node clustering
• Integration with Ceph and ZFS storage

…it’s more than capable of running real business workloads. And since it has an API and command-line tools, it’s easy to automate and integrate with existing systems.

Backups, Snapshots & Disaster Recovery

One of the standout features of Proxmox is how it handles backups and snapshots. You can take live backups of running machines and schedule regular backups to external storage.

Snapshots are great for testing — make one before a risky update, and you can restore everything back if things go wrong.

There’s also Proxmox Backup Server, a companion tool designed specifically for efficient and encrypted backups.

Why People Love Proxmox

• Open-source and free to use
• Active community and regular updates
• Clean, powerful web interface
• Supports both VMs and containers
• Flexible storage options (ZFS, Ceph, NFS, etc.)
• Can scale from one server to a whole datacenter

Whether you’re managing just one server or a dozen, Proxmox gives you the tools to keep things under control — and make your infrastructure easier to manage.

Final Thoughts

So, what is Proxmox?

It’s a powerful, flexible platform that helps you do more with the hardware you already have. From small home labs to enterprise-grade virtualization clusters, Proxmox is one of the best open-source solutions out there for anyone interested in managing virtual machines or containers.

And the best part? You can try it for free. Just download the ISO, install it on a spare machine, and start building your own virtual world.

Resources

• Proxmox Official Site
• Proxmox Wiki & Documentation
• Proxmox Community Forum

The post What Is Proxmox? appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

I recently installed a SriHome SH025 IP camera and wanted to monitor the live stream from my Arch Linux desktop (CachyOS in my case). While the official app works, I prefer using local tools — no cloud, no mobile app, just clean video over my LAN.

After some digging, I got the RTSP stream working beautifully with mpv, and I even created a launcher icon for quick access.

Here’s exactly how I did it — plus how to find the right RTSP port using nmap.

My Setup Goals

• Watch the SriHome SH025 stream on my Linux desktop
• Skip the cloud and use direct RTSP
• Get working video (and ideally audio)
• Add a clickable desktop launcher
• Find the RTSP port if undocumented

Finding the RTSP Port with Nmap

SriHome cameras often don’t use the default RTSP port (554) — mine used 8554. If you don’t know your camera’s port, use nmap to scan for open ones:

1. Install nmap (if you don’t already have it):

sudo pacman -S nmap

2. Scan for common video streaming ports:

nmap -p 554,8554,10554,7070,6688 192.168.0.11

Replace 192.168.0.11 with your camera’s actual IP address.

Example output:

PORT      STATE  SERVICE
554/tcp   closed rtsp
8554/tcp  open   rtsp-alt
10554/tcp closed unknown
6688/tcp  open   unknown

In my case, port 8554 was open, which matched what ffplay and mpv needed.

Testing the Stream with ffplay

Before setting up anything fancy, I tested the RTSP stream with:

ffplay rtsp://admin:888888@192.168.0.11:8554/profile0

It worked! Full 1080p video and even audio came through. This confirmed the camera was broadcasting fine over RTSP.

Daily Viewing with MPV

After confirming the stream worked, I switched to mpv for daily use. It’s lightweight and integrates better with my desktop.

mpv rtsp://admin:888888@192.168.0.11:8554/profile0

Create a Desktop Shortcut

To make launching the camera easy from my app launcher, I made a .desktop file.

1. Create the launcher:

nano ~/.local/share/applications/sricam-view.desktop

2. Paste this:

[Desktop Entry]
Name=SriHome SH025 Viewer
Comment=Open SriHome IP Camera Stream in MPV
Exec=mpv rtsp://admin:888888@192.168.0.11:8554/profile0
Icon=camera-video
Terminal=false
Type=Application
Categories=Video;AudioVideo;Utility;

3. Make it executable:

chmod +x ~/.local/share/applications/sricam-view.desktop

Wrap-up

SriHome doesn’t document these RTSP settings well, but with a little effort — and tools like nmap, ffplay, mpv, and ffmpeg — you can get full, local access to your camera stream.

The post Viewing SriHome SH025 IP Camera on Linux with MPV appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

Unraid is a powerful, Linux-based operating system that lets you build your own custom Network Attached Storage (NAS), Virtual Machine Host, and Docker Application Server—all in one box.

Unlike traditional RAID or hypervisor setups, Unraid focuses on simplicity, flexibility, and modularity, making it a favorite among home lab enthusiasts, media hoarders, self-hosters, and even small businesses.

So how does Unraid work under the hood?

1. Unraid Is Not “RAID”—It’s Better for Mixed Drives

Despite its name, Unraid doesn’t use traditional RAID (like RAID 5 or 6). Instead, it uses a unique hybrid model based on:

• Individual disk volumes (each formatted with XFS or Btrfs)
• One or two parity disks for recovery
• No striping or data distribution

This means:

• You can mix and match any size drives.
• You can pull a disk and access its contents directly.
• Only the parity disk(s) must be equal to or larger than the largest data disk.
• Drives spin up only when accessed—saving energy.

Example:

If you have 4 drives:

• 3× data disks (e.g., 4TB, 6TB, 10TB)
• 1× parity disk (10TB)

Your array has 20TB usable storage with fault tolerance for 1 disk failure.

2. The Array and Parity System

Unraid manages storage using an Array:

• Each disk is formatted independently (no block-level striping).
• The parity disk stores checksums to allow for single-disk recovery.
• You can add or remove disks without reformatting the entire array.

There’s also a cache pool (usually SSDs) to:

• Speed up writes (files are written to cache first, then moved to the array later)
• Run virtual machines or Docker containers with high IOPS
• Minimize spin-up delays on HDDs

3. User Shares: Logical Storage Abstraction

Unraid lets you create User Shares, which are folders that span across multiple physical disks.

For example:

• /mnt/user/media might pull data from disk1, disk3, and disk5
• You can configure how files are distributed: most-free, high-water, fill-up
• Exclude/include specific disks per share

This gives the appearance of a single large folder while keeping physical separation intact.

4. Docker Container Management

Unraid includes built-in Docker support with a GUI to:

• Pull images from Docker Hub or custom registries
• Define volumes and port mappings
• Automatically update containers
• Use templates from the Community Applications plugin

Docker runs atop a Btrfs-formatted cache pool, so containers benefit from fast SSD speeds.

Popular self-hosted apps include:

• Plex, Jellyfin
• Nextcloud
• Pi-hole
• Home Assistant
• Nginx Proxy Manager

5. Virtual Machines (VMs)

Unraid includes a built-in KVM hypervisor, allowing you to run full operating systems like:

• Windows 10/11
• Ubuntu
• macOS (with tweaks)
• Other Linux distros

Features:

• Web-based VM manager
• Passthrough support for GPUs, USB controllers, NICs (via IOMMU/VT-d)
• Virtual disk and ISO management
• VNC remote access

With proper hardware, you can even game on a VM using GPU passthrough.

6. Flash Boot, License, and Security

• Boots from USB (persistent license key tied to the USB drive)
• Runs in RAM after booting, keeping system fast and stateless
• GUI accessible via web browser on port 80
• Plugins available for additional monitoring, security, or customization

Licensing tiers are based on the number of attached storage devices:

• Basic: up to 6 devices
• Plus: up to 12 devices
• Pro: unlimited devices

7. Recovery, Snapshots, and Parity Limitations

• You can recover data from individual disks even outside of Unraid, since they use standard filesystems.
• Unraid doesn’t support bitrot protection or multiple-disk failures unless you configure a second parity disk.
• No ZFS support out-of-the-box, but Btrfs cache pools do allow snapshots and checksumming.

Why Unraid?

• Easier than FreeNAS/TrueNAS
• No storage rebalancing or reformatting required
• Efficient for mixed disks
• Great for self-hosted apps
• Flexible VM support
• Extremely beginner-friendly web UI

Final Thoughts

Unraid strikes a balance between simplicity and power. It’s ideal for users who want a robust home server with storage, Docker, and VMs—all manageable through a friendly web interface.

Whether you’re running a media server, building a homelab, or hosting production apps on a budget, Unraid gives you control, flexibility, and peace of mind.

The post How Unraid Works: The Flexible OS for NAS, VMs, and Docker at Home appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

When it comes to managing people, spreadsheets eventually fall apart. Whether you’re a small startup, a non-profit, or just a tech-savvy HR manager tired of SaaS subscriptions, you’ve probably thought:

“Can I just self-host my own HR app?”

Yes, you can. And if you’re anything like me, that means Docker is non-negotiable. You want fast deployment, simple updates, container isolation, and most importantly, full control of your data.

But here’s the catch: not all open-source HR systems are Docker-ready, and many are clunky, outdated, or abandoned. So I did the dirty work: tested the top contenders, spun up containers, broke a few things, and came away with clear winners and losers.

Odoo (Community Edition): Best All-Rounder for Docker + HR

Website: https://www.odoo.com
HR Module Overview: https://www.odoo.com/page/human-resources
Official Docker Image: https://hub.docker.com/_/odoo

If you only read this far: Odoo is the one. Hands down.

Odoo is an ERP system. That usually scares people — they think it’s too big, too bloated, too enterprisey. But here’s the thing: Odoo is modular, and the Community Edition is free and completely open-source. You can start with just HR modules and ignore the rest. Later on, you can add CRM, invoicing, accounting, and more — if you need them.

Why Odoo rocks:

• Clean, modern web interface
• HR features are well-built: employee records, contracts, leave, attendance, appraisals, timesheets, and basic recruitment
• Official Docker image means no hacks or 10-year-old community images
• Big ecosystem — plugins, docs, community support

What to watch out for:

• Built-in payroll only exists in third-party modules or the paid Enterprise edition
• Requires PostgreSQL as a backend (easy with Docker Compose, though)

Real-world Docker setup:

version: '3'

services:
  db:
    image: postgres:15
    environment:
      POSTGRES_DB: odoo
      POSTGRES_USER: odoo
      POSTGRES_PASSWORD: odoo

  odoo:
    image: odoo:16
    ports:
      - "8069:8069"
    depends_on:
      - db
    environment:
      HOST: db
      USER: odoo
      PASSWORD: odoo
    volumes:
      - odoo-data:/var/lib/odoo

volumes:
  odoo-data:

Just docker compose up -d, go to http://localhost:8069, and you’re in business.

ERPNext: Full-Featured HR + Payroll

Website: https://erpnext.com
GitHub: https://github.com/frappe/frappe_docker

ERPNext is what you get when you take accounting seriously. It was born as an ERP, but its HR module is surprisingly deep, and it’s one of the few with built-in payroll, which Odoo lacks in its free edition.

It covers everything from:

• Recruitment & onboarding
• Employee lifecycle
• Appraisals & KPIs
• Salary slips & payroll
• Leave, attendance, and shift planning

Why ERPNext is powerful:

• Built-in payroll engine with salary structures and tax calculations
• Fully open-source and active development
• Docker support via frappe_docker is well-documented

Downsides:

• Much harder to install than Odoo
• Requires familiarity with the Frappe framework
• You’ll be dealing with a more complex Docker Compose stack (Redis, MariaDB, etc.)

This is for you if:

• You’re comfortable with complex Docker setups
• You need serious payroll functionality without paying for a SaaS

ICE Hrm: Quick, Lightweight HR in a Box

Website: https://icehrm.com
Docker Image: https://hub.docker.com/r/gamonoid/icehrm

ICE Hrm is the fastest one to get up and running. It’s a traditional LAMP stack (PHP + MySQL), but the devs provide a Docker image, and it actually works out of the box.

It’s great for:

• Small teams
• NGOs
• Freelancers with a couple of contractors

You get:

• Employee directory
• Leave tracking
• Attendance (even with GPS support)
• Time tracking
• Document uploads

Limitations:

• The free version is limited — no advanced payroll, no performance modules
• UI is clean but not as polished as Odoo
• Docker image is community-maintained (but mostly stable)

Still, if you want to spin something up in 2 minutes and track employee leave without paying a dime, this is it.

OrangeHRM: Popular, But Not Docker-First

Website: https://www.orangehrm.com
GitHub: https://github.com/orangehrm/orangehrm

OrangeHRM is the first open-source HR app many people find. And on paper, it’s solid:

• Employee management
• Leave management
• Recruitment module
• Admin roles and permissions

But here’s the problem: Docker support is missing. No official image. No easy way to containerize it. You’ll have to DIY with Apache, PHP configs, and maybe even wrestle with mod_rewrite.

If you’re already running a LAMP stack manually, you might like it. Otherwise, skip it and save yourself the pain.

Summary Table

Feature / App	Odoo	ERPNext	ICE Hrm	OrangeHRM
Docker Ready	Official	Official	Community	Manual Only
HR Features
Payroll	(3rd-party)	Built-in	Basic	(Enterprise)
Recruitment
UI/UX	Modern	Clean	Simple	Outdated
Complexity	Moderate	High	Easy	Manual Setup
Best For	Most teams	Full HR+Finance	Small setups	LAMP fans

Final Thoughts

If I had to choose just one open-source HR system to self-host in Docker, Odoo would be it — no contest.

It’s powerful, modern, Docker-ready, and backed by a massive community. Even if you only use the HR modules, you’re already ahead. And if you ever want to grow into CRM, eCommerce, or Accounting, it’s all there.

The post Best Open Source HR Apps for Self-Hosting appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

This is where WUD, short for What’s Up Docker, steps in as a game-changer.

WUD is a lightweight, open-source solution that continuously monitors your running Docker containers and alerts you when new versions of the base images are available. It saves time, ensures better security, and brings automation to your software maintenance workflow. If you’re running a homelab, hosting your own services, or managing production infrastructure, WUD is an essential tool in your DevOps toolbox.

Why Should You Care About Image Updates?

Let’s face it—container image updates often carry critical fixes:

• Security patches that close zero-day exploits
• Performance improvements that enhance your service responsiveness
• Bug fixes and new features that your applications benefit from immediately

Not updating means you’re running outdated, potentially vulnerable software. But manually checking all containers regularly is unrealistic. Automating this check is the smartest move—and that’s exactly what WUD offers.

Meet WUD: What’s Up Docker

WUD is a smart container update monitor. It inspects the Docker images behind your currently running containers and checks if newer versions are available in the registries. If it finds updates, WUD notifies you instantly—helping you take immediate action.

Built for Flexibility

WUD integrates beautifully with:

• Docker
• Docker Compose
• Private or public registries
• A wide range of notification platforms (email, Slack, MQTT, webhooks)

It supports custom triggers and regex filtering, giving you full control over how you track and react to image updates.

Web UI: Your Update Control Tower

The included web interface is clean, intuitive, and mobile-friendly. From a centralized dashboard, you can:

• View all running containers
• See the image version in use
• Get update availability in real-time
• Customize monitoring preferences

This turns WUD from just another background service into a powerful UI-driven monitoring assistant.

Getting Started in 5 Minutes

Deploying WUD is surprisingly simple. Here’s a basic example using Docker Compose:

version: "3.3"
services:
  wud:
    image: fmartinou/whats-up-docker
    container_name: wud
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    ports:
      - "3000:3000"
    environment:
      - WUD_TRIGGER_EMAIL_TO=you@example.com
      - WUD_TRIGGER_EMAIL_SMTP_HOST=smtp.example.com
      - WUD_TRIGGER_EMAIL_SMTP_PORT=587
      - WUD_TRIGGER_EMAIL_SMTP_USERNAME=your_username
      - WUD_TRIGGER_EMAIL_SMTP_PASSWORD=your_password

Once it’s running, visit http://localhost:3000 (or your server’s IP) to access the web dashboard.

Notifications: Choose Your Channel

WUD can send notifications via:

• Email: Ideal for personal servers or smaller teams.
• Slack: Integrates well with DevOps pipelines.
• MQTT: Perfect for IoT/automation setups.
• Webhooks: Trigger custom update workflows (like automatic redeploys or backups).

You can even set up multiple triggers per container.

Stay Secure, Stay Updated

Running outdated containers can expose your system to vulnerabilities. WUD helps you avoid this by:

• Prompting early patching
• Monitoring containers 24/7
• Supporting multi-arch and registry-compatible images

It doesn’t replace update automation tools like Watchtower, but complements them with granular visibility before updates are applied.

Real-World Use Cases

Here are some great examples of WUD in the wild:

• Self-hosted services: Running Pi-hole, Home Assistant, Nextcloud? Get alerts before your services become outdated or vulnerable.
• Development environments: Developers using Docker-based stacks can be notified of new base images (Node, Python, Java) for better consistency and performance.
• Production clusters: Ops teams can integrate WUD with CI/CD pipelines to schedule updates safely.
• Homelab setups: Perfect for tinkerers and home sysadmins to maintain their containers easily.

WUD vs. Watchtower

Feature	WUD	Watchtower
Web UI	Yes	No
Notification	Flexible	Email, Slack
Auto-updates	No	Yes
Transparency	High control	Can be automatic

Use WUD for visibility, and Watchtower if you want automatic image pulls and container redeploys.

Community & Support

WUD is open-source and actively developed on GitHub:
https://github.com/getwud/wud

You’ll find extensive documentation covering everything from basic setup to advanced features, like authentication, registry credentials, and notifications via third-party services.

Got issues or feature ideas? Just open an issue and join the community discussions.

Final Thoughts

Keeping containers up to date should never be an afterthought. With WUD, you’re no longer flying blind when it comes to Docker image updates. Whether you’re a sysadmin, homelabber, DevOps engineer, or a curious tinkerer, WUD gives you real-time visibility and control over what’s running in your infrastructure.

Try it once—WUD will become your new best friend in Docker image hygiene.

TL;DR

• WUD = “What’s Up Docker”
• Monitors Docker containers for image updates
• Notifies you via email, Slack, MQTT, or webhook
• Has a clean and powerful web UI
• Easy to set up and fully customizable

Keep your containers fresh and your system secure with WUD.

The post Keeping Your Docker Containers Fresh with WUD appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

Developed by Louis Lam, the creator of Uptime Kuma, Dockge is a sleek, self-hosted solution for managing your docker-compose.yaml files in a user-friendly, modern web UI—directly from your own infrastructure.

What Is Dockge?

Dockge is a Docker Compose manager that acts as a control center for all your containerized applications. Unlike heavyweight orchestration platforms like Portainer or Rancher, Dockge doesn’t abstract away your Compose files—instead, it embraces them.

It runs in your browser, provides a beautiful and responsive interface, and gives you full control over managing, editing, and deploying Docker Compose stacks.

If you’ve been manually juggling docker-compose up, down, logs, and pull across multiple folders and terminals, Dockge will feel like a leap into the future.

Core Features That Make Dockge Shine

File-Centric Management

Dockge doesn’t lock you into a database or an internal config. Your compose.yaml files live on disk, exactly where you put them. Want to edit them outside Dockge? Go ahead. Dockge simply reflects and operates on your actual file structure.

Clean, Reactive UI

Built with modern web technologies (likely Vue/React), Dockge’s interface is snappy and beautiful. Navigating your projects, spinning containers up and down, and checking logs feels almost instantaneous.

Built-in YAML Editor

No need to SSH in or fumble through nano. Dockge provides an in-browser YAML editor with syntax highlighting, so you can tweak your Compose files in real-time, from any device.

Manage Container Lifecycle

With just a few clicks, you can:

• Start or stop containers
• Restart entire stacks
• Pull new images
• View live logs
• See environment variables

Multiple Project Support

Dockge supports multiple projects, each represented as a folder containing a Compose file. Think of it as a workspace manager—ideal for homelabbers running various self-hosted services like Home Assistant, Nextcloud, Pi-hole, Jellyfin, etc.

Web Terminal

Need to run a one-off command inside a container? The integrated web terminal gives you shell access right in the browser, without needing to docker exec manually.

Convert Docker Run to Compose

This underrated feature lets you paste a docker run command and convert it into a docker-compose.yaml file. It’s a brilliant way to transition your one-off containers to managed stacks.

Who Is Dockge For?

Dockge is tailor-made for:

• Developers who want more control over containerized environments.
• Self-hosting enthusiasts looking for clean, no-nonsense management of their homelab apps.
• Tech-savvy hobbyists who don’t want to learn Kubernetes or manage overkill dashboards.
• Minimalists who believe that good tools should be powerful and elegant.

Getting Started with Dockge

Setting up Dockge is incredibly simple—if you already use Docker Compose, you’re halfway there. Here’s a high-level overview:

1. Clone the Repository

git clone https://github.com/louislam/dockge /opt/dockge

2. Move Into the Directory

cd /opt/dockge

3. Start the Service

docker compose up -d

By default, Dockge runs a web server where you can start managing your Compose projects immediately. It reads your existing file structure, meaning there’s no database to configure and no vendor lock-in.

4. Optional: Add Auth and SSL

You can easily integrate it behind a reverse proxy with basic auth or OAuth (via Nginx, Traefik, etc.) to keep your setup secure.

Community & Support

Dockge is a growing open-source project with an active and supportive community. Here’s how to get involved:

• Join GitHub Discussions
• Report bugs and suggest features via GitHub Issues
• Contribute code or docs to help the project grow

Louis Lam has a reputation for responsiveness and quality (just look at Uptime Kuma’s success), so Dockge is in good hands.

Dockge vs Alternatives

Feature	Dockge	Portainer	Yacht
Compose-first design	Yes	No (UI-driven)	Yes
File-based	Yes	No	Yes
Lightweight UI	Blazing fast	Heavy	Moderate
Conversion Tools	docker run → compose	No	No
Terminal Access	Built-in		No
Multi-project	Excellent

Final Thoughts: Should You Use Dockge?

Absolutely—especially if you value clean interfaces and control.

Dockge bridges the gap between command-line flexibility and modern user interfaces. It’s the perfect tool for self-hosters and developers who want a non-intrusive, elegant, and functional way to manage Docker Compose environments.

Whether you’re managing a fleet of Raspberry Pis, running a mini data center at home, or just hosting your personal blog and media server, Dockge will make your life easier.

Explore More

GitHub: https://github.com/louislam/dockge

Try it, star it, and join the conversation. Your containers will thank you.

The post Dockge: The Ultimate Docker Compose Manager for Modern Self-Hosters appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

This is where PortNote comes in — a minimal, beautiful, and self-hosted tool to help you track and document all your used ports in one glance.

Whether you’re running dozens of Docker containers, VMs, or bare-metal services, PortNote is a must-have for keeping your infrastructure tidy and your sanity intact.

What is PortNote?

PortNote is a web-based app designed to let you quickly and visually document port usages. Think of it as a personal notepad or dashboard specifically built for network and application ports.

It’s completely self-hosted, requires no external services, and offers a beautiful interface for you to:

• Track which services use which ports
• Add meaningful descriptions and links
• Group entries by server or IP
• Avoid port conflicts
• Stay organized, especially in a growing homelab or VPS setup

PortNote is perfect for:

• Homelab enthusiasts
• Sysadmins managing multiple services
• Developers juggling local development ports
• Anyone using Docker, Proxmox, or VMs

Key Features

• Visual port mapping: Clean, card-style display of services and ports
• Notes and descriptions: Add context to each port so you never forget
• Clickable links: Link to service dashboards or local UIs
• Group by server/IP: Useful when managing multiple machines
• Lightweight & fast: No database, runs entirely in your browser
• Simple JSON backend: Data is stored in a local db.json file
• Docker-ready: Just one container to deploy

How to Deploy PortNote (Docker)

Getting PortNote running is super simple. Here’s a quick guide to deploy it using Docker:

Step 1: Clone the Repository

git clone https://github.com/crocofied/PortNote.git
cd PortNote

Step 2: Launch with Docker

docker compose up -d

That’s it!

By default, PortNote runs on port 5173. Open your browser and head to:

http://localhost:5173

You’ll be greeted with a clean and modern interface where you can begin adding your services and their associated ports.

Data Storage

PortNote stores your port notes in a local file called db.json.

By default, this file is mounted into the container to persist your data:

volumes:
  - ./db.json:/app/db.json

You can easily back it up, version it with Git, or sync it across devices if needed. It’s that simple.

How to Use PortNote

Once you’re inside the web UI, you’ll see a form to add a new port entry. Here’s how you might use it:

Click Add, and the port is logged and visually displayed on your dashboard.

You can edit or delete entries anytime — it’s designed to be fast and intuitive.

Demo

Want to try before hosting?

A live demo is available at:
https://portnote-demo.netlify.app

Note: The demo does not save your data between sessions.

Privacy and Simplicity

PortNote doesn’t phone home. It’s a fully static app with no telemetry, no analytics, and no dependencies beyond your browser and the JSON file. It’s perfect for privacy-focused users.

In fact, if you’d prefer to run it without Docker, you can even build and serve it statically via NGINX, Caddy, or any file server.

Advanced Deployment (Static Hosting)

Want to host PortNote without Docker? You can!

Build it manually:

npm install
npm run build

Then copy the contents of the dist/ directory to any web server of your choice — it’s just HTML, CSS, and JS.

You’ll also need to configure access to db.json or wire it up to a backend of your choice (e.g., Firebase, Supabase, etc.) if you want something more advanced.

Why PortNote is Useful

In a world where we’re running Grafana on :3000, Portainer on :9000, Prometheus on :9090, your blog on :4000, and who knows what else — it’s easy to forget.

PortNote gives you a single place to document everything and avoid confusion or port conflicts.

It also becomes handy when you revisit your homelab setup after a few weeks (or months) and don’t want to reverse-engineer every docker-compose.yml.

Final Thoughts

PortNote is one of those tools that’s small, but incredibly effective. If you maintain any sort of local or cloud infrastructure, this is a fantastic addition to your toolbox.

No overhead, no login systems, no complex config. Just a clean interface to help you stay organized.

Official GitHub:
https://github.com/crocofied/PortNote

Created by: @crocofied

The post PortNote – A Beautiful and Simple Way to Document Your Network Ports appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

Isn’t Linux supposed to be faster?

Yes… but “lighter” doesn’t always mean “faster” in daily use. There are several reasons why Ubuntu 25.04 might feel heavier than Windows 10 on the same hardware, and the good news is: you can fix most of them.

Let’s explore why this happens and how you can tweak Ubuntu for a smoother experience.

GNOME Desktop: Beautiful but Bulky

Ubuntu 25.04 ships with the GNOME desktop environment, which is modern and visually polished—but not lightweight.

Compared to Windows 10’s UI, GNOME:

• Uses more RAM and CPU
• Has animations and background daemons that run persistently
• May struggle on older or mid-range hardware

Fix: Install a lighter desktop environment like:

• Xfce: sudo apt install xubuntu-desktop
• MATE: sudo apt install ubuntu-mate-desktop
• LXQt: sudo apt install lubuntu-desktop

These will drastically improve responsiveness, especially on older systems.

Memory Handling: Different Philosophies

Windows 10 uses aggressive memory prefetching and caching to make apps launch quickly. Even if the system uses more RAM, it often feels snappier.

Ubuntu, on the other hand:

• Prioritizes minimal RAM usage at idle
• Loads apps on-demand rather than predicting

So Linux may feel slower to launch apps, but it’s actually using RAM more efficiently. The “snappiness” just needs a few tweaks.

Fix:

• Install preload: sudo apt install preload
• Enable zram swap: sudo apt install zram-tools && sudo systemctl enable --now zramswap.service

Drivers: Windows Has the Advantage

Most laptops come with OEM-optimized drivers for Windows. Linux often has to rely on:

• Generic open-source drivers
• Community-developed alternatives (e.g. Nouveau for NVIDIA)

This can affect:

• Graphics performance
• Battery life
• Touchpad gestures
• Wi-Fi stability

Fix:

• Use proprietary drivers where available: sudo ubuntu-drivers autoinstall
• Reboot and check with lshw -c video to confirm usage.

Power Management and CPU Scaling

On Windows, manufacturers preload power profiles, tuned firmware, and thermal governors.

Linux relies on the CPU governor, which may default to “powersave” or “ondemand”—making your laptop feel laggy.

Fix:

• View profiles: powerprofilesctl list
• Switch to performance: sudo apt install power-profiles-daemon powerprofilesctl set performance

For older systems, use cpufrequtils:

sudo apt install cpufrequtils
echo 'GOVERNOR="performance"' | sudo tee /etc/default/cpufrequtils
sudo systemctl restart cpufrequtils

Snap Packages and Startup Lag

Ubuntu ships many apps as Snap packages. These:

• Are isolated and more secure
• But launch slower and consume more disk I/O

Fix:

• Replace with .deb versions when possible: sudo snap remove firefox sudo add-apt-repository ppa:mozillateam/ppa sudo apt install firefox

You can also disable Snap entirely and switch to Flatpak or classic APT apps.

Optional Tips for a Faster Ubuntu

Here are a few more tweaks to make Ubuntu faster and lighter:

Disable Unused Services

Use systemd-analyze blame to see slow boot processes. Disable what you don’t need:

sudo systemctl disable <service>

Use a Lightweight File Manager

Replace Nautilus with something faster like:

sudo apt install thunar

Use a Lightweight Browser

Try Librewolf, Falkon, or GNOME Web instead of Firefox or Chrome.

Benchmark Comparison: Windows 10 vs Ubuntu 25.04 (GNOME)

With the above tweaks (especially desktop environment change and Snap removal), Ubuntu can outperform Windows 10 in real-world use.

Conclusion: Don’t Give Up on Ubuntu!

If Ubuntu 25.04 feels heavier than Windows 10, it’s not your hardware—it’s just that Ubuntu’s default setup is not optimized for every machine out-of-the-box.

The beauty of Linux is in its customizability. With a few simple tweaks, you can make Ubuntu faster, lighter, and tailored perfectly to your system.

Feel free to share this post with friends facing the same issue—or better yet, give them a hand tuning their Linux box.

The post Why Windows 10 Feels Lighter Than Ubuntu 25.04 (And How to Fix It) appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

In this post, we’ll explore the top 5 open-source NAS operating systems you can deploy today. Each one is suited to different needs—ranging from powerful enterprise-level setups to simple plug-and-play solutions for beginners.

1. TrueNAS CORE (formerly FreeNAS) – The ZFS King

Base OS: FreeBSD
Filesystem: ZFS
Best for: Power users, enterprises, and anyone who values data integrity

Why TrueNAS CORE?

TrueNAS CORE is the gold standard in open-source NAS software. Built on FreeBSD and leveraging the incredibly robust ZFS file system, it offers data protection features like checksumming, copy-on-write, and built-in snapshots.

It comes with a polished web UI, plugin support (e.g., Nextcloud, Plex, Transmission), replication tools, encryption, and advanced networking. It even supports virtual machines and Docker via its Linux counterpart, TrueNAS SCALE.

Recommended if you have 8GB+ RAM, preferably ECC, and want bulletproof storage with enterprise-level features.

https://www.truenas.com/truenas-core/

2. OpenMediaVault (OMV) – Best for Simplicity and Home Use

Base OS: Debian Linux
Filesystem: ext4, XFS, Btrfs, ZFS (via plugin)
Best for: Home servers, Raspberry Pi NAS builds, beginners

Why OpenMediaVault?

If you’re looking for something lightweight and easy to manage, OMV is your go-to. It’s perfect for home users or beginners wanting to set up a file server, media server, or even a Time Machine backup destination.

With Docker and Portainer integration, you can run containers effortlessly. It also has a large ecosystem of plugins and excellent community support.

Ideal for Raspberry Pi, mini PCs, or old laptops converted into a NAS.

https://www.openmediavault.org/

3. Rockstor – Linux-Based NAS with Btrfs Power

Base OS: openSUSE (newer versions)
Filesystem: Btrfs
Best for: Developers, Docker fans, modern Linux users

Why Rockstor?

Rockstor is a lesser-known but powerful NAS option that revolves around Btrfs, a modern copy-on-write file system with snapshot and compression capabilities. It features a clean web UI, Docker support, and great storage management features.

If you’re into Linux and want an alternative to ZFS, Rockstor’s Btrfs-first approach is worth trying.

Perfect for DIYers and devs looking to experiment with containers and Btrfs.

https://rockstor.com/

4. XigmaNAS (formerly NAS4Free) – Lightweight BSD NAS

Base OS: FreeBSD
Filesystem: ZFS, UFS
Best for: Legacy hardware, users who want a BSD NAS without bloat

Why XigmaNAS?

Think of XigmaNAS as the simpler cousin of TrueNAS. It’s BSD-based, supports ZFS, and runs well on older hardware. The UI is not as polished, but it gets the job done.

It supports all major sharing protocols (SMB, NFS, AFP, FTP, etc.) and can be configured for RAID, iSCSI, and rsync easily.

Great for repurposing older PCs into reliable NAS boxes.

https://www.xigmanas.com/

5. EasyNAS – Minimalist and Straightforward

Base OS: openSUSE
Filesystem: Btrfs
Best for: Total beginners, plug-and-play NAS setups

Why EasyNAS?

True to its name, EasyNAS is built for simplicity. It’s lightweight, quick to install, and has a minimal interface that lets you set up your file server in minutes. It lacks advanced features, but for basic use—like backing up files or sharing over the network—it’s more than capable.

Best if you want a “set it and forget it” NAS with minimal learning curve.

https://easynas.org/

Comparison at a Glance

Final Thoughts: Which NAS Should You Choose?

• Choose TrueNAS CORE if you want maximum reliability with ZFS, advanced features, and don’t mind the extra learning curve.
• Choose OpenMediaVault for ease of use, Raspberry Pi support, and excellent Docker integration.
• Choose Rockstor if you prefer Linux and want to explore Btrfs with Docker.
• Choose XigmaNAS for a light BSD-based NAS on old or underpowered hardware.
• Choose EasyNAS if you want a quick and easy local file server without the fluff.

Have questions or need help choosing the right NAS for your setup? Feel free to reach out or drop a comment below. Whether you’re running this on a recycled PC or a Raspberry Pi, there’s never been a better time to go open-source with your storage.

The post The Best Open Source NAS Operating Systems appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

In this post, we’ll explore the top FreeBSD-based small operating systems you can install on x86 hardware to transform it into a powerful, reliable, and secure router or firewall.

Why Use FreeBSD for Network Appliances?

FreeBSD is widely respected for its:

• Rock-solid performance
• Advanced networking features (like PF, IPFW, and netgraph)
• Security-focused architecture
• Clean, consistent system design

These features make it a preferred base for commercial and open-source router/firewall systems.

1. pfSense® – Trusted and Proven

pfSense is arguably the most popular FreeBSD-based firewall/router OS in the world. Maintained by Netgate, it combines FreeBSD’s power with a user-friendly web interface, making it suitable for both home users and professionals.

Key Features:

• Web GUI for full control
• Stateful firewall with PF
• NAT, port forwarding, VLANs
• Built-in DHCP, DNS forwarding, and captive portal
• VPN support (OpenVPN, IPsec, WireGuard)
• High availability (CARP/HA)
• Traffic shaping and Quality of Service (QoS)
• Add-on packages (Snort, pfBlockerNG, Squid, etc.)

Minimum Requirements:

• x86 or x86_64 CPU
• 1GB RAM (2GB or more recommended)
• 4GB storage (SSD preferred)
• At least two network interfaces (NICs)

Best Use Cases:

• Home firewall/router
• Small office or business gateway
• Educational networks
• VPN edge device

Official Website:
https://www.pfsense.org

2. OPNsense® – Modern and Open Alternative

OPNsense is a community-driven, open-source fork of pfSense. Built on FreeBSD, it offers a more modern user interface, frequent updates, and a plugin system designed for flexibility.

What Makes It Different from pfSense?

• Modern and responsive web UI
• Faster update cycles (weekly)
• HardenedBSD kernel (optional for extra security)
• Better plugin framework
• Transparent open development model

Notable Features:

• IDS/IPS with Suricata
• Real-time traffic graphs and reporting
• DNS over TLS, DoH, and encrypted DNS options
• Built-in 2FA and secure remote management
• Easy backup and restore

Ideal For:

• Users who want modern UI and faster development
• Advanced users who prefer open-source transparency
• Businesses that require frequent security updates

Official Website:
https://opnsense.org

3. NanoBSD – Minimal FreeBSD for Embedded Systems

NanoBSD isn’t a separate OS, but a build tool that comes with FreeBSD. It creates minimal, read-only, embedded FreeBSD images for use on devices with limited storage or specialized applications (e.g., routers, kiosks, and appliances).

Features:

• Extremely lightweight image (~100–300MB)
• Read-only root filesystem (reduces corruption)
• Optimized for CF/SD/USB media
• Easily upgradable via scripts
• Complete control over what goes into the system

Important Notes:

• No graphical UI by default
• Requires strong FreeBSD knowledge
• Manual configuration of services and network interfaces

Best For:

• Developers creating custom appliances
• Embedded or industrial x86 systems
• Learning how FreeBSD works under the hood

Documentation:
https://docs.freebsd.org/en/articles/nanobsd/

Comparison Table

Feature	pfSense	OPNsense	NanoBSD
Based on FreeBSD	Yes	Yes	Yes
Web Interface	Yes	Yes	No
VPN Support	Yes	Yes	Manual Only
IDS/IPS	(Add-ons)	(Suricata)	No
Plugin System	Yes	Yes	No
Beginner Friendly	Yes	Yes	No
For Embedded Devices	Not ideal	Not ideal	Yes
Frequent Updates	Moderate	Weekly	Manual

Hardware Recommendations

You can run pfSense or OPNsense on many low-power x86 machines, including:

• Intel NUCs and mini PCs
• Used thin clients (e.g., HP T620 Plus, Dell Wyse)
• PC Engines APU series
• Small form factor desktops with 2+ NICs

Tip: For best performance and compatibility, always use Intel-based network cards (NICs) — FreeBSD has excellent driver support for them.

Choosing the Right One

Final Thoughts

Building your own firewall or router using FreeBSD-based systems is a rewarding project. It gives you:

• Full control over your network
• Better privacy and security
• Valuable knowledge in networking and open-source systems

Whether you choose pfSense, OPNsense, or go all-in with NanoBSD, you’ll be using a robust foundation trusted by professionals worldwide.

All it takes is an old PC or a mini PC, a USB installer, and a bit of time.

The post Best Small FreeBSD-Based Systems for Routers & Firewalls (x86 Hardware) appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

FreeBSD is a powerful and stable UNIX-like operating system renowned for its performance, security, and advanced networking features. While it’s widely used for servers and firewalls, it also makes an excellent choice for running a home media server. In this guide, I’ll walk you through how to set up FreeBSD as a media server from scratch.

Whether you’re streaming movies via Plex or Jellyfin, serving audio through DLNA, or just organizing your media over SMB/NFS, FreeBSD offers a clean and minimal platform to build on — free of bloat and with full control.

Prerequisites

• A spare computer or VM with at least:
  • 2 CPU cores
  • 4GB RAM (8GB+ recommended for transcoding)
  • 100GB+ storage (depending on your media collection)
• Internet connection
• A basic understanding of terminal commands

Step 1: Installing FreeBSD

1. Download the ISO
   • Visit https://www.freebsd.org/ and download the latest stable release (e.g. FreeBSD 14.0) ISO under the amd64 architecture.
2. Create a Bootable USB sudo dd if=FreeBSD-14.0-RELEASE-amd64-disc1.iso of=/dev/sdX bs=1M (Replace /dev/sdX with your USB device)
3. Boot & Install
   • Boot into the USB.
   • Follow the guided install:
     • Set hostname (e.g. media-server)
     • Use ZFS as the filesystem for features like snapshots
     • Enable sshd, ntpd
     • Create a user (e.g. piju) and add to the wheel group
4. Reboot and login

Step 2: Post-Install Setup

1. Update the system sudo freebsd-update fetch install sudo pkg update && sudo pkg upgrade
2. Install essential tools sudo pkg install sudo nano tmux htop
3. Allow your user to use sudo echo 'piju ALL=(ALL) NOPASSWD: ALL' | sudo tee -a /usr/local/etc/sudoers.d/piju

Step 3: Install Media Server Software

Option 1: Plex Media Server (Proprietary)

sudo pkg install plexmediaserver
sudo sysrc plexmediaserver_enable=YES
sudo service plexmediaserver start

Access via browser:
http://<your_ip>:32400/web

Option 2: Jellyfin (Open Source)

Install from packagesite:

sudo pkg install jellyfin
sudo sysrc jellyfin_enable=YES
sudo service jellyfin start

Access via browser:
http://<your_ip>:8096

Option 3: Emby (Optional Alternative)

Download .txz package from https://emby.media/ and install manually.

Step 4: Add Your Media

1. Create media directories:

sudo mkdir -p /mnt/media/{movies,tv,music}
sudo chown -R media:media /mnt/media

2. Mount storage (if using a separate drive):
   Edit /etc/fstab and mount your drive (e.g., /dev/ada1p2) to /mnt/media.
3. Point your media server (Jellyfin/Plex) to these directories in the web UI.

Step 5: Optional – Enable Sharing Over Network

DLNA Server (MiniDLNA)

sudo pkg install minidlna
sudo sysrc minidlna_enable=YES
sudo service minidlna start

Edit /usr/local/etc/minidlna.conf to point to your media directories.

SMB (Samba)

sudo pkg install samba413
sudo sysrc samba_server_enable=YES
sudo service samba_server start

Configure /usr/local/etc/smb4.conf and add your user with smbpasswd -a piju.

Step 6: Secure Remote Access

• Set up SSH key-based login
• Change default SSH port (in /etc/ssh/sshd_config)
• Optionally install fail2ban (via ports or manually)

Bonus Tips

• Set up ZFS snapshots for backup and rollback
• Install transmission-daemon for torrents
• Monitor storage with zpool list and df -h
• Use smartmontools for drive health checks

Conclusion

FreeBSD may seem unconventional for a media server, but it provides unmatched control, performance, and security — with no background bloatware. Once you get familiar with its ecosystem, it becomes a solid and long-lasting foundation for any home server project.

If you prefer minimalism, stability, and advanced file systems like ZFS, FreeBSD is an excellent choice for your media streaming needs.

The post How to Use FreeBSD as a Media Server: A Lightweight, Rock-Solid Solution appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

If you’re looking for a low-power, always-on solution for streaming your personal media library, the Raspberry Pi makes a great Plex server. It’s compact, quiet, affordable, and perfect for handling basic media streaming—especially for home use.

In this post, I’ll guide you through setting up Plex Media Server on a Raspberry Pi, using Raspberry Pi OS (Lite or Full) or Debian-based distros like Ubuntu Server.

What You’ll Need

• Raspberry Pi 4 or 5 (at least 2GB RAM, 4GB+ recommended)
• microSD card (32GB+), or SSD via USB 3.0
• External storage for media (USB HDD/SSD or NAS)
• Ethernet or Wi-Fi connection
• Raspberry Pi OS (Lite or Desktop)
• A Plex account (free is enough)

Step 1: Prepare the Raspberry Pi

1. Flash Raspberry Pi OS using Raspberry Pi Imager
2. Enable SSH and set hostname (optional)
3. Boot the Pi, log in, and update:

sudo apt update && sudo apt upgrade -y

Step 2: Install Plex Media Server

Plex is available for ARM-based devices via their official repository.

1. Add Plex repo and key:

curl https://downloads.plex.tv/plex-keys/PlexSign.key | sudo apt-key add -
echo deb https://downloads.plex.tv/repo/deb public main | sudo tee /etc/apt/sources.list.d/plexmediaserver.list
sudo apt update

2. Install Plex:

sudo apt install plexmediaserver -y

Step 3: Enable and Start the Service

Enable Plex on boot and start the service:

sudo systemctl enable plexmediaserver
sudo systemctl start plexmediaserver

Make sure it’s running:

sudo systemctl status plexmediaserver

Step 4: Access Plex Web Interface

Open your browser and go to:

http://<your-pi-ip>:32400/web

Log in with your Plex account and begin the setup wizard.

Step 5: Add Your Media Library

Plug in your external HDD or mount a network share, then:

sudo mkdir -p /mnt/media
sudo mount /dev/sda1 /mnt/media

Make sure Plex can access it:

sudo chown -R plex:plex /mnt/media

Add the media folder during the Plex setup under Library > Add Library.

Optional Tips

• Transcoding: The Pi can handle direct play (no transcoding) well, but struggles with transcoding large files. Use compatible formats like H.264 (MP4).
• USB Boot: For better performance, boot the Pi from an SSD instead of a microSD card.
• Power Supply: Use a proper 5V/3A PSU to avoid crashes under heavy disk load.
• Thermal: Add a heatsink or fan for the Pi if using Plex for long sessions.

Secure Your Server

• Use your router to forward port 32400 only if you want remote access.
• Set a strong Plex password.
• Enable Tailscale or WireGuard for secure remote access without exposing ports.

Conclusion

A Raspberry Pi might not replace a full-blown NAS or dedicated server, but for personal use or as a secondary Plex node, it’s surprisingly capable. With low energy usage and silent operation, it’s the perfect DIY home media solution.

If you’re running other services like Pi-hole or Home Assistant, the Pi can multitask well — just avoid overloading it with too much transcoding.

The post Building a Plex Media Server with Raspberry Pi appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

Docker has become the de facto standard for containerization on Linux systems. It provides developers with an easy and reproducible way to deploy applications. But if you’re a FreeBSD user like me, you’ve probably discovered that Docker isn’t natively supported. That’s because Docker relies heavily on Linux kernel features such as cgroups, namespaces, and UnionFS, which FreeBSD does not support directly.

So, what are our options? Can we still run containers on FreeBSD, or even Docker itself? The answer is yes—with some workarounds and native alternatives.

In this blog post, we will walk you through several approaches:

Why Docker Doesn’t Run Natively on FreeBSD

Docker was built specifically for the Linux kernel. It depends on:

• Linux control groups (cgroups)
• Namespaces
• AUFS/OverlayFS
• A running Docker daemon

FreeBSD uses different mechanisms, such as jails and ZFS. Because of this incompatibility, Docker can’t run on FreeBSD without a Linux layer. However, that doesn’t mean you’re out of luck.

Option 1: Use Podman – A Docker-Compatible Alternative

Podman is a daemonless container engine that offers a command-line interface similar to Docker. It’s available in FreeBSD’s package repository and works quite well for many use cases.

Installing Podman on FreeBSD

pkg install podman

Start the Podman service:

service podman start

Now you can use it just like Docker:

podman pull alpine
podman run -it alpine sh

Podman runs rootless containers, which means better security, but some Docker features like Docker Compose or privileged containers might not be fully supported.

Option 2: Run Docker Inside a Linux VM

If you absolutely need full Docker functionality, the best solution is to run Docker inside a virtual machine. You can do this using FreeBSD’s native hypervisor bhyve, or with VirtualBox.

A. Using bhyve and vm-bhyve

1. Install the required packages:

pkg install vm-bhyve grub2-bhyve

2. Initialize the environment:

zfs create -o mountpoint=/vm zroot/vm
vm init
vm switch create public

3. Download a Linux ISO (e.g., Ubuntu), and create the VM:

vm iso https://releases.ubuntu.com/22.04/ubuntu-22.04-live-server-amd64.iso
vm create ubuntuvm
vm install ubuntuvm ubuntu-22.04-live-server-amd64.iso

4. After installing Ubuntu, log into the VM and install Docker:

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

Now you have a full Linux environment running Docker within FreeBSD.

B. Using VirtualBox

If you prefer a GUI solution, VirtualBox works well on FreeBSD:

pkg install virtualbox-ose

After installation, create a Linux virtual machine (e.g., Ubuntu, Alpine), then install Docker inside it as shown above.

Option 3: Use FreeBSD Jails with BastilleBSD

FreeBSD has its own native containerization technology: jails. They are extremely lightweight and secure. You can manage jails easily with a tool like BastilleBSD.

Installing BastilleBSD

pkg install bastille
sysrc bastille_enable=YES
service bastille start

Bootstrap a FreeBSD Release

bastille bootstrap 13.2-RELEASE

Create and Start a Jail

bastille create myjail 13.2-RELEASE 10.0.0.10
bastille start myjail
bastille console myjail

Now you’re inside a FreeBSD jail where you can run isolated applications.

While this isn’t Docker-compatible, it’s extremely efficient and secure for server deployments.

Summary Table

Method	Docker-Compatible	FreeBSD Native	Ideal Use Case
Podman	Partial	Yes	Development, rootless containers
Linux VM (bhyve)	Full	No	Full Docker support, CI/CD setups
VirtualBox	Full	No	Desktop Docker environment
BastilleBSD	No	Yes	Secure, lightweight FreeBSD jails

Final Thoughts

While Docker doesn’t run natively on FreeBSD, you still have powerful and flexible options depending on your use case:

• Want to run containers like Docker? Try Podman.
• Need full Docker functionality? Use a Linux VM with bhyve or VirtualBox.
• Want lightweight, secure FreeBSD-native containers? Go with jails and BastilleBSD.

Each method has its strengths and trade-offs.

The post How to Use Docker on FreeBSD (and the Best Alternatives) appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

Are you looking to learn more about servers but don’t know where to start? Ubuntu Server provides the perfect foundation for beginners and experienced users alike. With its reliability, security features, and extensive community support, Ubuntu Server makes it easy to create useful projects that enhance your home network or provide valuable skills for your career.

In this guide, I’ll walk you through 10 practical projects that anyone can set up using Ubuntu Server. Each project requires minimal hardware and provides real-world benefits. Let’s get started!

1. Network-Attached Storage (NAS) Server

What it is: A centralized location to store and access your files from any device on your network.

Why Ubuntu Server is perfect: Ubuntu’s stability ensures your data remains safe, while its lightweight nature means even older hardware can serve as a reliable NAS.

Setup overview:

1. Install Ubuntu Server on your hardware
2. Install and configure Samba for file sharing:

sudo apt update
sudo apt install samba -y

3. Create a directory for your shared files:

sudo mkdir -p /media/nas
sudo chmod 777 /media/nas

4. Configure Samba by editing its configuration file:

sudo nano /etc/samba/smb.conf

5. Add the following at the end of the file:

[NASShare]
path = /media/nas
browseable = yes
read only = no
force create mode = 0660
force directory mode = 2770
valid users = @users

6. Set a Samba password for your user:

sudo smbpasswd -a yourusername

7. Restart Samba:

sudo systemctl restart smbd

Benefits: Access your files from any device, centralize your backups, and stream media throughout your home.

2. Personal Cloud Storage (NextCloud)

What it is: Your own personal cloud storage solution similar to Dropbox or Google Drive but hosted on your own hardware.

Why Ubuntu Server is perfect: Ubuntu’s package management makes installing dependencies straightforward, while LTS releases ensure long-term stability.

Setup overview:

1. Install LAMP stack:

sudo apt update
sudo apt install apache2 mariadb-server libapache2-mod-php php-gd php-json php-mysql php-curl php-mbstring php-intl php-imagick php-xml php-zip -y

2. Secure your MariaDB installation:

sudo mysql_secure_installation

3. Create a database:

sudo mysql -u root -p
CREATE DATABASE nextcloud;
CREATE USER 'nextclouduser'@'localhost' IDENTIFIED BY 'your_password';
GRANT ALL PRIVILEGES ON nextcloud.* TO 'nextclouduser'@'localhost';
FLUSH PRIVILEGES;
EXIT;

4. Download and install NextCloud:

cd /tmp
wget https://download.nextcloud.com/server/releases/latest.zip
unzip latest.zip
sudo mv nextcloud /var/www/html/
sudo chown -R www-data:www-data /var/www/html/nextcloud/

5. Configure Apache:

sudo nano /etc/apache2/sites-available/nextcloud.conf

6. Add the following configuration:

<VirtualHost *:80>
    DocumentRoot /var/www/html/nextcloud/
    ServerName your_domain_or_IP

    <Directory /var/www/html/nextcloud/>
        Options +FollowSymlinks
        AllowOverride All
        Require all granted
    </Directory>

    ErrorLog ${APACHE_LOG_DIR}/error.log
    CustomLog ${APACHE_LOG_DIR}/access.log combined
</VirtualHost>

7. Enable the site and required modules:

sudo a2ensite nextcloud.conf
sudo a2enmod rewrite headers env dir mime
sudo systemctl restart apache2

8. Access NextCloud through your browser at http://your_server_IP_or_domain and complete the setup wizard.

Benefits: Maintain control over your data, avoid subscription fees, and get unlimited storage based on your hardware.

3. Media Server with Plex

What it is: A powerful media server that organizes your movies, TV shows, music, and photos, making them accessible from anywhere.

Why Ubuntu Server is perfect: Ubuntu’s efficiency means more resources are available for transcoding media, and its compatibility with Plex is excellent.

Setup overview:

1. Add the Plex repository:

sudo apt update
sudo apt install apt-transport-https curl -y
curl https://downloads.plex.tv/plex-keys/PlexSign.key | sudo apt-key add -
echo deb https://downloads.plex.tv/repo/deb public main | sudo tee /etc/apt/sources.list.d/plexmediaserver.list

2. Install Plex Media Server:

sudo apt update
sudo apt install plexmediaserver -y

3. Create directories for your media:

sudo mkdir -p /opt/plexmedia/{movies,tv,music,photos}
sudo chown -R plex:plex /opt/plexmedia

4. Access the Plex web interface at http://your_server_IP:32400/web and follow the setup wizard
5. Add your media libraries pointing to the directories you created

Benefits: Stream your media collection to any device, automatic metadata fetching, and smart organization of your content.

4. Home Automation Server with Home Assistant

What it is: A central hub to control and automate your smart home devices.

Why Ubuntu Server is perfect: Ubuntu’s reliability ensures your home automation stays running, while its hardware compatibility supports various IoT devices.

Setup overview:

1. Install Docker (the easiest way to run Home Assistant):

sudo apt update
sudo apt install apt-transport-https ca-certificates curl software-properties-common -y
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"
sudo apt update
sudo apt install docker-ce -y

2. Install Docker Compose:

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

3. Create a Docker Compose file:

mkdir ~/homeassistant
cd ~/homeassistant
nano docker-compose.yml

4. Add the following content:

version: '3'
services:
  homeassistant:
    container_name: homeassistant
    image: ghcr.io/home-assistant/home-assistant:stable
    volumes:
      - ./config:/config
    environment:
      - TZ=YOUR_TIME_ZONE
    restart: always
    network_mode: host

5. Start Home Assistant:

sudo docker-compose up -d

6. Access Home Assistant through your browser at http://your_server_IP:8123

Benefits: Centralized control of all smart devices, powerful automation capabilities, and reduced dependence on cloud services.

5. Personal VPN Server with WireGuard

What it is: Your own VPN server that allows secure remote access to your home network and protects your privacy when using public Wi-Fi.

Why Ubuntu Server is perfect: Ubuntu’s security focus makes it ideal for VPN services, and recent kernels include built-in WireGuard support.

Setup overview:

1. Install WireGuard:

sudo apt update
sudo apt install wireguard -y

2. Generate private and public keys:

wg genkey | sudo tee /etc/wireguard/private.key
sudo chmod 600 /etc/wireguard/private.key
sudo cat /etc/wireguard/private.key | wg pubkey | sudo tee /etc/wireguard/public.key

3. Create a WireGuard configuration:

sudo nano /etc/wireguard/wg0.conf

4. Add the following (substituting your own values):

[Interface]
PrivateKey = YOUR_SERVER_PRIVATE_KEY
Address = 10.0.0.1/24
ListenPort = 51820
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

# Client configuration example
[Peer]
PublicKey = CLIENT_PUBLIC_KEY
AllowedIPs = 10.0.0.2/32

5. Enable IP forwarding:

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

6. Start and enable the WireGuard service:

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

7. Generate configurations for your clients and distribute them securely

Benefits: Secure remote access to your home network, enhanced privacy on public networks, and better control over your internet connection.

6. Web Server for Hosting Your Own Website

What it is: A server to host your personal website, blog, or web application.

Why Ubuntu Server is perfect: Ubuntu’s robust LAMP stack support makes it the go-to choice for web hosting environments.

Setup overview:

1. Install LAMP stack:

sudo apt update
sudo apt install apache2 mariadb-server php libapache2-mod-php php-mysql -y

2. Secure MariaDB:

sudo mysql_secure_installation

3. Create a website directory:

sudo mkdir -p /var/www/yourwebsite
sudo chown -R $USER:$USER /var/www/yourwebsite

4. Create a simple index.php file:

echo '<?php phpinfo(); ?>' > /var/www/yourwebsite/index.php

5. Configure Apache virtual host:

sudo nano /etc/apache2/sites-available/yourwebsite.conf

6. Add the following configuration:

<VirtualHost *:80>
    ServerName yourwebsite.local
    ServerAlias www.yourwebsite.local
    DocumentRoot /var/www/yourwebsite
    ErrorLog ${APACHE_LOG_DIR}/yourwebsite_error.log
    CustomLog ${APACHE_LOG_DIR}/yourwebsite_access.log combined
</VirtualHost>

7. Enable the site and restart Apache:

sudo a2ensite yourwebsite.conf
sudo systemctl restart apache2

Benefits: Full control over your web presence, no monthly hosting fees, and valuable skills for web development.

7. Pi-hole Ad Blocker

What it is: A network-wide ad blocker that improves browsing speed and privacy by blocking ads at the DNS level.

Why Ubuntu Server is perfect: Ubuntu’s efficiency means Pi-hole can run alongside other services without issues, making it a perfect addition to any home server.

Setup overview:

1. Install required packages:

sudo apt update
sudo apt install curl -y

2. Run the Pi-hole installer:

curl -sSL https://install.pi-hole.net | bash

3. Follow the on-screen instructions (accept most defaults)
4. Note your admin password at the end of installation
5. Configure your router to use your Ubuntu Server as the DNS server, or configure individual devices
6. Access the Pi-hole admin interface at http://your_server_IP/admin

Benefits: Faster browsing, reduced bandwidth usage, enhanced privacy, and protection from malicious domains.

8. Git Server with Gitea

What it is: A lightweight, self-hosted Git service similar to GitHub but running on your own hardware.

Why Ubuntu Server is perfect: Ubuntu’s package management and system resource efficiency make it ideal for hosting developer tools like Git services.

Setup overview:

1. Install required packages:

sudo apt update
sudo apt install git curl sqlite3 -y

2. Create a user for Gitea:

sudo adduser --system --group --disabled-password --shell /bin/bash --home /home/git git

3. Download and install Gitea:

VERSION=$(curl -s https://api.github.com/repos/go-gitea/gitea/releases/latest | grep tag_name | cut -d '"' -f 4)
sudo wget -O /tmp/gitea https://dl.gitea.io/gitea/${VERSION}/gitea-${VERSION}-linux-amd64
sudo chmod +x /tmp/gitea
sudo mv /tmp/gitea /usr/local/bin/gitea

4. Create required directories:

sudo mkdir -p /var/lib/gitea/{custom,data,log}
sudo chown -R git:git /var/lib/gitea
sudo chmod -R 750 /var/lib/gitea
sudo mkdir /etc/gitea
sudo chown root:git /etc/gitea
sudo chmod 770 /etc/gitea

5. Create a systemd service:

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

6. Add the following content:

[Unit]
Description=Gitea (Git with a cup of tea)
After=syslog.target
After=network.target

[Service]
RestartSec=2s
Type=simple
User=git
Group=git
WorkingDirectory=/var/lib/gitea
ExecStart=/usr/local/bin/gitea web --config /etc/gitea/app.ini
Restart=always
Environment=USER=git HOME=/home/git GITEA_WORK_DIR=/var/lib/gitea

[Install]
WantedBy=multi-user.target

7. Start and enable Gitea:

sudo systemctl daemon-reload
sudo systemctl enable --now gitea

8. Access Gitea through your browser at http://your_server_IP:3000 and complete the initial setup

Benefits: Full control over your code repositories, no limitations on private repositories, and integrated issue tracking.

9. Game Server Host

What it is: A dedicated server for hosting multiplayer games like Minecraft, Terraria, or Counter-Strike.

Why Ubuntu Server is perfect: Ubuntu’s stability and resource efficiency allow game servers to run smoothly and consistently, even on modest hardware.

Setup overview for Minecraft Server:

1. Install required packages:

sudo apt update
sudo apt install openjdk-17-jre-headless screen -y

2. Create a minecraft user:

sudo adduser --system --home /opt/minecraft-server minecraft
sudo addgroup --system minecraft
sudo adduser minecraft minecraft

3. Switch to the minecraft user:

sudo su - minecraft

4. Download the Minecraft server:

mkdir -p ~/server
cd ~/server
wget https://piston-data.mojang.com/v1/objects/8f3112a1049751cc472ec13e397eade5336ca7ae/server.jar -O minecraft_server.jar

5. Accept the EULA:

echo "eula=true" > eula.txt

6. Create a start script:

echo '#!/bin/sh
cd /opt/minecraft-server/server
java -Xmx2G -Xms1G -jar minecraft_server.jar nogui' > start.sh
chmod +x start.sh

7. Exit the minecraft user and create a systemd service:

exit
sudo nano /etc/systemd/system/minecraft.service

8. Add the following content:

[Unit]
Description=Minecraft Server
After=network.target

[Service]
User=minecraft
Nice=5
KillMode=none
SuccessExitStatus=0 1
InaccessibleDirectories=/root /sys /srv /media -/lost+found
NoNewPrivileges=true
WorkingDirectory=/opt/minecraft-server/server
ReadWriteDirectories=/opt/minecraft-server/server
ExecStart=/opt/minecraft-server/server/start.sh
ExecStop=/usr/bin/screen -p 0 -S minecraft -X eval 'stuff "say SERVER SHUTTING DOWN IN 10 SECONDS. SAVING ALL MAPS..."\015'
ExecStop=/bin/sleep 10
ExecStop=/usr/bin/screen -p 0 -S minecraft -X eval 'stuff "save-all"\015'
ExecStop=/usr/bin/screen -p 0 -S minecraft -X eval 'stuff "stop"\015'

[Install]
WantedBy=multi-user.target

9. Enable and start the service:

sudo systemctl enable minecraft.service
sudo systemctl start minecraft.service

Benefits: Host your favorite games with friends without subscription fees, customize server settings, and install mods freely.

10. Docker Host for Containerized Applications

What it is: A platform for running containerized applications, making it easy to deploy and manage various services.

Why Ubuntu Server is perfect: Ubuntu has excellent Docker support, regular updates, and a well-maintained Docker repository.

Setup overview:

1. Install Docker:

sudo apt update
sudo apt install apt-transport-https ca-certificates curl software-properties-common -y
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"
sudo apt update
sudo apt install docker-ce -y

2. Install Docker Compose:

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

3. Add your user to the Docker group (to avoid using sudo with Docker commands):

sudo usermod -aG docker $USER

4. Log out and back in for the changes to take effect
5. Test Docker:

docker run hello-world

6. Create a sample Docker Compose project:

mkdir ~/docker-test
cd ~/docker-test
nano docker-compose.yml

7. Add the following content for a simple web server:

version: '3'
services:
  web:
    image: nginx:latest
    ports:
      - "8080:80"
    volumes:
      - ./html:/usr/share/nginx/html
    restart: always

8. Create a test HTML file:

mkdir -p html
echo "<html><body><h1>My Docker Container is Working!</h1></body></html>" > html/index.html

9. Start the container:

docker-compose up -d

10. Access your test site at http://your_server_IP:8080

Benefits: Easily deploy complex applications, maintain isolated environments, and simplify updates and maintenance.

Why Ubuntu Server is the Perfect Choice

Throughout these projects, Ubuntu Server demonstrates its incredible versatility and power. Here’s why Ubuntu Server stands out from other options:

1. Stability: Ubuntu Server LTS releases are supported for 5 years, ensuring long-term reliability
2. Security: Regular security updates keep your server and data protected
3. Huge Community: Extensive documentation and community support make troubleshooting easy
4. Package Management: The APT package system simplifies software installation and updates
5. Resource Efficiency: Works well even on older or limited hardware
6. No License Fees: Completely free to use, even in commercial environments
7. Regular Updates: Stay current with the latest technologies and improvements

Getting Started with Ubuntu Server

Ready to begin? Here’s how to get started:

1. Download Ubuntu Server from ubuntu.com/download/server
2. Install it on your preferred hardware (old PC, Raspberry Pi, or virtual machine)
3. Choose one of the projects above and follow the step-by-step instructions
4. Join the Ubuntu community for support and to share your experiences

Remember, these projects are just the beginning. As you become more comfortable with Ubuntu Server, you’ll discover countless more possibilities for creating valuable services for your home or small business.

Have you built any interesting projects with Ubuntu Server? Share your experiences in the comments below!

This guide was created to help newcomers explore the capabilities of Ubuntu Server. For enterprise environments, consider Ubuntu’s commercial support options.

The post 10 Simple and Useful Projects Anyone Can Build with Ubuntu Server appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

Does your home or office internet feel sluggish, especially when multiple people are browsing? You might be surprised to learn that you can significantly improve your network’s performance by setting up a caching proxy server. In this guide, I’ll walk you through the process step-by-step.

What is a Caching Proxy Server?

A caching proxy server sits between your local network devices and the internet. It stores copies of resources (like web pages, images, and videos) that users request. When someone on your network visits a website that another user has already accessed, the proxy server delivers the cached content instead of downloading it again from the internet. This reduces bandwidth usage and improves loading times.

Benefits of Setting Up a Caching Proxy Server

• Faster browsing: Cached content loads much quicker than fresh downloads
• Reduced bandwidth consumption: The same content isn’t downloaded multiple times
• Lower latency: Local network access is always faster than internet requests
• Works for all devices: Benefits every device on your network without configuration
• Potential cost savings: If you have a metered connection, this reduces data usage

What You’ll Need

• A spare computer or Raspberry Pi (with at least 2GB RAM and 32GB storage)
• Basic networking knowledge
• 1-2 hours of setup time
• Squid proxy software (free and open-source)

Step 1: Choosing and Preparing Your Hardware

You don’t need powerful hardware for a home or small office caching proxy. A Raspberry Pi 4 works great for small networks (up to 10 devices), while a modest PC or old laptop can handle larger networks.

For this tutorial, I’ll use Ubuntu Server as the operating system, but you can use any Linux distribution.

1. Download Ubuntu Server from ubuntu.com/download/server
2. Install it on your device following the installation prompts
3. Make sure to set a static IP address during installation

Step 2: Installing Squid Proxy Server

Squid is the most popular caching proxy software. It’s powerful, reliable, and well-documented. Let’s install it:

1. Update your system:

sudo apt update
sudo apt upgrade -y

2. Install Squid:

sudo apt install squid -y

3. Verify the installation:

squid -v

This should display the Squid version information.

Step 3: Configuring Squid for Caching

The default Squid configuration works, but we need to optimize it for caching:

1. Back up the original configuration:

sudo cp /etc/squid/squid.conf /etc/squid/squid.conf.original

2. Edit the configuration file:

sudo nano /etc/squid/squid.conf

3. Find and modify these settings (or add them if not present):

# Define your local network
acl localnet src 192.168.1.0/24  # Change this to match your network

# Allow access from your local network
http_access allow localnet

# Cache settings
cache_mem 512 MB  # Adjust based on your server's RAM
maximum_object_size 50 MB  # Maximum size of objects to cache
cache_dir ufs /var/spool/squid 10000 16 256  # 10GB disk cache

# Refresh patterns for different content types
refresh_pattern ^ftp:           1440    20%     10080
refresh_pattern ^gopher:        1440    0%      1440
refresh_pattern -i (/cgi-bin/|\?) 0     0%      0
refresh_pattern \.(gif|png|jpg|jpeg|ico)$ 10080 90% 43200 override-expire ignore-no-cache ignore-no-store
refresh_pattern \.(css|js)$     10080   90%     43200 override-expire ignore-no-cache ignore-no-store
refresh_pattern .               0       20%     4320

4. Save and close the file (Ctrl+X, then Y, then Enter in nano)
5. Create the cache directory:

sudo mkdir -p /var/spool/squid
sudo chown proxy:proxy /var/spool/squid

6. Initialize the cache:

sudo squid -z

7. Restart Squid:

sudo systemctl restart squid

Step 4: Setting Up Your Network to Use the Proxy

There are two ways to implement the proxy on your network:

Option 1: Configure Each Device (Manual Method)

Configure each device to use your proxy server:

• Proxy Address: Your server’s IP address (e.g., 192.168.1.10)
• Port: 3128 (Squid’s default port)

This approach requires setting up each device individually but gives you more control.

Option 2: Configure Your Router (Transparent Proxy)

This method automatically routes all web traffic through your proxy:

1. Install additional packages:

sudo apt install iptables-persistent -y

2. Add these lines to squid.conf:

# Transparent proxy settings
http_port 3128 transparent

3. Set up IP forwarding:

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

4. Create IPTables rules:

sudo iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 80 -j REDIRECT --to-port 3128
sudo iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 443 -j REDIRECT --to-port 3128

5. Save the rules:

sudo netfilter-persistent save

6. On your router, set the default gateway to your proxy server’s IP address

Step 5: Testing and Monitoring

1. Test basic functionality by browsing from a device on your network
2. Monitor cache performance:

tail -f /var/log/squid/access.log

3. Check cache hit rate:

squidclient mgr:info | grep "Hit Rate"

Advanced Optimizations

After you have the basic setup working, consider these optimizations:

Increase Cache Size

If you have extra storage, increase the cache size:

cache_dir ufs /var/spool/squid 20000 16 256  # 20GB disk cache

Enable HTTPS Caching

Modern websites use HTTPS. To cache this content:

1. Install SSL tools:

sudo apt install openssl -y

2. Generate certificates:

sudo mkdir -p /etc/squid/ssl_cert
sudo openssl req -new -newkey rsa:2048 -sha256 -days 365 -nodes -x509 -keyout /etc/squid/ssl_cert/myproxy.pem -out /etc/squid/ssl_cert/myproxy.pem
sudo chown proxy:proxy /etc/squid/ssl_cert/myproxy.pem

3. Add to squid.conf:

# HTTPS caching
https_port 3129 cert=/etc/squid/ssl_cert/myproxy.pem ssl-bump intercept
acl SSL_port port 443
acl CONNECT method CONNECT
http_access allow CONNECT SSL_port localnet
ssl_bump server-first all
sslcrtd_program /usr/lib/squid/security_file_certgen -s /var/lib/ssl_db -M 4MB
sslcrtd_children 5

4. Create the SSL database:

sudo mkdir -p /var/lib/ssl_db
sudo chown -R proxy:proxy /var/lib/ssl_db

5. Restart Squid:

sudo systemctl restart squid

6. Install the generated certificate on your devices as a trusted CA

Troubleshooting Common Issues

1. Squid not starting: Check logs with sudo journalctl -u squid
2. Slow performance: Verify disk cache is working with ls -la /var/spool/squid/
3. Websites not loading: Ensure your network configuration is correct
4. HTTPS issues: Check certificate installation

Conclusion

Setting up a caching proxy server can significantly improve your network’s browsing experience. While the initial setup requires some technical knowledge, the long-term benefits are substantial. Your internet will feel faster, especially for frequently visited sites, and you’ll save bandwidth in the process.

Have you set up a caching proxy server? Share your experience in the comments below!

Disclaimer: This setup is intended for home or small office networks. For enterprise environments, consider professional solutions with support contracts.

The post How to Set Up a Caching Proxy Server to Speed Up Your Local Network appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

Maintaining multiple Ubuntu desktops in an office, school, or lab environment can become bandwidth-intensive if each machine downloads updates from the internet individually. A more efficient solution is to set up a local update server, which caches packages and distributes them to all local machines.

In this guide, we walk through how to set up a local Ubuntu package mirror using apt-cacher-ng, a lightweight and efficient caching proxy for Debian-based systems.

Prerequisites

• A dedicated Ubuntu server (or one of your desktops) that will act as the cache server.
• Internet access on the server.
• Static IP or reserved DHCP IP for the cache server.
• Ubuntu desktops configured to use the cache.

Step 1: Install apt-cacher-ng on the Server

sudo apt update
sudo apt install apt-cacher-ng

Once installed, the service starts automatically. You can check its status with:

sudo systemctl status apt-cacher-ng

Step 2: Configure apt-cacher-ng (Optional)

The default settings are usually fine for most use cases. But if you want to review or tweak the settings:

sudo nano /etc/apt-cacher-ng/acng.conf

Ensure this line is set (it usually is):

PassThroughPattern: .*ubuntu.com/.* 

To allow web access to the stats page, find and set:

ReportPage: acng-report.html

Then restart the service:

sudo systemctl restart apt-cacher-ng

Step 3: Allow Access Through Firewall (If Enabled)

If UFW is enabled:

sudo ufw allow 3142/tcp

Port 3142 is the default port used by apt-cacher-ng.

Step 4: Test the Server Locally

You can test the server by accessing this URL in a browser on another machine:

http://<cache-server-ip>:3142/acng-report.html

You should see the Apt-Cacher NG status page.

Step 5: Configure Ubuntu Clients

On each Ubuntu desktop, edit or create the file:

sudo nano /etc/apt/apt.conf.d/01proxy

Add this line (replace <cache-server-ip> with your server’s IP address):

Acquire::http::Proxy "http://<cache-server-ip>:3142";

Example:

Acquire::http::Proxy "http://192.168.1.10:3142";

Now, whenever you run:

sudo apt update && sudo apt upgrade

The desktop will fetch packages from your local cache server, downloading from the internet only if they’re not already cached.

Optional: Exclude Certain Packages or Repositories

You can fine-tune what gets cached in /etc/apt-cacher-ng/acng.conf. Look for directives like:

ExThreshold: 10

Or define blacklist patterns. See the man page for more advanced options:

man acng.conf

Monitor Usage

Check the cache statistics and logs via:

• Web UI: http://<cache-server-ip>:3142/acng-report.html
• Log file: /var/log/apt-cacher-ng/apt-cacher.log

Final Tips

• Regularly monitor disk space. Cache can grow over time.
• Use cron or logrotate to manage logs and old cached files.
• Works seamlessly for Ubuntu, Debian, and derivatives (Linux Mint, Pop!_OS).

Setting up a local update server is a smart move for environments with multiple machines. It reduces internet usage, speeds up updates, and improves reliability during high-traffic times. Once configured, it’s mostly maintenance-free.

The post How to Set Up a Local Update Server for Ubuntu Desktops appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

This guide shows you how to safely publish your internal website using Cloudflare Tunnel, hosted directly on your MikroTik router via Docker.

Scenario

Your router will run the Cloudflare Tunnel and forward requests securely to your internal PC running the web server.

Prerequisites

• MikroTik router with Docker support (e.g. RB5009, CCR2004, CHR)
• RouterOS 7.5+
• USB flash drive plugged into MikroTik (for container storage)
• Web server running at 192.168.0.10:80
• A Cloudflare account with your domain added (e.g. domain.com)

Step 1: Enable Docker on MikroTik

1. Install the container package:
   Get it from mikrotik.com/download under RouterOS v7 > Extra packages.
2. Reboot after installation.
3. Set Docker storage: /container config set root-dir=disk1/docker
4. Enable Docker: /container set enabled=yes

Step 2: Create Tunnel (on any PC)

Only needed once — you can delete the PC tunnel afterward.

1. Install Cloudflared: sudo apt install cloudflared
2. Authenticate: cloudflared tunnel login This opens a browser window. Log in and choose your domain.
3. Create a tunnel: cloudflared tunnel create webserver-tunnel This generates a .json credential file.
4. Create config file config.yml: tunnel: webserver-tunnel credentials-file: /cloudflared/webserver-tunnel.json ingress: - hostname: webserver.domain.com service: http://192.168.0.10:80 - service: http_status:404

Step 3: Transfer Files to MikroTik

Copy the following files to your MikroTik into /disk1/cloudflared/:

• webserver-tunnel.json
• config.yml

Use SCP or drag & drop via Winbox → Files.

Step 4: Run Cloudflared Docker Container on MikroTik

1. Add the container: /container add \ remote-image=cloudflare/cloudflared:latest \ name=cloudflared \ root-dir=disk1/cloudflared \ command="tunnel --config /etc/config.yml run"
2. Start it: /container start cloudflared

Step 5: Configure Cloudflare Dashboard (Zero Trust)

Now go to https://one.cloudflare.com and:

1. Navigate to Access → Tunnels.
2. Click your tunnel (webserver-tunnel).
3. Click “Add a public hostname”.
4. Fill in:
   • Subdomain: webserver
   • Domain: domain.com
   • Service: http://192.168.0.10:80
5. Click Save.

Now Cloudflare knows where to route incoming requests.

Done! Test It

Visit:

https://webserver.domain.com

Your site should load — even if you’re on mobile or outside your home network. All traffic is encrypted and proxied via Cloudflare, without any port forwarding.

Optional: Add Zero Trust Access Policy

Want to protect the site with a login?

1. In Cloudflare dashboard, go to:
   Access → Applications → Add Application
2. Choose Self-hosted.
3. Fill in:
   • App name: Web Server
   • URL: https://webserver.domain.com
4. Set who can access (e.g. emails, GitHub, etc.)

Now only authorized users can access your internal site.

Summary

Feature	Status
No port forwarding
Works behind NAT
Runs on MikroTik
Secure Cloudflare Tunnel
Access via domain

You’ve now turned your MikroTik router into a secure gateway for publishing internal services to the internet — the Cloudflare way.

The post Hosting a Web Server Securely with Cloudflare Zero Trust Tunnel on MikroTik (Using Docker) appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

Self-hosting applications has become increasingly popular among developers, tech enthusiasts, and homelabbers. However, securely exposing internal services to the internet is often a complicated task. It involves:

• Opening firewall ports
• Dealing with dynamic IPs
• Managing TLS certificates
• Handling reverse proxies
• Setting up access control

This is where DockFlare comes in.

DockFlare is a lightweight, self-hosted Cloudflare Tunnel automation tool for Docker users. It simplifies the process of publishing your internal Docker services to the public internet through Cloudflare Tunnels, while providing optional Zero Trust security, DNS record automation, and a sleek web interface for real-time management.

Objectives of DockFlare

DockFlare was created to solve three key problems:

1. Simplicity: Configure secure public access to your Docker containers using just labels—no reverse proxy, SSL setup, or manual DNS records needed.
2. Security: Protect your services behind Cloudflare’s Zero Trust Access, supporting identity-based authentication (Google, GitHub, OTP, and more).
3. Automation: Automatically create tunnels, subdomains, and security policies based on your Docker service metadata. No scripting. No re-deploys.

Why Use DockFlare?

Here’s how DockFlare benefits its users:

• Quick Setup: Set up secure tunnels and expose services in seconds with Docker labels.
• Zero Trust Security: Enforce authentication for any service using Cloudflare Access.
• No Public IP Required: No need to forward ports or expose your home IP—perfect for CG-NAT and mobile ISPs.
• Safe by Default: TLS encryption, no open ports, and access rules built-in.
• User-Friendly UI: Visualize tunnels, view logs, and manage configurations in a web dashboard.
• DevOps Ready: Works seamlessly in CI/CD pipelines or home labs.

How to Install DockFlare

Requirements

• Docker and Docker Compose
• A Cloudflare account
• A domain connected to Cloudflare
• A Cloudflare API Token with:
  • Zone DNS edit
  • Zero Trust policy management
  • Tunnel management

Step 1: Create Your Project Directory

mkdir dockflare && cd dockflare

Step 2: Create .env File

Create a file named .env with the following contents:

CLOUDFLARE_API_TOKEN=your_token_here
CLOUDFLARE_ACCOUNT_ID=your_account_id
CLOUDFLARE_ZONE_ID=your_zone_id
TZ=Asia/Kuala_Lumpur

Keep this file private!

Step 3: Create docker-compose.yml

version: '3.8'

services:
  dockflare:
    image: alplat/dockflare:stable
    container_name: dockflare
    restart: unless-stopped
    env_file:
      - .env
    ports:
      - "5000:5000"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock:ro
      - dockflare_data:/app/data
    labels:
      - cloudflare.tunnel.enable=true
      - cloudflare.tunnel.hostname=dockflare.yourdomain.com
      - cloudflare.tunnel.service=http://dockflare:5000

volumes:
  dockflare_data:

Step 4: Deploy DockFlare

docker compose up -d

Access the UI: http://localhost:5000

Exposing a Docker Service

Here’s an example of exposing a service like myapp running on port 8080:

services:
  myapp:
    image: myapp:latest
    labels:
      cloudflare.tunnel.enable: "true"
      cloudflare.tunnel.hostname: "app.yourdomain.com"
      cloudflare.tunnel.service: "http://myapp:8080"
      cloudflare.tunnel.access.policy: "authenticate"
      cloudflare.tunnel.access.allowed_idps: "your-idp-uuid"

This will automatically:

• Create a Cloudflare Tunnel
• Point your subdomain to it
• Enforce secure login

Add Non-Docker Services

Want to expose your home router or NAS?

1. Go to DockFlare UI.
2. Click “Add Hostname”.
3. Enter:
   • Hostname (e.g., nas.yourdomain.com)
   • Internal IP/port
   • Access policy (bypass/authenticate)
4. Done!

This works for any service, not just Docker.

Configuring Zero Trust Access

To secure your services:

• Go to Cloudflare Zero Trust dashboard
• Add an identity provider (Google, GitHub, etc.)
• Use the IDP UUID in your container labels
• Example:

cloudflare.tunnel.access.policy: authenticate
cloudflare.tunnel.access.allowed_idps: abc123-def456
cloudflare.tunnel.access.session_duration: 8h

Advanced Tips

• Expose multiple hostnames:
  cloudflare.tunnel.hostname=api.domain.com,admin.domain.com
• Customize session duration:
  cloudflare.tunnel.access.session_duration=12h
• Monitor logs via the web UI or docker logs dockflare

Resources

• GitHub: ChrispyBacon-dev/DockFlare
• Docker Compose Docs: docker.com/compose
• Cloudflare Tunnels Guide: developers.cloudflare.com

Conclusion

DockFlare is a game-changer for developers, sysadmins, and homelabbers who want an easy, secure, and automated way to expose their applications to the web. With support for Cloudflare Tunnels, Zero Trust Access, DNS automation, and a clean UI—it’s the only tool you’ll need to publish your services safely.

No more port forwarding. No more SSL headaches.

Just Docker + DockFlare + Cloudflare = Done.

The post DockFlare: Securely Expose Docker Services with Cloudflare Tunnels appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

In a local network where you want to keep your devices synchronized with accurate time, running a lightweight and efficient NTP server is essential. Chrony, a modern alternative to ntpd, is a great choice and in this guide, I’ll show you how to set it up inside a Docker container that fetches time from global sources and distributes it across your LAN.

Why Chrony?

Chrony is:

• More accurate than ntpd in many conditions (especially with intermittent connectivity)
• Lightweight and easy to configure
• Ideal for both clients and servers

What You’ll Set Up

• A Docker container running Chrony
• Configured to sync with global NTP servers
• Act as a time server for your LAN
• With optional logging and control access

Step 1: Create a Dockerfile for Chrony

Start by creating a simple Dockerfile to build a minimal Chrony container.

# Dockerfile
FROM debian:stable-slim

RUN apt-get update && \
    apt-get install -y chrony && \
    apt-get clean && \
    rm -rf /var/lib/apt/lists/*

COPY chrony.conf /etc/chrony/chrony.conf

EXPOSE 123/udp

CMD ["chronyd", "-d", "-f", "/etc/chrony/chrony.conf"]

Step 2: Create the chrony.conf

Here’s a sample chrony.conf tailored for local server use and syncing with global time sources:

# chrony.conf

# Time sources (use pool.ntp.org or your regional servers)
server 0.pool.ntp.org iburst
server 1.pool.ntp.org iburst
server 2.pool.ntp.org iburst

# Allow all clients on your LAN (edit this according to your subnet)
allow 192.168.1.0/24

# Local stratum fallback if Internet is down
local stratum 10

# Drift file to track clock error over time
driftfile /var/lib/chrony/chrony.drift

# Log tracking data
log tracking measurements statistics

# Log files location
logdir /var/log/chrony

# Optional: control access
cmdport 0  # Use 0 to disable remote control; use 323 if needed

Replace 192.168.1.0/24 with your actual LAN subnet.

Step 3: Build and Run the Docker Container

docker build -t chrony-server .

Now run the container with:

docker run -d \
  --name chrony \
  --restart unless-stopped \
  --network host \
  --cap-add=NET_BIND_SERVICE \
  chrony-server

Explanation:

• --network host allows the container to bind directly to port 123/UDP
• --cap-add=NET_BIND_SERVICE is required to bind to low-numbered ports like 123

Step 4: Test Your NTP Server

From a client machine on your LAN:

ntpdate -q <chrony-server-ip>

or

chronyc sources -a

You should see that the time is being served and synchronized.

Optional: Run as a Local Time Authority

If you want to run fully offline, or ensure internal time continuity even without internet:

1. Remove the server lines from chrony.conf
2. Set: local stratum 8
3. Start the server with a stable internal clock source

This makes your Chrony instance a local time authority for your network.

Firewall Notes

Make sure UDP port 123 is allowed inbound from your LAN on your Docker host:

sudo ufw allow proto udp from 192.168.1.0/24 to any port 123

Or for iptables:

iptables -A INPUT -p udp -s 192.168.1.0/24 --dport 123 -j ACCEPT

Conclusion

With this setup, you’ve created a portable, containerized NTP server using Chrony that:

• Syncs with global servers
• Serves accurate time to all local devices
• Works even if your external internet connection drops

Perfect for homelabs, IoT networks, or offline environments.

The post How to Set Up Chrony as a Local NTP Server Using Docker appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

Before container technologies like Docker came into play, applications were typically run directly on the host operating system—either on bare metal hardware or inside virtual machines (VMs). While this method works, it often leads to frustrating issues, especially when trying to reproduce setups across different environments.

This becomes even more relevant in the amateur radio world, where we often experiment with digital tools, servers, logging software, APRS gateways, SDR applications, and more. Having a consistent and lightweight deployment method is key when tinkering with limited hardware like Raspberry Pi, small form factor PCs, or cloud VPS systems.

The Problem with Traditional Software Deployment

Let’s say you’ve set up an APRS iGate, or maybe you’re experimenting with WSJT-X for FT8, and everything runs flawlessly on your laptop. But the moment you try deploying the same setup on a Raspberry Pi or a remote server—suddenly things break.

Why?

Common culprits include:

• Different versions of the operating system
• Mismatched library versions
• Varying configurations
• Conflicting dependencies

These issues can be particularly painful in amateur radio projects, where specific software dependencies are critical, and stability matters for long-term operation.

You could solve this by running each setup inside a virtual machine, but VMs are often overkill—especially for ham radio gear with limited resources.

Enter Docker: The Ham’s Best Friend for Lightweight Deployment

Docker is an open-source platform that allows you to package applications along with everything they need—libraries, configurations, runtimes—into one neat, portable unit called a container.

Think of it like packaging up your entire ham radio setup (SDR software, packet tools, logging apps, etc.) into a container, then being able to deploy that same exact setup on:

• A Raspberry Pi
• A cloud server
• A homelab NUC
• Another ham’s machine

Why It’s Great for Hams:

• Lightweight – great for Raspberry Pi or low-power servers
• Fast startup – ideal for services that need to restart quickly
• Reproducible environments – makes sharing setups with fellow hams easier
• Isolation – keeps different radio tools from interfering with each other

Many amateur radio tools like Direwolf, Xastir, Pat (Winlink), and even JS8Call can be containerized, making experimentation safer and more efficient.

Virtual Machines: Still Relevant in the Shack

Virtual Machines (VMs) have been around much longer and still play a crucial role. Each VM acts like a complete computer, with its own OS and kernel, running on a hypervisor like:

• VirtualBox
• VMware
• KVM
• Hyper-V

With VMs, you can spin up an entire Windows or Linux machine, perfect for:

• Running legacy ham radio software (e.g., old Windows-only apps)
• Simulating different operating systems for testing
• Isolating potentially unstable setups from your main system

However, VMs require more horsepower. They’re heavy, boot slowly, and take up more disk space—often not ideal for small ham radio PCs or low-powered nodes deployed in the field.

Quick Comparison: Docker vs Virtual Machines for Hams

Ham Radio Use Cases for Docker

Here’s how Docker fits into amateur radio workflows:

• Run an APRS iGate with Direwolf and YAAC in isolated containers.
• Deploy SDR receivers like rtl_433, OpenWebRX, or CubicSDR as containerized services.
• Set up a Winlink gateway using Pat + ax25 tools, all in one container.
• Automate and scale your APRS bot, or APRS gateway using Docker + cron + scripts.

Docker makes it easier to test and share these setups with other hams—just export your Docker Compose file or image.

When to Use Docker, When to Use a VM

Use Docker if:

• You’re building or experimenting with modern ham radio apps
• You want to deploy quickly and repeatably
• You’re using Raspberry Pi, VPS, or low-power hardware
• You’re setting up CI/CD pipelines for your scripts or bots

Use VMs if:

• You need to run legacy apps (e.g., old Windows logging software)
• You want to simulate full system environments
• You’re working on something that could crash your main system

Final Thoughts

Both Docker and VMs are powerful tools that have a place in the modern ham shack. Docker offers speed, portability, and resource-efficiency—making it ideal for deploying SDR setups, APRS bots, or automation scripts. VMs, on the other hand, still shine when you need full system emulation or deeper isolation.

At the end of the day, being a ham means being an experimenter. And tools like Docker just give us more ways to explore, automate, and share our radio projects with the world.

The post Docker vs Virtual Machines: What Every Ham Should Know appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.