DEV Community: eldara

Docker Swarm Auto-healing: A Guide to Troubleshooting 'Pending' States

eldara — Sun, 12 Apr 2026 13:07:02 +0000

It’s 3:00 AM. Your monitoring alert goes off. You check your cluster, and instead of a healthy green "Running" status, you see the dreaded, silent word: Pending.

In Docker Swarm, "Pending" is the scheduler’s way of saying, "I want to run this container, but I literally can’t find a home for it." Unlike an "Error" or a "Crash," a Pending state doesn't always show up in the standard logs. It’s a scheduling ghost.

In 2026, with the rise of resource-heavy AI sidecars and high-density edge clusters, "Pending" states are usually tied to one of three things. Let's look at how to find the bottleneck and fix it.

1. The "Resource Exhaustion" Trap

The most common reason for a Pending state is that you’ve promised more than your hardware can deliver. If you define a service with heavy reservations:

deploy:
  resources:
    reservations:
      cpus: '2'
      memory: 4G

...and your nodes only have 1GB of RAM free, Swarm will wait forever for resources to clear up.

How to Diagnose

The Native Way:

docker service ps --no-trunc <service_name>

Look for the Error column. It will usually say: insufficient resources on X nodes.

The SwarmCLI Fix:
Instead of checking every service one by one, SwarmCLI highlights the problems immediately.

This gives you a overview of your cluster’s services. You’ll instantly see which service has issues and needs attention.

2. The "VIP Section" (Placement Constraints)

We use constraints to make sure our Database only runs on nodes with SSDs, or our AI models only run on nodes with GPUs. But if you get too specific, you create an impossible puzzle for the scheduler.

The Scenario

You have a constraint node.labels.storage == ssd, but you forgot to actually label your new Raspberry Pi 5 nodes. Result? Pending.

Quick Check

Run docker node inspect <node-id> to see if the labels match your docker-compose.yml requirements.

3. The "Missing Map" (Volume & Network Mismatches)

In 2026, we’re seeing more "Multi-Arch" clusters (mixing x86 and ARM). If you try to deploy a service that requires a specific named volume that only exists on node-01, but you told Swarm it can run anywhere, the task will hang in "Pending" on any node that lacks that volume.

[!NOTE]
Common Network Hang: If you’re using an overlay network that hasn't synchronized across your managers correctly, the task might stay Pending while it waits for a network ID that doesn't exist on the target worker.

How to Debug Like a Pro in 2026

When a service stays Pending for more than 30 seconds, follow this checklist:

Check the "Desired State": Is Swarm actually trying to scale up?
Inspect the Task: Use docker inspect <task_id> and look at the Status and Message fields. This is where the "real" reason is hidden.
Check Node Health: Is the node marked as Ready and Active? A node in Drain mode will never accept new tasks.

The SwarmCLI "Doctor" Command

If you’re tired of digging through nested JSON, we’ve simplified the process:

swarmcli analyze <service_name>

This command runs a diagnostic sweep of your cluster, comparing your service requirements against your current node health. It will tell you exactly why your task is stuck—whether it’s a missing label, a full disk, or a memory reservation conflict.

Summary: Don't Let "Pending" Be Permanent

Docker Swarm’s auto-healing is brilliant, but it’s not magic. It needs a valid "landing strip" to place your containers. By keeping an eye on your resource reservations and using SwarmCLI to visualize your cluster capacity, you can solve 90% of scheduling issues before they even trigger an alert.

2026 Docker Swarm Mastery Series

Mar 9: [The Foundation] The Definitive Docker Swarm Guide for 2026.
Mar 12: [Expert Analysis] Docker Swarm vs Kubernetes in 2026 — The Case for Staying Simple.
Mar 16: [Edge Frontier] Setting up the ultimate 3-node Swarm on Raspberry Pi 5.
Mar 19: [Security Specialist] Secure by Design: Managing Docker Swarm Secrets the SwarmCLI Way.
Mar 23: [Ops Mastery] Docker Swarm Auto-healing: A Guide to Troubleshooting 'Pending' States.

Why SwarmCLI?

By 2026, we noticed a gap. Docker Swarm was rock solid, but the management tooling felt stuck in 2017. SwarmCLI bridges that gap with:

Real-time Health: Stop guessing which node is throttled.
Atomic Secret Sync: One-command .env to Raft encryption.
Edge-Optimized: Built in Go for zero-overhead on ARM/RPi5 devices.

Stay Connected

Secure by Design: Managing Docker Swarm Secrets the SwarmCLI Way

eldara — Thu, 26 Mar 2026 12:53:38 +0000

Look, in 2026, security isn't just a "nice-to-have" feature; it's the core of your infrastructure. If you're still putting API keys, database passwords, or private keys into environment variables in your docker-compose.yml, you're living on the edge — and not the good "Edge Computing" kind.

Docker Swarm has a powerful, built-in Secrets mechanism that encrypts your sensitive data both at rest (within the manager's Raft log) and in transit. But for many developers, the native CLI experience feels like a black box.

In this guide, we'll look at how SwarmCLI transforms secret management from a chore into a seamless part of your workflow.

The Native Problem: "Write-Once, Read-Never"

The biggest frustration with native Swarm secrets is how hard they are to audit. Once you've run docker secret create, that's it. You cannot "cat" the secret back out to verify its content without deploying a service, mounting the secret, and reading it from within the container.

This leads to a "deploy-fail-debug" cycle that slows down development.

Step 1: Secure Creation (The SwarmCLI Interface)

SwarmCLI provides a visual, interactive layer over the standard docker secret commands. Instead of long, complex one-liners, you get a clear dashboard where you can manage your secrets with context.

The OSS Experience

Even in the open-source version, SwarmCLI makes it easy to:

Bulk Audit: See all your secrets and their age in one view.
Service Mapping: Instantly see which services are using which secrets.
Health Checks: Detect secrets that are defined but unused (orphaned secrets).

Step 2: The Business Edition Advantage — Selective Transparency

This is where SwarmCLI BE really shines. We've heard from hundreds of developers that the "Write-Once" nature of secrets is the single biggest productivity killer.

The "Reveal" Feature

SwarmCLI BE introduces the Reveal action (x). With a single keystroke, SwarmCLI BE automates the complex dance required to safely audit a secret's value:

It spins up a temporary, minimal container (defaulting to alpine:latest).
It mounts the target secret.
It securely streams the value back to your TUI.
It instantly tears down the container, leaving no trace.

BE Tip: You can even customize the image used for this reveal process with the SWARMCLI_REVEAL_IMAGE environment variable if your environment requires strictly hardened base images.

Why This Matters in 2026

In a world where we're managing dozens of AI sidecars and edge nodes, you don't have time to manually verify that every node has the correct decryption keys. SwarmCLI BE gives you Observability without compromising Security.

By using Docker's native mechanisms boosted by SwarmCLI's intelligence, you get:

Zero Config: No extra vault software to install or manage.
Maximum Speed: Audit secrets in seconds, not minutes.
Audit Trails: Know exactly what’s in your cluster at any given time.

Conclusion

Secrets management shouldn't be a friction point in your development pipeline. Use the native power of Docker Swarm, and use SwarmCLI to pull back the curtain just enough to keep your team productive and your infrastructure secure.

Ready to secure your stack?

2026 Docker Swarm Mastery Series

Mar 9: [The Foundation] The Definitive Docker Swarm Guide for 2026.
Mar 12: [Expert Analysis] Docker Swarm vs Kubernetes in 2026 — The Case for Staying Simple.
Mar 16: [Edge Frontier] Setting up the ultimate 3-node Swarm on Raspberry Pi 5.
Mar 19: [Security Specialist] Secure by Design: Managing Docker Swarm Secrets the SwarmCLI Way.
Mar 23: [Ops Mastery] Docker Swarm Auto-healing: A Guide to Troubleshooting 'Pending' States.

Why SwarmCLI?

By 2026, we noticed a gap. Docker Swarm was rock solid, but the management tooling felt stuck in 2017. SwarmCLI bridges that gap with:

Real-time Health: Stop guessing which node is throttled.
Atomic Secret Sync: One-command .env to Raft encryption.
Edge-Optimized: Built in Go for zero-overhead on ARM/RPi5 devices.

Stay Connected

The Ultimate Edge Cluster: Setting up a 3-Node Swarm on Raspberry Pi 5 (2026)

eldara — Thu, 19 Mar 2026 11:42:36 +0000

By 2026, the Raspberry Pi 5 has become the undisputed king of the "Prosumer Edge." With its PCIe support for NVMe drives and significantly improved thermal management, it’s no longer just a toy—it’s a viable production environment for localized AI, smart home hubs, and private cloud storage.

But running a single Pi is a single point of failure. To get true reliability at the edge, you need a cluster. In this guide, we’ll build a 3-node "Pikube" (without the K8s overhead) that fits in the palm of your hand.

Why Swarm for the Edge?

If you’ve tried running Kubernetes on a Pi, you know the pain: the control plane can consume 1.5GB of RAM before you even deploy a single container.

Docker Swarm is different. It is baked into the Docker engine. On a Raspberry Pi 5, the Swarm overhead is nearly invisible, leaving all those glorious 8GB of RAM for your actual workloads.

Phase 1: The Hardware Prep

For a Production-Ready Edge cluster, we recommend:

3x Raspberry Pi 5 (8GB RAM models): The extra headroom is vital for AI sidecars and real-time observability.
NVMe Base/HAT: Skip the SD cards. They will fail under heavy Docker logging. Use NVMe SSDs for boot and data storage.
PoE+ HATs: This allows you to power all three nodes via a single ethernet switch—keeping your "cluster" cable-managed and professional.

OS Choice

Stick with Raspberry Pi OS (64-bit) or Ubuntu Server 26.04 LTS. Ensure you enable cgroups in cmdline.txt if they aren't on by default.

Phase 2: Installing Docker (The Quick Way)

On all three nodes, run the standard convenience script:

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

[!TIP]
Add your user to the docker group so you don't have to type sudo for every command:
sudo usermod -aG docker $USER (Log out and back in for this to take effect).

Phase 3: Initializing the Swarm

Pick your "Lead" Pi (let's call it pi-manager-01) and run:

docker swarm init --advertise-addr <YOUR-PI-IP>

Docker will provide a join-token. Copy that, SSH into your other two Pis, and paste it.

Verify with SwarmCLI

This is where SwarmCLI saves you from opening multiple terminal windows. From your laptop, connect to your manager node and run:

swarmcli node list

You’ll see a beautiful, real-time status of your Pi cluster. If one Pi is running hot or throttled, SwarmCLI will highlight the status so you can investigate before the node goes offline.

Phase 4: Edge-Specific Optimizations

Running on ARM hardware at the edge requires a few tweaks.

1. Label Your Nodes

In an edge setup, you might have one Pi with a camera attached. Use labels to tell Swarm where to put specific tasks.

docker node update --label-add hardware=camera pi-manager-01

2. Manage Log Rotation

Edge storage (even NVMe) can fill up fast. Update your /etc/docker/daemon.json:

{
  "log-driver": "json-file",
  "log-opts": {
    "max-size": "10m",
    "max-file": "3"
  }
}

3. Monitoring with SwarmCLI

Instead of installing a heavy monitoring stack like Prometheus/Grafana, use:

swarmcli service stats

This gives you a lightweight view of CPU cycles across the entire cluster without taxing the Pi's resources.

Conclusion: The Power of Three

A 3-node Raspberry Pi 5 Swarm cluster provides:

High Availability: One Pi can fail completely, and your services will migrate gracefully.
Low Power: The entire cluster pulls less than 40W under load.
Simplicity: No complex networking plugins required—just native Swarm power.

2026 Docker Swarm Mastery Series

Mar 9: [The Foundation] The Definitive Docker Swarm Guide for 2026.
Mar 12: [Expert Analysis] Docker Swarm vs Kubernetes in 2026 — The Case for Staying Simple.
Mar 16: [Edge Frontier] Setting up the ultimate 3-node Swarm on Raspberry Pi 5.
Mar 19: [Security Specialist] Secure by Design: Managing Docker Swarm Secrets the SwarmCLI Way.
Mar 23: [Ops Mastery] Docker Swarm Auto-healing: A Guide to Troubleshooting 'Pending' States.

Why SwarmCLI?

By 2026, we noticed a gap. Docker Swarm was rock solid, but the management tooling felt stuck in 2017. SwarmCLI bridges that gap with:

Real-time Health: Stop guessing which node is throttled.
Atomic Secret Sync: One-command .env to Raft encryption.
Edge-Optimized: Built in Go for zero-overhead on ARM/RPi5 devices.

Stay Connected

Docker Swarm vs. Kubernetes in 2026: The Case for Staying Simple

eldara — Mon, 16 Mar 2026 17:55:53 +0000

By 2026, the tech industry has reached a collective realization: not every app needs to be a spaceship. We’ve spent the last few years watching startups with three microservices spend $10,000 a month on "managed Kubernetes" and another $20,000 on the DevOps engineers required to keep it alive.

We call this the "Complexity Tax," and in today's efficiency-first market, developers are looking for an exit ramp. If you’re deciding between Docker Swarm and Kubernetes today, you aren't just choosing a tool; you're choosing how much of your life you want to spend writing YAML.

The Reality of the 2026 Landscape

Kubernetes has essentially become the "Linux of the Cloud"—it’s the foundational layer for massive enterprises. However, two major trends have brought Docker Swarm back into the spotlight:

The Edge Computing Explosion: Running AI inference models on local hardware or ARM-based edge devices doesn't leave much room for a heavy K8s control plane.
The "SME" Renaissance: Small and medium enterprises are prioritizing "Time to Market" over "Infinite Scalability." They need things that just work.

The Comparison: Complexity vs. Control

Feature	Docker Swarm (Simple Path)	Kubernetes (Scalable Path)
Setup & Onboarding	Minutes. If you know Docker, you know Swarm.	Days/Weeks. Requires learning Pods, Deployments, and CRDs.
Resource Overhead	Negligible. Runs comfortably on a 2GB RAM VPS.	Significant. The control plane alone needs dedicated resources.
Networking	Built-in Ingress Mesh. Load balancing works instantly.	Modular. Requires choosing CNI plugins and Ingress controllers.
Maintenance	Minimal. It’s an extension of the Docker daemon.	Continuous. Version upgrades can be breaking and complex.
Ecosystem	Smaller, but stable and predictable.	Massive. If a tool exists, it has a K8s version.

When to Stay Simple: The Case for Swarm

You should stick with Docker Swarm if:

You are a Small Team: You don't have a dedicated "Platform Team" to manage your infrastructure 24/7.
You're Building for the Edge: You need to deploy containers on remote devices (like a Raspberry Pi 5) where every MB of RAM counts.
You Already Use Docker Compose: Swarm is essentially "Compose for multiple servers." The mental leap is zero.
Your Scaling is Predictable: If you’re running 10, 50, or even 100 containers, Swarm handles this with rock-solid stability.

[!TIP]
The biggest "missing piece" in Swarm has always been visibility. This is why we built SwarmCLI. It gives you the high-level cluster insights you’d expect from a K8s dashboard, but through the terminal you already love.

When to Choose the "Complex" Path (Kubernetes)

Let’s be fair—Kubernetes is the industry standard for a reason. You should use it if:

You Need Multi-Tenancy: You’re a large org where different teams need strict isolation (RBAC) within the same cluster.
You Need Custom Autoscaling: You have massive traffic swings that require pods to spin up and down based on custom metrics (like a GPU queue).
You Live in the "Cloud-Native" Ecosystem: You rely heavily on tools like Service Meshes (Istio), GitOps (ArgoCD), or complex operators built specifically for K8s.

The Bottom Line

In 2026, simplicity is a competitive advantage. Every hour your team spends debugging a CNI plugin in Kubernetes is an hour they aren't shipping features for your customers.

Docker Swarm gives you 90% of what you need with 10% of the effort. And with modern tools like SwarmCLI, the "management gap" has never been smaller. Stop over-engineering. Start shipping.

2026 Docker Swarm Mastery Series

Mar 9: [The Foundation] The Definitive Docker Swarm Guide for 2026.
Mar 12: [Expert Analysis] Docker Swarm vs Kubernetes in 2026 — The Case for Staying Simple.
Mar 16: [Edge Frontier] Setting up the ultimate 3-node Swarm on Raspberry Pi 5.
Mar 19: [Security Specialist] Secure by Design: Managing Docker Swarm Secrets the SwarmCLI Way.
Mar 23: [Ops Mastery] Docker Swarm Auto-healing: A Guide to Troubleshooting 'Pending' States.

Why SwarmCLI?

By 2026, we noticed a gap. Docker Swarm was rock solid, but the management tooling felt stuck in 2017. SwarmCLI bridges that gap with:

Real-time Health: Stop guessing which node is throttled.
Atomic Secret Sync: One-command .env to Raft encryption.
Edge-Optimized: Built in Go for zero-overhead on ARM/RPi5 devices.

Stay Connected

The Definitive Docker Swarm Guide for 2026: Production-Ready Clusters in 10 Minutes

eldara — Mon, 09 Mar 2026 16:46:30 +0000

Look, it's 2026. We've all seen the "Kubernetes-is-everything" era, and frankly, some of us are a bit tired. While K8s is a marvel of engineering, using it for a 5-node application or an edge deployment is like using a literal rocket ship to go to the grocery store.

Docker Swarm isn't just "still alive"; it's thriving.

Why? Because in an era of AI-driven microservices and edge computing, developers are realizing that simplicity is a feature, not a limitation.

In this guide, we're going to skip the fluff and get a production-ready Swarm cluster running. And because we value your time, we're going to show you how SwarmCLI makes the "boring" parts of Swarm actually enjoyable.

Why Swarm in 2026? (The Honest Truth)

Before we dive in, let's clear the air. If you are managing 5,000 nodes for a global bank, go use Kubernetes. But if you fall into these categories, Swarm is your best friend:

Edge & IoT: Running AI sidecars on localized hardware where overhead matters.
SaaS Startups: You need to scale, but you don't have a dedicated DevOps team.
Internal Tools: Getting a CI/CD pipeline or a staging environment up in seconds.

Perspective Check: Most of the "complex" problems people solve with K8s can be solved with a well-configured Swarm cluster and about 90% less YAML.

Expert Analysis: Docker Swarm vs Kubernetes in 2026 — The candid case for staying simple.

Step 1: The Foundation (Node Setup)

To follow this Docker Swarm tutorial, you need at least three nodes for a "production-ready" feel (high availability). We recommend the "Manager-Worker" split.

Initialize the Manager:

docker swarm init --advertise-addr <MANAGER-IP>

Add the Workers: Copy the token generated above and run it on your other nodes.

The SwarmCLI Shortcut

Managing these tokens and IPs manually is a headache. With SwarmCLI, you can audit your node health instantly:

This gives you a color-coded view of who's leader, who's reachable, and who's struggling — no more squinting at raw JSON.

Step 2: Secret Management (The Right Way)

Security is where most "10-minute guides" fail. They tell you to put passwords in environment variables. Don't do that.

Docker Swarm has a built-in "Secrets" mechanism that encrypts sensitive data at rest and in transit.

Native Way:

echo "password" | docker secret create db_pass -

The SwarmCLI Way:

Step-by-Step: Secure by Design: Managing Docker Swarm Secrets the SwarmCLI Way.

Step 3: Deploying Your First Stack

In 2026, we don't just deploy containers; we deploy Stacks. A stack is a collection of services (DB, API, Frontend) that talk to each other.

version: '3.8'
services:
  web:
    image: my-app:latest
    deploy:
      replicas: 3
      update_config:
        parallelism: 1
        delay: 10s
      restart_policy:
        condition: on-failure

Deploy it:

docker stack deploy -c docker-compose.yml my_project

Step 4: Maintaining Health (Auto-healing)

One of Swarm's superpowers is Desired State Reconciliation. If a container crashes, Swarm starts a new one. If a node dies, Swarm moves the tasks.

However, sometimes services get stuck in a "Pending" state (usually due to resource constraints or network labels).

Troubleshooting Guide: Docker Swarm Auto-healing: A Guide to Troubleshooting 'Pending' States.

Swarm vs. The World

Feature	Docker Swarm	Kubernetes	Verdict
Setup Time	< 5 Minutes	Hours/Days	Swarm Wins
Learning Curve	Low (Compose-based)	High (CRDs, Pods)	Swarm Wins
Resource Overhead	Very Low	High	Swarm Wins
AI/Edge Suitability	Excellent	Heavy	Swarm Wins

Conclusion: Simplicity is the New Scale

You don't need to be a cloud architect to run a reliable, scalable cluster. By using Docker Swarm combined with the modern tooling of SwarmCLI, you get the power of orchestration without the "configuration tax."

Ready to push your first production stack?

Download SwarmCLI today!
Edge Frontier:Setting up the ultimate 3-node Swarm on Raspberry Pi 5.

2026 Docker Swarm Mastery Series

Mar 9: [The Foundation] The Definitive Docker Swarm Guide for 2026.
Mar 12: [Expert Analysis] Docker Swarm vs Kubernetes in 2026 — The Case for Staying Simple.
Mar 16: [Edge Frontier] Setting up the ultimate 3-node Swarm on Raspberry Pi 5.
Mar 19: [Security Specialist] Secure by Design: Managing Docker Swarm Secrets the SwarmCLI Way.
Mar 23: [Ops Mastery] Docker Swarm Auto-healing: A Guide to Troubleshooting 'Pending' States.

Why SwarmCLI?

By 2026, we noticed a gap. Docker Swarm was rock solid, but the management tooling felt stuck in 2017. SwarmCLI bridges that gap with:

Real-time Health Heatmaps: Stop guessing which node is throttled.
Atomic Secret Sync: One-command .env to Raft encryption.
Edge-Optimized: Built in Go for zero-overhead on ARM/RPi5 devices.

Stay Connected

SwarmCLI vs. Portainer and Native Docker: Why It's the Lightweight Choice for Swarm Users

eldara — Tue, 17 Feb 2026 19:50:09 +0000

In the container management space, options abound—from native Docker CLI to full-featured GUIs like Portainer. But for Docker Swarm loyalists who want simplicity without bloat, SwarmCLI stands out as a fresh contender. Launched open-source by Eldara, it's designed for those sticking with Swarm's ease over Kubernetes complexity.

Quick Comparison

Native Docker CLI: Powerful but command-heavy. SwarmCLI wraps it in a TUI for faster navigation—think k9s vibes.
Portainer: Great web UI with Swarm support, but it's broader (K8s/Docker focus) and can feel heavy.SwarmCLI is CLI-first, lighter, and Swarm-specialized.

SwarmCLI's edge? It's free for basics, with a path to premiums without vendor lock-in.

Feature Highlights: What Sets SwarmCLI Apart

Core Management (Free in Community)

Stacks: List, delete, tasks, errors.
Services: Full suite—inspect, logs, scale, rollback.
Nodes: Promote, label, delete.
Secrets/Configs: Secure CRUDE.
Networks/Contexts: Prune, switch, export.

Planned Business Boosts

Shell and port forwarding for direct container interaction.
Analytics, RBAC, and integrations.

Why Choose SwarmCLI?

Swarm Focus: Pure Swarm optimization—lighter footprint for cost-sensitive teams.
Open-Source Community: Contribute on GitHub.

Test it: Clone github.com/Eldara-Tech/swarmcli and share your thoughts.

Deep Dive: How SwarmCLI Simplifies Docker Swarm Operations for DevOps Teams

eldara — Thu, 12 Feb 2026 18:48:19 +0000

As Docker Swarm continues to power production environments for its minimal overhead and native Docker integration, tools that enhance its usability are in high demand. In my last post, I introduced SwarmCLI, the open-source CLI tool that's like k9s for Swarm. Today, let's dive deeper into its features and how they streamline real-world workflows.

The Core Workflow: From Setup to Scaling
SwarmCLI's TUI lets you navigate Swarm entities interactively—no more memorizing commands. Here's how it shines in key areas:

Stacks and Services: Your Deployment Powerhouse

List and Inspect: Quickly view stacks (docker stack ls) and services (docker stack services). Drill down with inspections for configs, ports, and more.
Scaling and Rollbacks: Adjust replicas on the fly (docker service scale) or rollback bad deploys (docker service update --rollback). Immediate error overviews flag issues instantly.
Logs and Tasks: Tail logs (docker service logs) or check task status (docker service ps) without leaving the interface—perfect for debugging live.

In the Community Edition, these are all free. For teams, a Business Edition is planned, which will add features like shell access (e.g., exec into containers) and port forwarding for secure remote testing.

Nodes and Networks: Infrastructure at Your Fingertips

Node Management: List nodes (docker node ls), promote/demote managers, add labels, or delete nodes safely.
Network Ops: Create, inspect, prune, or delete networks (docker network prune) to keep things tidy.
Configs and Secrets: Secure Data Handling
CRUDE for configs and secrets, with inspection and creation. The The “Reveal” feature for secrets will be available in a Business Edition.
Contexts: Multi-Env Mastery

Switch between dev, staging, and prod seamlessly (docker context use), with export/import for sharing setups.

Real-Use Case: Debugging a Failing Service
Imagine a service crashing in production. With SwarmCLI:

List services and spot the offender.
View tasks and logs in real-time.
Scale down, rollback, and restart—all in seconds.
Check node health to rule out hardware issues.
This workflow saved our team hours compared to native CLI.

Head to swarmcli.io or github.com/Eldara-Tech/swarmcli to install and contribute.

If this resonates, clap and follow for more DevOps tips!

Introducing SwarmCLI: The k9s-Inspired CLI Tool Revolutionizing Docker Swarm Management

eldara — Mon, 09 Feb 2026 19:53:05 +0000

In the world of container orchestration, Docker Swarm has long been a lightweight, reliable alternative to Kubernetes for teams that value simplicity and ease of setup. But let's be honest—managing Swarm clusters with the native Docker CLI can feel clunky and time-consuming. Endless typing of commands, switching contexts, and sifting through logs? It's enough to make any DevOps engineer long for a more intuitive interface.

Enter SwarmCLI, an open-source terminal user interface (TUI) tool inspired by the beloved k9s for Kubernetes. SwarmCLI brings that same snappy, interactive experience to Docker Swarm users.

Why SwarmCLI? The Pain Points It Solves

If you've ever wrestled with Docker Swarm, you know the drill:

Native commands are powerful but verbose—think docker service ps just to check tasks.
No built-in error overviews or quick diagnostics, leading to hours lost in troubleshooting.
Scaling and managing multi-node clusters feels fragmented without a unified view.

SwarmCLI addresses these by providing a k9s-like TUI where you can browse, edit, and monitor everything in one place. It's fully open-source under Apache 2.0, with a Community Edition that's free forever for core features.

Key Features at a Glance

Here's a snapshot of what SwarmCLI offers right out of the box:

Stack Management
List, delete, show tasks, and get immediate error overviews.

Service Management
List, remove, inspect, restart, view logs, rollback, scale, and error overviews—all free in Community.
Business Edition extras: Shell access and port forwarding (coming soon).

Node, Config, Secret, Context, and Network Tools
Comprehensive CRUD operations (create, read, update, delete) for all, plus pruning and labeling.

Check out our Website or our GitHub repo for the full feature breakdown.

Open-Core Model: Free Core, Premium Power later

SwarmCLI follows an open-core approach. The Community Edition handles 95% of daily needs, while the Business Edition will unlock enterprise features like advanced analytics, RBAC, and integrations.

Get Started Today

Installation is simple: Clone the repo, build with Docker, and dive in. If you're a Swarm user, give it a try and star the repo to show support.

Feedback? Open an issue—we're building this with the community.

What do you think? Is SwarmCLI the tool you've been waiting for? Drop a comment below!