Virtualization has always been a powerful way to run multiple operating systems on a single machine. But what if you could spin up a fully functional Windows installation inside a Docker container, just as easily as you deploy a Linux service? That’s exactly what Dockur/Windows delivers — and it’s one of the most exciting projects for developers, system admins, and tech enthusiasts in 2025.

What Is Dockur/Windows?

Dockur/Windows is an open-source project that lets you run Windows operating systems inside Docker containers. With over 37,000 GitHub stars and thousands of forks, it has become one of the most popular ways to experiment with Windows virtualization without needing heavy hypervisor setups.

It combines KVM acceleration, automatic ISO downloads, and a web-based viewer, making it incredibly simple to get Windows up and running on your host.

In just a few minutes, you can deploy Windows 11, Windows 10, or even classics like Windows XP or Server 2003.

Key Features

• Automatic ISO Downloader – no hunting for Windows ISOs; the container does it for you.
• KVM Acceleration – blazing-fast virtualization on supported hardware.
• Web-Based Viewer – access installation and desktop directly via your browser on port 8006.
• Full Customization – control CPU, RAM, storage, language, keyboard layout, editions, and more.
• File Sharing – bind mount host folders to access them from inside Windows.
• RDP Support – connect via Microsoft Remote Desktop for better performance.
• Wide OS Support – from Windows 11 Pro to legacy XP, Vista, and Windows 2000.
• Legal & Open-Source – no pirated ISOs; it only uses official Microsoft trial ISOs.

How Easy Is It to Use?

Running Windows inside Docker has never been simpler. Here’s an example with Docker Compose:

services:
  windows:
    image: dockurr/windows
    container_name: windows
    environment:
      VERSION: "11"
      RAM_SIZE: "8G"
      CPU_CORES: "4"
      DISK_SIZE: "128G"
    devices:
      - /dev/kvm
      - /dev/net/tun
    cap_add:
      - NET_ADMIN
    ports:
      - 8006:8006
      - 3389:3389/tcp
      - 3389:3389/udp
    volumes:
      - ./windows:/storage
    restart: always

After launching, simply visit http://localhost:8006 in your browser, watch the automated installation, and within minutes you’ll be greeted with a fully working Windows desktop.

Supported Versions

Dockur/Windows supports a wide range of editions, including:

• Windows 11 Pro / LTSC / Enterprise
• Windows 10 Pro / LTSC / Enterprise
• Windows 8.1 Enterprise
• Windows 7 Ultimate
• Windows XP Professional
• Windows 2000 Professional
• Windows Server editions (2003–2025)

You can even use custom ISOs by specifying a URL or mounting a local .iso file.

Why Is This Important?

Traditionally, running Windows required dedicated VMs via VirtualBox, VMware, or Hyper-V. These solutions are resource-heavy and less portable.

With Dockur/Windows, you get:

• Lightweight deployment – run anywhere Docker runs.
• Infrastructure-as-code – reproducible Windows environments defined in YAML.
• Portability – move your Windows environment between servers easily.
• Integration – combine Windows containers with Linux microservices seamlessly.

Use Cases

• Software Testing – instantly spin up legacy Windows builds for QA.
• Retro Gaming – bring back Windows XP or 7 environments for classic games.
• CI/CD Pipelines – test Windows applications in automated workflows.
• Learning & Training – safe sandbox for students and professionals.
• Server Labs – deploy Windows Server editions alongside Linux services.

Final Thoughts

Dockur/Windows is a game-changer for developers and IT enthusiasts. It transforms Windows from a heavyweight virtual machine into a Dockerized, portable, and scriptable service.

If you’ve ever dreamed of running Windows inside Docker with minimal setup, this project is for you.

Check it out here: Dockur/Windows on GitHub

The post Run Windows Inside Docker Like Magic: A Look at Dockur/Windows appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

In the fast-evolving world of software containers, two titans stand at the forefront: Docker and Podman. Both tools aim to simplify container management, but they differ significantly in design, architecture, security, and philosophy. If you’re a developer, sysadmin, or DevOps enthusiast, choosing the right tool could impact your workflows, security posture, and deployment pipelines.

Let’s dive deep into the real, factual differences between Docker and Podman—no fluff, just facts.

What Are Docker and Podman?

Docker

Released in 2013, Docker revolutionized how developers package and ship applications. It introduced a high-level, developer-friendly interface for containerizing applications and quickly became the standard in CI/CD pipelines and cloud-native development.

• Architecture: Daemon-based (dockerd)
• License: Apache 2.0 (Engine), Docker Desktop (commercial license for enterprises)
• Adoption: Widely used in enterprises and supported across all major cloud providers

Podman

Podman (short for Pod Manager) emerged from the Red Hat ecosystem in 2018 as a modern, daemonless, rootless, and Kubernetes-native alternative to Docker. It’s a drop-in replacement for many Docker CLI commands but with a twist: better security and system integration.

• Architecture: Daemonless, fork/exec model
• License: Apache 2.0
• Endorsed by: Red Hat, Fedora, and used in OpenShift

Architecture: Daemon vs Daemonless

Docker

Docker uses a centralized daemon (dockerd) that listens for commands from the Docker CLI. All containers run as subprocesses of this daemon, which must be started and kept running in the background.

• Pros: Easier to manage containers centrally
• Cons: If the daemon crashes, all containers go down. Also, the daemon typically runs with root privileges, a security concern in multi-tenant environments.

Podman

Podman is daemonless. Each container is a direct child process of the Podman CLI, eliminating the single point of failure and reducing complexity.

• Pros: More secure, no need for a background service
• Cons: Slightly more complex to manage container orchestration manually (but easily fixed with systemd)

Security: Rootless by Default

Docker

Docker runs the daemon as root by default. While Docker introduced a rootless mode, it’s not the standard, and setting it up requires additional configuration.

This model has led to security breaches in containerized environments when untrusted containers were exploited to escalate privileges.

Podman

Podman was built with security first. It runs containers as the current user, even allowing completely rootless containers with no special setup. This significantly reduces the attack surface and aligns better with multi-user Linux environments.

Rootless Podman containers can’t access host kernel features they shouldn’t, which is excellent for sandboxing.

Compatibility and CLI

One of Podman’s biggest strengths is its Docker CLI compatibility.

docker run -it alpine sh
# is identical to
podman run -it alpine sh

• Podman supports nearly all Docker CLI commands.
• Even podman-compose (a replacement for docker-compose) is available.
• Transitioning from Docker to Podman is usually as simple as replacing the word “docker” with “podman.”

Systemd Integration

Podman integrates directly with systemd, allowing you to manage containers as system services without writing complex unit files manually.

podman generate systemd --name myapp > ~/.config/systemd/user/myapp.service

With this, containers can:

• Auto-start on boot
• Restart on failure
• Be managed like native Linux services

Docker can do this too—but only with extra configuration or third-party wrappers.

Pod Support: Kubernetes-Ready

Docker

• No native support for pods
• Multi-container apps must be managed with Docker Compose

Podman

• Supports pods natively, just like Kubernetes
• You can run multiple containers sharing the same network and IPC namespace—perfect for mimicking Kubernetes locally

podman pod create --name webpod
podman run --pod webpod nginx
podman run --pod webpod redis

You’re essentially spinning up a Kubernetes-like environment on your laptop.

Performance

• Startup Speed: Podman starts containers slightly faster, especially in rootless mode, since there’s no daemon overhead.
• System Resources: Podman consumes fewer resources due to its daemonless architecture.
• Stability: If Docker’s daemon fails, all containers die. Podman avoids this problem.

Tooling and Ecosystem

Docker

• Has a mature, vast ecosystem
• Seamless integration with CI/CD tools, IDEs, and Kubernetes
• Rich GUI with Docker Desktop

Podman

• Lighter, CLI-focused tooling
• Supported by Buildah (for building images), Skopeo (for image management), and Podman Compose
• No official GUI, but Cockpit and third-party tools exist

Licensing

When to Use What?

Choose Docker if:

You’re working in a team already standardized on Docker
You need Docker Desktop’s GUI or Compose integration
You rely on third-party tools that only support Docker

Choose Podman if:

You prioritize security and want rootless containers
You want systemd integration for persistent services
You’re running on Red Hat, Fedora, or Debian-based servers
You want better Kubernetes alignment with pods

Final Verdict

Feature	Docker	Podman
Daemon	Required	Not required
Rootless	Optional	Default
Pod Support
systemd Integration	Limited	Native
Kubernetes Alignment	Moderate	High
GUI Tools	(Docker Desktop)	(CLI-centric)
Licensing for Desktop	Paid for some	Fully open source

Bottom line: Podman is a modern, security-focused, daemonless alternative to Docker. It’s perfect for developers and sysadmins who want Kubernetes-native behaviors and rootless containerization. Docker, however, remains unmatched in terms of ecosystem maturity and toolchain support.

Sources

• Red Hat Developer
• Podman Official Docs
• Docker Docs
• Spacelift Blog
• Last9 Engineering
• BetterStack Guides

The post Docker vs Podman: The Showdown in Containerization appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

If you’re like many amateur radio operators, you’ve probably tinkered with APRS (Automatic Packet Reporting System) at some point. It’s a brilliant way to track stations, weather reports, messages, and more over the air. But most of the software out there is either old, clunky, or designed primarily for Windows.

That’s where APRS TNC Web comes in.

What Is APRS TNC Web?

APRS TNC Web is a lightweight, Docker-powered web application that gives you a clean, modern interface to interact with your APRS traffic using any KISS-compatible TNC (Terminal Node Controller). Whether you’re on a Raspberry Pi, a server in your shack, or just your laptop, this tool makes APRS monitoring and messaging effortless.

Why Was This Built?

The motivation is simple: a lot of us want to keep track of local APRS traffic or send a quick message—but without booting up a heavy GUI or running Windows-only software like APRSIS32. Damian (SQ2CPA) created this project with usability in mind, and it shows.

Features at a Glance

• Connects to any KISS TNC over TCP/IP
• Human-readable decoding of APRS frames
• Raw frame display for deeper analysis
• Send and receive APRS messages from your browser
• Fully Dockerized: Runs with a single command
• Cross-platform: Access from any device on your LAN

Quick Setup (Yes, Really!)

If you have Docker installed, you’re already halfway there.

1. Clone the repo or create a project folder
2. Copy the example .env and docker-compose.yaml into the directory
3. Customize your .env file (port, DB settings, TNC host/port)
4. Run:

docker compose up -d

That’s it. Visit http://<your-device-ip>:8000 and you’re live.

What You’ll See

Once it’s running, APRS TNC Web gives you a real-time view of decoded APRS packets. Frames appear instantly in a sleek interface, with options to toggle raw views and message interfaces.

You can go to Settings to configure your callsign, SSID, and KISS device IP. After that, you’re ready to send and receive APRS messages directly through your TNC.

What’s Missing (For Now)

The current release is focused and stable—but intentionally lean. Some advanced features like:

• Object or item beaconing
• Real-time maps
• Advanced filtering or analytics

…are not yet included, but may come in future versions. If you’re a dev with an itch to scratch, contributions are very welcome!

Final Thoughts

As an active ham, I found this tool refreshing. It strips APRS down to its essentials without losing the things we actually use. It’s also ideal for club deployments or APRS field kits, where simplicity and reliability matter.

If you’re tired of fighting with outdated interfaces or installing bloated software just to decode a few packets, give APRS TNC Web a try.

Project repo: github.com/SQ2CPA/aprs-tnc-web
Author: Damian, SQ2CPA
License: MIT

The post APRS TNC Web – A Simple, Modern Interface for Your KISS TNC appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

Managing your kitchen just got a lot easier! KitchenOwl is a modern, open-source, self-hosted solution for handling grocery lists, recipes, meal planning, and even tracking household expenses — all from one sleek and user-friendly interface. Whether you’re managing meals for yourself or your entire family, KitchenOwl gives you full control with privacy and collaboration at its core.

Key Features

• Grocery List Manager
  Categorized grocery lists with icons and quantities help you shop faster and smarter.
• Recipe Organizer
  Save, edit, and categorize your favorite recipes. You can even add ingredients from a recipe directly into your grocery list.
• Meal Planning
  Plan meals for the week with ease and link recipes to your calendar for a smoother kitchen workflow.
• Expense Tracker
  Track how much you spend on groceries and view expenses per shopping trip.
• Multi-User Support
  Perfect for households — everyone can share access to lists, plans, and recipes in real time.
• Cross-Platform Access
  Use it on any web browser or mobile device. KitchenOwl supports Android, iOS (via TestFlight), and has a web interface for desktops.

How to Self-Host KitchenOwl Using Docker

Hosting KitchenOwl on your own server or VPS gives you full control over your data. Here’s how to do it in just a few steps:

Prerequisites

• A Linux server (can be local or cloud-hosted)
• Docker & Docker Compose installed
• Basic terminal knowledge

Step 1: Create Docker Compose File

Create a new file called docker-compose.yml:

version: "3"
services:
  front:
    image: tombursch/kitchenowl-web:latest
    restart: unless-stopped
    ports:
      - "80:80"
    depends_on:
      - back
  back:
    image: tombursch/kitchenowl-backend:latest
    restart: unless-stopped
    environment:
      - JWT_SECRET_KEY=PLEASE_CHANGE_ME
    volumes:
      - kitchenowl_data:/data

volumes:
  kitchenowl_data:

Important: Replace PLEASE_CHANGE_ME with a secure, random string to act as your JWT secret key.

Step 2: Start the Service

Run the following command in your terminal where the file is located:

docker-compose up -d

This will download the necessary images and start KitchenOwl as a background service.

Step 3: Open in Browser

After setup is complete, visit:

http://localhost

If you’re using a remote server, replace localhost with your server’s IP address or domain name.

Access Anywhere

KitchenOwl is cross-platform:

• Web: Use it in any modern browser
• Android: Available via Google Play and F-Droid
• iOS: Access through Apple TestFlight
• Desktop: Use the browser or wrap in Electron for a native feel

Why Self-Host?

Self-hosting KitchenOwl ensures that your personal data stays private, free from third-party tracking or restrictions. With multi-user support, it’s perfect for families or shared homes.

• Own your data
• Customize it to your needs
• No subscription fees
• Access anytime, anywhere

Final Thoughts

KitchenOwl is more than just a grocery app — it’s a full-featured kitchen assistant designed with privacy, usability, and flexibility in mind. Whether you’re a techie who loves Docker or someone just looking to simplify kitchen life, KitchenOwl is a brilliant tool to have.

The post KitchenOwl: Your Self-Hosted Grocery List and Recipe Manager appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

Keeping track of IT assets can quickly become overwhelming—especially when you’re dealing with laptops, monitors, licenses, accessories, consumables, and more. That’s where Snipe-IT shines. Designed with IT teams in mind, Snipe-IT helps you efficiently manage all your assets in one central dashboard—whether you’re an SME, enterprise, educational institution, or a non-profit.

This guide introduces Snipe-IT and walks you through installing it on your own server, turning your team into asset management pros in no time.

Why Choose Snipe-IT?

Snipe-IT is more than just a spreadsheet replacement. It’s a full-featured, web-based, and open-source asset management system. Some standout features:

• Free and Open Source: Host it yourself and customize as needed.
• Modern UI: Clean interface with a responsive layout.
• Asset Assignment: Assign devices to users and track histories.
• License Management: Keep tabs on software expiration dates.
• Consumables & Accessories: Track cables, keyboards, and other smaller items.
• Multi-language support: Over 55 languages supported.
• REST API: Integrate with your existing tools and automation.
• LDAP/AD support: Easy user syncing.

Tutorial: How to Self-Host Snipe-IT on a Linux Server

Let’s walk through how to set up Snipe-IT on your own server using Docker Compose. This method is easy to maintain and works great on Debian, Ubuntu, or CentOS.

Step 1: Install Docker and Docker Compose

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

Enable Docker at startup:

sudo systemctl enable docker

Step 2: Create a Docker Compose File

Make a folder for Snipe-IT:

mkdir ~/snipeit && cd ~/snipeit

Then create a docker-compose.yml:

# Compose file for production.

volumes:
  db_data:
  storage:

services:
  app:
    image: snipe/snipe-it:${APP_VERSION:-latest}
    restart: unless-stopped
    volumes:
      - storage:/var/lib/snipeit
    ports:
      - "${APP_PORT:-8000}:80"
    depends_on:
      db:
        condition: service_healthy
        restart: true
    env_file:
      - .env

  db:
    image: mariadb:11.4.7
    restart: unless-stopped
    volumes:
      - db_data:/var/lib/mysql
    environment:
      MYSQL_DATABASE: ${DB_DATABASE}
      MYSQL_USER: ${DB_USERNAME}
      MYSQL_PASSWORD: ${DB_PASSWORD}
      MYSQL_ROOT_PASSWORD: ${MYSQL_ROOT_PASSWORD}
    healthcheck:
      # https://mariadb.com/kb/en/using-healthcheck-sh/#compose-file-example
      test: ["CMD", "healthcheck.sh", "--connect", "--innodb_initialized"]
      interval: 5s
      timeout: 1s
      retries: 5

Step 3: Launch Snipe-IT

Start the containers:

docker-compose up -d

Then, access Snipe-IT via your browser:

http://your-server-ip:8000

Follow the setup wizard to configure admin user and organization info.

Post-Installation Tips

• Set up categories for your equipment (e.g. laptops, desktops, printers).
• Create user accounts or import from LDAP/Active Directory.
• Assign assets with status updates, warranty info, and custom notes.
• Enable email notifications for expiring warranties or licenses.

Who Should Use Snipe-IT?

• Startups: Manage growing teams and hardware efficiently.
• Schools & Universities: Keep track of laptops issued to students.
• Non-Profits: Manage donated equipment and reduce waste.
• IT Departments: Maintain audit trails and simplify inventory checks.

Bonus: Cloud-Hosted Option

Don’t want to manage your own server? The official team offers affordable cloud-hosted Snipe-IT plans. It’s perfect if you want to hit the ground running without worrying about backend maintenance.

Visit the official site to sign up: https://snipeitapp.com

Extend Snipe-IT with the API

Snipe-IT’s RESTful API allows developers to:

• Automate new asset creation
• Sync users from HR tools
• Generate reports and dashboards
• Connect with other IT systems

With powerful integrations, Snipe-IT becomes a central piece of your IT toolkit.

Secure & Compliant

Snipe-IT supports:

• Two-factor authentication (2FA)
• HTTPS
• Secure password hashing (bcrypt)
• User audit trails

This ensures your asset data is protected and audit-ready.

Final Thoughts

Snipe-IT is a powerhouse for IT asset management, giving you full control and visibility over your hardware and software landscape. Whether you’re looking to declutter your tech life or streamline an enterprise setup, Snipe-IT is the tool to do it—clean, reliable, and absolutely yours.

The post Master Your IT Inventory with Snipe-IT: A Powerful, Open-Source Asset Management System appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

In today’s fast-paced digital landscape, efficient time management is crucial for productivity and profitability. Enter Kimai, an open-source, web-based time-tracking application designed to cater to freelancers, small businesses, and large enterprises alike. Whether you’re a solo developer or managing a team, Kimai offers a robust solution to track work hours, manage projects, and generate insightful reports—all from a user-friendly interface.

Why Choose Kimai?

1. Versatility Across Industries

Kimai isn’t just for developers; it’s a versatile tool that adapts to various industries. From consulting firms to creative agencies, Kimai’s flexible structure allows for customized workflows, making it a go-to solution for diverse professional needs.

2. Open-Source Freedom

Being open-source means you have the freedom to customize Kimai to fit your specific requirements. With a vibrant community contributing to its development, Kimai continuously evolves, ensuring it stays aligned with user needs and technological advancements.

3. Self-Hosting Capabilities

For those who prioritize data privacy and control, Kimai offers self-hosting options. This feature is particularly beneficial for organizations with strict data compliance requirements, allowing them to maintain complete control over their time-tracking data.

Key Features

1. Intuitive Time Tracking

Kimai simplifies the process of tracking work hours. With its user-friendly interface, you can start and stop timers with ease, assign time entries to specific projects or clients, and add detailed notes for clarity.

2. Comprehensive Reporting

Generate detailed reports to analyze productivity, project progress, and resource allocation. Kimai’s reporting tools help you make informed decisions and optimize workflows.

3. Invoicing and Expense Management

Streamline your billing process with Kimai’s invoicing features. Create customizable invoices based on tracked time and expenses, ensuring accurate and timely billing for your clients.

4. Multi-User and Role Management

Kimai supports multiple users with customizable roles and permissions. This feature is essential for teams, allowing administrators to control access levels and maintain data integrity.

5. Plugin Support and API Integration

Extend Kimai’s functionality with a variety of plugins or integrate it with other tools using its robust API. This flexibility ensures that Kimai can adapt to your existing tech stack and workflows.

Mobile Accessibility

Kimai’s responsive design ensures that you can track time on-the-go from any device, be it a smartphone, tablet, or desktop. This mobility ensures that your time tracking is uninterrupted, regardless of where you are.

Security and Compliance

Security is a top priority for Kimai. With features like two-factor authentication, audit logs, and compliance with data protection regulations, you can trust that your data is secure and handled responsibly.

Getting Started with Kimai

1. Installation

Kimai offers straightforward installation processes for both self-hosted and cloud-based setups. Comprehensive documentation guides you through each step, ensuring a smooth setup experience.

2. Customization

Tailor Kimai to your needs by configuring settings, installing plugins, and integrating with other tools. Whether you need specific reporting formats or unique workflows, Kimai’s flexibility has you covered.

3. Community Support

Join Kimai’s active community forums to seek assistance, share experiences, and contribute to the platform’s growth. The collaborative environment ensures that help is always available when needed.

Use Cases

• Freelancers: Track billable hours, manage multiple clients, and generate invoices with ease.
• Agencies: Monitor team productivity, allocate resources efficiently, and maintain transparent client billing.
• Enterprises: Implement organization-wide time tracking, integrate with existing systems, and ensure compliance with internal policies.

Conclusion

Kimai stands out as a powerful, flexible, and user-friendly time-tracking solution. Its open-source nature, combined with a rich feature set and active community, makes it an excellent choice for individuals and organizations aiming to optimize their time management processes.

The post Kimai: The Open-Source Time Tracking Powerhouse for Freelancers and Teams appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

What Is code-server?

code-server is an open-source project developed by Coder that allows you to run VS Code on a remote server and access it through a web browser. This setup provides a consistent development environment that can be accessed from any device, be it a laptop, tablet, or even a smartphone. By leveraging the power of cloud servers, code-server enables faster tests, compilations, and downloads, all while preserving your local device’s resources.

Key Features of code-server

• VS Code in the Browser: Experience the full functionality of VS Code, including IntelliSense, debugging, and Git integration, all within your browser.
• Remote Development: Develop on powerful cloud servers, reducing the load on your local machine and enabling resource-intensive tasks.
• Consistent Environment: Maintain a uniform development setup across different devices, ensuring consistency and reducing the “it works on my machine” problem.
• Extension Support: Install and use most VS Code extensions, enhancing your development workflow.
• Secure Access: Access your development environment securely from anywhere, with options for HTTPS and authentication.

Installation Guide

Setting up code-server is straightforward. The easiest way to install code-server is to use the official install script, which automates most of the process. This script attempts to use the system package manager if possible.

For Linux, macOS, and FreeBSD:

Run the following command in your terminal:

curl -fsSL https://code-server.dev/install.sh | sh

After installation, you can start code-server by running:

code-server

By default, code-server will be accessible at http://127.0.0.1:8080, and your password will be stored in ~/.config/code-server/config.yaml.

For Docker Users:

You can also run code-server in a Docker container:

docker run -it --name code-server -p 127.0.0.1:8080:8080 \
  -v "$HOME/.local:/home/coder/.local" \
  -v "$HOME/.config:/home/coder/.config" \
  -v "$PWD:/home/coder/project" \
  -u "$(id -u):$(id -g)" \
  -e "DOCKER_USER=$USER" \
  codercom/code-server:latest

This command mounts your current directory into the container and forwards your UID/GID so that all file system operations occur as your user outside the container.

Securing Your code-server Instance

To expose code-server securely to the internet, consider the following methods:

• Port Forwarding via SSH: If you have an SSH server on your remote machine, you can forward local ports to access code-server securely.
• Using Let’s Encrypt with Caddy or NGINX: For a more robust solution, you can set up HTTPS using Let’s Encrypt with web servers like Caddy or NGINX.
• Self-Signed Certificates: For internal use or testing, you can generate and use self-signed certificates to enable HTTPS.

These methods ensure that your code-server instance is accessible securely from anywhere.

Keeping code-server Up-to-Date

To ensure you have the latest features and security patches, it’s important to keep code-server updated. You can check for the latest releases on the GitHub Releases Page. To update, simply run the install script again:

curl -fsSL https://code-server.dev/install.sh | sh

This will download and install the latest version of code-server.

Final Thoughts

code-server empowers developers by providing a powerful, browser-based development environment that can be accessed from anywhere. Whether you’re working from a laptop, tablet, or smartphone, code-server ensures that you have a consistent and secure development setup at your fingertips.

By leveraging cloud servers, code-server enables faster development cycles and reduces the load on local machines, making it an ideal solution for modern development workflows.

The post code-server: Unlocking the Power of VS Code in Your Browser appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

Whether you’re a developer, a data enthusiast, or someone who simply loves to geek out over EV metrics, TeslaMate offers a comprehensive solution to monitor your vehicle’s health, efficiency, and usage patterns.

What Is TeslaMate?

TeslaMate is a self-hosted application that connects to your Tesla account via the official API. It retrieves real-time data about your vehicle’s state, charging sessions, trips, and more. This data is then stored in a PostgreSQL database and visualized through Grafana dashboards.

With TeslaMate, you can track:

• Battery Health: Monitor your battery’s state of health and degradation over time.
• Charging Stats: Analyze charging sessions, including energy added, cost, and efficiency.
• Drive Metrics: Record trip details such as distance, energy consumption, and driving behavior.
• Vehicle Status: Keep tabs on your car’s location, online/offline status, and more.

All of this is presented in a clean, intuitive web interface, ensuring you have all the insights you need at your fingertips.

Key Features

1. High Precision Drive Data Recording

TeslaMate captures detailed drive data, including energy consumption, distance traveled, and driving behavior. This allows you to analyze your driving habits and identify areas for improvement.

2. No Additional Vampire Drain

TeslaMate is designed to minimize energy consumption. It ensures that your vehicle falls asleep as soon as possible, preventing unnecessary battery drain.

3. Automatic Address Lookup

The application automatically converts GPS coordinates into human-readable addresses, making it easier to understand your vehicle’s locations during trips.

4. Easy Integration with Home Assistant

TeslaMate supports integration with Home Assistant via MQTT, allowing you to incorporate your Tesla’s data into your smart home automation system.

5. Geo-Fencing

Create custom locations to track when your vehicle enters or exits specific areas. This feature is useful for monitoring charging stations, home locations, or other points of interest.

6. Multiple Vehicle Support

TeslaMate supports multiple vehicles per Tesla account, making it ideal for owners of more than one Tesla.

7. Charge Cost Tracking

Track the cost of charging your vehicle by setting custom electricity rates for different locations. This helps you understand your charging expenses and optimize your usage.

Installation Guide

Setting up TeslaMate is straightforward, especially if you’re familiar with Docker. Here’s a basic docker-compose.yml configuration:

version: "3.3"
services:
  teslamate:
    image: teslamate/teslamate:latest
    restart: always
    environment:
      - ENCRYPTION_KEY=your_secure_key
      - DATABASE_USER=teslamate
      - DATABASE_PASS=your_password
      - DATABASE_NAME=teslamate
      - DATABASE_HOST=database
      - MQTT_HOST=mosquitto
    ports:
      - "4000:4000"
    volumes:
      - ./import:/opt/app/import
    cap_drop:
      - all
  database:
    image: postgres:17
    restart: always
    environment:
      - POSTGRES_USER=teslamate
      - POSTGRES_PASSWORD=your_password
      - POSTGRES_DB=teslamate
    volumes:
      - ./postgres:/var/lib/postgresql/data
  mosquitto:
    image: eclipse-mosquitto
    restart: always
    ports:
      - "1883:1883"
    volumes:
      - ./mosquitto:/mosquitto/config

After setting up your docker-compose.yml, run:

docker-compose up -d

Once the containers are up and running, you can access the TeslaMate web interface at http://localhost:4000.

Visualizing Your Data

TeslaMate comes bundled with Grafana dashboards that provide a comprehensive view of your vehicle’s data. These dashboards include:

• Battery Health: Track your battery’s state of health and degradation over time.
• Charging Stats: Analyze charging sessions, including energy added, cost, and efficiency.
• Drive Metrics: Record trip details such as distance, energy consumption, and driving behavior.
• Vehicle Status: Keep tabs on your car’s location, online/offline status, and more.

You can customize these dashboards to suit your preferences or create new ones to monitor specific metrics.

Integrations and Automation

TeslaMate supports integration with various platforms and services:

• Home Assistant: Integrate TeslaMate with your smart home automation system via MQTT.
• Node-RED: Use Node-RED to create custom automation workflows based on TeslaMate data.
• Telegram: Receive notifications about your vehicle’s status and events via Telegram.

These integrations allow you to automate tasks such as sending notifications when your vehicle reaches a specific location or when a charging session is complete.

Data Privacy and Security

One of the standout features of TeslaMate is its commitment to data privacy. Unlike cloud-based services, TeslaMate stores all your data locally, giving you full control over it. Your Tesla account credentials are encrypted and never stored in plaintext. Additionally, TeslaMate minimizes energy consumption to prevent unnecessary battery drain.

Real-World Use Cases

TeslaMate is ideal for various scenarios:

• Personal Use: Monitor your driving habits, track charging costs, and keep an eye on your vehicle’s health.
• Fleet Management: For businesses with multiple Teslas, TeslaMate provides a centralized dashboard to monitor all vehicles.
• Data Analysis: Researchers and data enthusiasts can analyze Tesla data for insights into EV performance and usage patterns.

Final Thoughts

TeslaMate is a robust, feature-rich solution for Tesla owners who want to take control of their vehicle’s data. Its self-hosted nature ensures privacy and customization, while its integrations and visualizations provide valuable insights into your driving and charging behaviors.

Whether you’re a developer, a data enthusiast, or someone who simply loves to geek out over EV metrics, TeslaMate offers a comprehensive solution to monitor your vehicle’s health, efficiency, and usage patterns.

https://github.com/teslamate-org/teslamate

The post TeslaMate: The Ultimate Self-Hosted Data Logger for Your Tesla 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.

Amateur radio operators often use various software for digital modes, packet radio, SDR, logging, and hotspot management. Docker containers make installing and running these apps easier and more consistent, regardless of your OS or environment.

Below is a curated list of top amateur radio software that either has official or community Docker images available — plus example commands so you can start using them immediately.

1. Dire Wolf – Soundcard AX.25 Packet TNC & APRS

Purpose: Software TNC for packet radio and APRS with soundcard interface.

Docker image: w6rz/direwolf

Run command example:

docker pull w6rz/direwolf

docker run -it --rm \
  --device /dev/snd \
  --device /dev/ttyUSB0 \
  -v $HOME/direwolf:/root \
  w6rz/direwolf

• Mounts your local config directory.
• Accesses sound and radio devices.
• Configure direwolf.conf inside your $HOME/direwolf folder.

2. OpenWebRX – Web-Based SDR Receiver

Purpose: Run a remote software-defined radio (SDR) accessible via web browser.

Docker image: cyoung/openwebrx

Run command example:

docker pull cyoung/openwebrx

docker run -d -p 8073:8073 cyoung/openwebrx

• Access the SDR web interface at http://localhost:8073
• Connect and listen from anywhere on your network.

3. WSJT-X – FT8 and Other Weak Signal Digital Modes

Purpose: Decode weak digital signals like FT8, JT65.

Docker image: No official image, but community versions exist (e.g., jks-prv/wsjtx).

Run command example:

docker pull jks-prv/wsjtx

docker run -d -p 5900:5900 jks-prv/wsjtx

• Runs a VNC server on port 5900 to access the GUI.
• Connect using a VNC client to localhost:5900.

4. Fldigi – Multi-Mode Digital Modem

Purpose: Supports many digital modes: PSK31, RTTY, MFSK, Olivia, and more.

Docker image: Community-built images exist (e.g., ka6sox/fldigi).

Run command example with X11 forwarding (Linux):

xhost +local:docker

docker run -it --rm \
  -e DISPLAY=$DISPLAY \
  -v /tmp/.X11-unix:/tmp/.X11-unix \
  --device /dev/snd \
  ka6sox/fldigi

• Access GUI directly on your desktop.
• Use sound devices for digital mode decoding.

5. Pi-Star – Digital Voice Hotspot Software (DMR, YSF, P25)

Purpose: Popular for managing digital voice hotspots.

Docker image: Community image (e.g., wm5d/pi-star).

Run command example:

docker pull wm5d/pi-star

docker run -d -p 80:80 -p 22222:22222 wm5d/pi-star

• Access the Pi-Star dashboard via http://localhost
• Configure your digital voice hotspot remotely.

6. Chirp – Radio Programming Software

Purpose: Program handheld radios easily.

Docker image: Community images available.

Run command example with GUI (X11 forwarding):

xhost +local:docker

docker run -it --rm \
  -e DISPLAY=$DISPLAY \
  -v /tmp/.X11-unix:/tmp/.X11-unix \
  yourusername/chirp

Bonus: Managing Multiple Ham Radio Containers with Docker Compose

Create a docker-compose.yml file to run multiple services together (e.g., Dire Wolf and OpenWebRX):

version: '3'
services:
  direwolf:
    image: w6rz/direwolf
    devices:
      - /dev/snd
      - /dev/ttyUSB0
    volumes:
      - ./direwolf:/root
    stdin_open: true
    tty: true

  openwebrx:
    image: cyoung/openwebrx
    ports:
      - "8073:8073"

Run all at once:

docker-compose up

Summary Table of Top Ham Radio Docker Containers

Final Thoughts

Running amateur radio software inside Docker containers lets you:

• Avoid complicated installations.
• Run your apps anywhere without changes.
• Experiment with new software without risk.
• Easily manage dependencies and updates.

The post Top Amateur Radio Software You Can Run Using Docker: Practical Examples appeared on Hamradio.my - Amateur Radio, Tech Insights and Product Reviews by 9M2PJU.

In the landscape of modern software development and IT operations, Docker has emerged as a game-changer. Whether you’re a developer, system administrator, or a DevOps engineer, Docker empowers you to build, ship, and run applications seamlessly — across your laptop, on-premise servers, or the cloud. This blog post will dive deep into Docker’s origin, its practical uses, key commands you need to know, advantages, and provide a hands-on example to get you started.

The Origin and History of Docker

Docker’s roots trace back to 2010 when a company named dotCloud, a platform-as-a-service (PaaS) provider, started experimenting with Linux container technology to better isolate and manage applications.

• March 2013: Docker was launched as an open-source project by Solomon Hykes, the CTO of dotCloud.
• Why it stood out: Docker made Linux containers accessible to developers through simple commands, standard image formats, and tooling that abstracted away complex underlying tech like LXC, cgroups, and namespaces.
• Growth: Docker quickly captured the attention of the tech community and companies worldwide. It transformed from an internal tool to the foundation of a whole ecosystem involving container registries (Docker Hub), orchestration tools (Docker Swarm, Kubernetes), and developer workflows.

Today, Docker Inc. continues to innovate with products designed for enterprise container management, security, and cloud-native development.

What Is Docker and Why Should You Care?

At its core, Docker is a containerization platform that packages your application and all its dependencies — libraries, system tools, and settings — into a single container. This container can run consistently across any environment that supports Docker, eliminating the infamous “it works on my machine” problem.

Why containers?

Before containers, virtualization was the go-to method to isolate applications — think Virtual Machines (VMs). But VMs require a full guest OS, which consumes more disk space, memory, and CPU.

Containers are lightweight:

• Share the host OS kernel.
• Start almost instantly.
• Require less storage.

Use cases for Docker include:

• Development environment standardization: Developers can replicate production environments on local machines.
• Microservices deployment: Each service runs in its own container, independently scalable and maintainable.
• CI/CD pipelines: Automate builds and tests in isolated containers.
• Legacy app modernization: Containerize old apps to run on modern infrastructure.
• Cloud migration: Easily move workloads across public clouds or hybrid setups.

Essential Docker Commands You Must Know

Here’s a handy list of Docker commands that cover basic to intermediate tasks:

Advantages of Using Docker

1. Portability and Consistency

Docker containers encapsulate everything needed to run your app, ensuring consistent behavior across development, staging, and production — regardless of where the container runs.

2. Lightweight

Containers share the OS kernel and don’t require running a full guest OS, saving CPU, memory, and storage compared to VMs.

3. Faster Deployment

Containers start almost instantly (in seconds), accelerating development cycles and scaling capabilities.

4. Isolation and Security

Containers provide process-level isolation, which helps prevent conflicts between apps running on the same host.

5. Simplified Dependency Management

No need to install or configure software dependencies on your host; they’re baked into the container image.

6. Vibrant Ecosystem

With Docker Hub, users have access to thousands of ready-to-use container images. The active community continually develops tools and resources.

7. Improved Resource Utilization

Multiple containers can run efficiently on a single host, making better use of hardware resources.

A Simple Docker Example: Running a Hello World Web Server

Let’s walk through a practical example so you can experience Docker firsthand.

Step 1: Install Docker

Make sure Docker is installed on your system. You can find official installation guides on docker.com.

Step 2: Run a prebuilt web server container

Open your terminal and run:

docker run -d -p 8080:80 --name hello-web nginx

What this does:

• docker run — Run a container.
• -d — Detached mode (runs container in the background).
• -p 8080:80 — Map port 8080 on your host to port 80 in the container.
• --name hello-web — Assign a name to the container.
• nginx — Use the official nginx web server image from Docker Hub.

Step 3: Access your web server

Open your browser and navigate to http://localhost:8080. You should see the default Nginx welcome page, meaning your container is up and running.

Step 4: Inspect the container

Check running containers:

docker ps

View container logs:

docker logs hello-web

Access the container shell:

docker exec -it hello-web /bin/bash

Inside, you can browse files, for example:

cat /usr/share/nginx/html/index.html

Step 5: Stop and remove the container

To stop:

docker stop hello-web

To remove:

docker rm hello-web

Conclusion

Docker has revolutionized software development and IT operations by making container technology accessible, portable, and scalable. It simplifies dependency management, accelerates deployment, and ensures your applications behave the same everywhere — a crucial advantage in today’s fast-moving development world.

This example only scratches the surface of Docker’s power. From building your own container images to orchestrating complex multi-container applications with Docker Compose or Kubernetes, Docker opens up a world of possibilities.

If you want to master modern software workflows, learning Docker is a must.

The post Docker: The Container Revolution That Changed Software Development Forever 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.

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.