Docker Swarm: Orchestration & Scaling for Large-Scale Deployments

In today's fast-paced world, deploying applications efficiently and effectively is more critical than ever. As containerization has gained popularity, Docker has become the go-to solution for creating and managing containers. But what happens when your application needs to scale across multiple containers and hosts? That's where Docker Swarm comes into play. Docker Swarm is a native clustering and orchestration tool for Docker that allows you to create and manage a swarm of nodes (or Docker hosts) and deploy services across them. In this blog post, we'll delve deep into Docker Swarm, discussing its features, components, and how to use it for large-scale deployments. We'll also provide hands-on examples that demonstrate the key concepts in action.

What is Docker Swarm?

Docker Swarm is a container orchestration platform built into Docker, which allows you to manage and scale your Docker containers across multiple hosts. It offers features such as service discovery, load balancing, rolling updates, and automatic scaling, enabling you to deploy and manage applications at scale with ease.

Swarm Components

Before diving into the implementation, let's explore the main components of a Docker Swarm:


A node is an individual Docker host, which can be a physical or virtual machine running the Docker engine. Nodes can be classified into two types:

  1. Manager nodes: These nodes are responsible for managing the swarm, including maintaining the cluster state, scheduling services, and serving the swarm mode HTTP API endpoint.
  2. Worker nodes: These nodes execute tasks (container instances) that are assigned to them by manager nodes.


A service is a high-level abstraction that represents your application or a part of it. A service defines how your application should run, including the Docker image to be used, the desired number of replicas, and the network and storage resources that should be allocated.


A task is a single container instance running on a node. It is the smallest unit in the swarm and is created when the manager schedules a service to run on a node.

Setting up a Docker Swarm

Before you can start using Docker Swarm, you need to have Docker installed on your nodes. If you haven't already, follow the official installation guide for your operating system.

Initializing a Swarm

To create a swarm, you need to run the following command on one of your Docker hosts:

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

Replace <MANAGER-IP> with the IP address of the host you want to be the manager node. This command will initialize a new swarm with the current host as the manager node.

You should see a response similar to the following:

Swarm initialized: current node (dxn1zf6l61qsb1josjja83ngz) is now a manager.

To add a worker to this swarm, run the following command:

    docker swarm join --token SWMTKN-1-49nj1cmql0jkz5s954yi3oex3nedyz0fb0xx14ie39trti4wxv-8vxv8rssmk743ojnwacrr2e7c

To add a manager to this swarm, run 'docker swarm join-token manager' and follow the instructions.

Adding Nodes to the Swarm

To add a new node to the swarm, you'll need to run the docker swarm join command provided in the output of the docker swarm init command. This command includes the swarm token and the IP address and port of the manager node.

Run the following command on the node you want to add:

docker swarm join --token <SWARM-TOKEN> <MANAGER-IP>:<MANAGER-PORT>

Replace <SWARM-TOKEN> with the token from the output of docker swarm init, and <MANAGER-IP> and <MANAGER-PORT> with the IP address and port of the manager node.

Once you've executed the command, you should see a response like:

This node joined a swarm as a worker.

To add additional manager nodes, run docker swarm join-token manager on the current manager node and follow the instructions provided.

Deploying Services

Now that we have a swarm up and running, let's deploy a service to it. For this example, we'll deploy a simple web application using the nginx Docker image.

Creating a Service

To create a new service, run the following command on the manager node:

docker service create --name web --publish 80:80 --replicas 3 nginx

This command creates a new service named web using the nginx Docker image, publishes port 80 on the host to port 80 on the container, and creates three replicas of the service.

Listing Services

To view the list of services running in the swarm, run:

docker service ls

You should see output similar to:

ID                  NAME                MODE                REPLICAS            IMAGE               PORTS
y1wtdg8bm5l4        web                 replicated          3/3                 nginx:latest        *:80->80/tcp

Scaling Services

To scale a service, update the number of replicas using the docker service update command:

docker service update --replicas 5 web

This command sets the number of replicas for the web service to 5.

Rolling Updates

One of the benefits of using Docker Swarm is its ability to perform rolling updates, minimizing downtime during the deployment of new versions of your application. To demonstrate this, let's update our web service to use a different version of the nginx Docker image.

Updating a Service

To update a service, run the docker service update command with the --image flag:

docker service update --image nginx:1.21 web

This command updates the web service to use the nginx:1.21 Docker image.

Docker Swarm will now perform a rolling update, stopping and updating one replica at a time while maintaining the desired number of replicas.

Monitoring the Swarm

Docker Swarm provides several commands to help you monitor the state of your swarm, nodes, and services.

Viewing Swarm Nodes

To view the nodes in your swarm, run:

docker node ls

You should see output similar to:

ID                            HOSTNAME            STATUS              AVAILABILITY        MANAGER STATUS      ENGINE VERSION
dxn1zf6l61qsb1josjja83ngz *   node-1              Ready               Active              Leader              20.10.7
8vxv8rssmk743ojnwacrr2e7c     node-2              Ready               Active                                  20.10.7

Viewing Service Tasks

To view the tasks associated with a service, run:

docker service ps <SERVICE-NAME>

Replace <SERVICE-NAME> with the name of the service you want to inspect. For example, to view the tasks for our web service, run:

docker service ps web

You should see output similar to:

ID                  NAME                IMAGE               NODE                DESIRED STATE       CURRENT STATE            ERROR               PORTS
t0gbbw13q35w2l1m        web.1               nginx:1.21           node-1              Running             Running 2 minutes ago                       
7b8w1z97h7ik      web.2               nginx:1.21           node-2              Running             Running 2 minutes ago                       
4m24j8nj4z1b      web.3               nginx:1.21           node-1              Running             Running 2 minutes ago                       
c5v5j5n6d5g6      web.4               nginx:1.21           node-2              Running             Running 2 minutes ago                       
8q3h6d7e8r9j      web.5               nginx:1.21           node-1              Running             Running 2 minutes ago

This output shows the tasks (container instances) running for the web service, along with their current state and the node on which they are running.


Q: What is the difference between Docker Swarm and Kubernetes?

A: Docker Swarm and Kubernetes are both container orchestration platforms, but they have different design philosophies and features. Docker Swarm is built into Docker and is generally easier to set up and use, making it a good choice for smaller-scale deployments or those just getting started with container orchestration. Kubernetes, on the other hand, is a more powerful and flexible platform, suitable for large-scale, complex deployments, but it has a steeper learning curve.

Q: Can I use Docker Compose with Docker Swarm?

A: Yes, you can use Docker Compose to define your services and their configurations in a docker-compose.yml file and then deploy them to a swarm using the docker stack deploy command. This allows you to leverage your existing Docker Compose files and workflows in a swarm environment.

Q: How do I secure my Docker Swarm?

A: Securing your Docker Swarm involves multiple steps, including securing the underlying hosts, Docker daemons, and swarm itself. Some best practices include using TLS to secure communication between nodes, enabling and configuring role-based access control (RBAC), and keeping your Docker images and host systems up-to-date with the latest security patches.

Q: Can I mix manager and worker nodes?

A: While it is technically possible to have a node function as both a manager and a worker, it is generally not recommended. Manager nodes are responsible for managing the swarm and should be dedicated to that task, whereas worker nodes should be focused on running tasks (container instances) assigned to them.

Sharing is caring

Did you like what Mehul Mohan wrote? Thank them for their work by sharing it on social media.


No comments so far