Swarm Cluster and Services

🐝 Docker Swarm: Your Container Orchestra

Imagine you have a bee hive. One bee can carry some honey, but a whole swarm of bees working together? They can do AMAZING things! Docker Swarm works the same way—it’s how we get many computers to work together as one super-team.

🎯 What is Docker Swarm?

Think of Docker Swarm like a school play:

• You have one director (the manager) who decides what happens
• You have actors (workers) who do the actual performing
• Together, they create something magical!

Without Swarm: You run containers on ONE computer. If it breaks, everything stops. 😢

With Swarm: You run containers across MANY computers. If one breaks, others keep going! 🎉

Single Computer          Docker Swarm
    📦                   📦 📦 📦
    ⬇️                   ⬇️ ⬇️ ⬇️
   💻                  💻 💻 💻
 (risky!)            (safe & strong!)

🚀 Swarm Mode Initialization

Before bees can work together, they need to form a swarm. Same with Docker!

Starting Your Swarm

On your first computer (this becomes the manager):

docker swarm init

That’s it! One command. Docker will reply with something like:

Swarm initialized: current node
is now a manager.

To add a worker, run:
docker swarm join --token SWMTKN-1-abc123...

Real Example:

docker swarm init --advertise-addr 192.168.1.10

This tells other computers: “Hey! Find me at this address!”

What Happens Behind the Scenes?

graph TD
    A["Your Computer"] -->|docker swarm init| B["🎩 Manager Node"]
    B --> C["Ready to Accept Workers!"]
    C --> D["Swarm is Born 🐝"]

👔 Managers and Workers

Every swarm has two types of members:

🎩 Managers (The Bosses)

• Decide what containers to run
• Remember the state of everything
• Direct workers to do tasks
• Can also do work themselves!

👷 Workers (The Doers)

• Follow manager instructions
• Run containers
• Report back their status
• Cannot make decisions alone

Think of it like a restaurant:

• 🎩 Manager = Head Chef (plans the menu, assigns tasks)
• 👷 Worker = Line Cooks (prepare the dishes)

How Many Managers?

Why odd numbers? If managers disagree, they vote! Odd numbers prevent ties.

graph TD
    M1["🎩 Manager 1"] --- M2["🎩 Manager 2"]
    M2 --- M3["🎩 Manager 3"]
    M1 --- M3
    M1 --> W1["👷 Worker 1"]
    M2 --> W2["👷 Worker 2"]
    M3 --> W3["👷 Worker 3"]

🚪 Joining and Leaving a Swarm

Joining as a Worker

Remember that token from docker swarm init? Workers use it:

docker swarm join \
  --token SWMTKN-1-abc123... \
  192.168.1.10:2377

Breaking it down:

• --token = Your secret password to join
• 192.168.1.10:2377 = Manager’s address

Joining as a Manager

Want another manager? Get a special manager token:

# On existing manager:
docker swarm join-token manager

# Then use that token on new machine

Leaving the Swarm

Worker leaving:

docker swarm leave

Manager leaving:

docker swarm leave --force

⚠️ Warning: Managers need --force because leaving affects the whole swarm!

Removing a Node (from Manager’s side)

docker node rm worker-node-name

graph TD
    A["New Computer"] -->|join token| B["Swarm"]
    B -->|Welcome!| A
    C["Leaving Computer"] -->|swarm leave| D["Goodbye! 👋"]

📦 Swarm Services

Here’s where the magic happens! Services are how you run apps in a swarm.

Container vs Service

Think of it like:

• 🏠 Container = One house
• 🏘️ Service = A whole neighborhood of identical houses

Your First Service

docker service create \
  --name my-web \
  --replicas 3 \
  nginx

This says: “Run 3 copies of nginx, keep them running!”

graph TD
    S["🎯 Service: my-web"] --> R1["📦 Replica 1"]
    S --> R2["📦 Replica 2"]
    S --> R3["📦 Replica 3"]
    R1 --> N1["💻 Node 1"]
    R2 --> N2["💻 Node 2"]
    R3 --> N3["💻 Node 3"]

Checking Your Services

# List all services
docker service ls

# See details of one service
docker service ps my-web

📈 Service Creation and Scaling

Creating Services with Options

docker service create \
  --name api \
  --replicas 5 \
  --publish 8080:80 \
  --env APP_ENV=production \
  my-api-image

What this does:

• --name api → Call it “api”
• --replicas 5 → Run 5 copies
• --publish 8080:80 → Port 8080 outside → 80 inside
• --env → Set environment variable

Scaling Up and Down

Need more power? Scale up!

docker service scale my-web=10

Now you have 10 copies instead of 3! 🚀

Too many? Scale down:

docker service scale my-web=2

Scaling Multiple Services

docker service scale \
  web=5 \
  api=3 \
  cache=2

One command, multiple services scaled!

graph TD
    subgraph Before
    B1["📦 📦 📦"]
    end
    subgraph After Scale Up
    A1["📦 📦 📦 📦 📦 📦 📦 📦 📦 📦"]
    end
    Before -->|scale=10| After

Updating Services

docker service update \
  --image nginx:latest \
  my-web

This updates all replicas to the new image—one at a time, no downtime!

🌍 Global vs Replicated Services

Two ways to spread your containers:

🔄 Replicated Services (Default)

“Run exactly N copies, put them anywhere”

docker service create \
  --name web \
  --replicas 3 \
  nginx

• You choose how many: 3 replicas
• Swarm decides where to put them
• Some nodes might have 0, some might have 2

Use when: You need a specific number of copies

🌍 Global Services

“Run exactly ONE copy on EVERY node”

docker service create \
  --name monitor \
  --mode global \
  datadog/agent

• Every node gets exactly one
• New node joins? It automatically gets one too!
• Node leaves? That copy goes away

Use when:

• Monitoring agents (need one per machine)
• Log collectors
• Security scanners

Side by Side Comparison

REPLICATED (3 copies)     GLOBAL (1 per node)

Node 1: 📦 📦             Node 1: 📦
Node 2: 📦                Node 2: 📦
Node 3: (empty)           Node 3: 📦
Node 4: (empty)           Node 4: 📦

Total: 3 containers       Total: 4 containers
                          (one per node)

graph TD
    subgraph Replicated
    R["Service"] --> R1["📦"]
    R --> R2["📦"]
    R --> R3["📦"]
    end

    subgraph Global
    G["Service"] --> G1["📦 Node1"]
    G --> G2["📦 Node2"]
    G --> G3["📦 Node3"]
    G --> G4["📦 Node4"]
    end

🎉 Putting It All Together

Let’s create a real swarm setup!

Step 1: Initialize on first machine

docker swarm init --advertise-addr 192.168.1.10

Step 2: Join workers

# On other machines:
docker swarm join --token SWMTKN-1-xxx 192.168.1.10:2377

Step 3: Create services

# Web app - 5 replicas
docker service create \
  --name web \
  --replicas 5 \
  --publish 80:80 \
  nginx

# Monitoring - one per node
docker service create \
  --name monitor \
  --mode global \
  prom/node-exporter

Step 4: Check everything

docker node ls          # See all nodes
docker service ls       # See all services
docker service ps web   # See web replicas

🧠 Key Takeaways

🚀 You Did It!

You now understand how Docker Swarm turns many computers into one powerful team. Like bees in a hive, each node has its role, and together they’re unstoppable!

Remember:

• One swarm init creates your hive
• Tokens let others join
• Services keep your apps running
• Scaling is just one command away!

Go forth and orchestrate! 🐝✨