Deploying a Web Application Using Docker Swarm : A Step-by-Step Guide for Beginners

Introduction

Deploying web applications in a reliable and scalable way is crucial for modern software development. Docker Swarm, a powerful container orchestration tool, helps manage and scale containerized applications with ease.

In this article, we'll guide you through the process of deploying a web application using Docker Swarm, explaining each step in simple terms. Whether you're new to Docker or looking to enhance your skills, this guide is for you!

What is Docker Swarm?

Docker Swarm is a tool that helps you manage a group of Docker containers across multiple computers, known as a Swarm cluster. It makes it easier to deploy, scale, and manage your applications. Key features of Docker Swarm include:

Load Balancing: Distributes network traffic evenly across multiple containers.
Rolling Updates: Updates your application without downtime.
Service Discovery: Automatically detects and connects services within the Swarm.
High Availability: Ensures your application is always available, even if some containers fail.

Project Overview

In this project, we'll deploy a web application using Docker Swarm. The steps include:

Creating a Dockerfile to package the application.
Setting up a Docker Swarm cluster.
Deploying the application onto the Swarm cluster.
Configuring the Swarm cluster for high availability and reliability.
Demonstrating key features like load balancing, rolling updates, and service discovery.

Step 1 : Creating a Dockerfile

A Dockerfile is a simple text file that contains instructions to build a Docker image. This image includes everything your application needs to run. Here’s an example Dockerfile for a basic Node.js web application:

# Use an official Node.js image as the base image
FROM node:14

# Set the working directory inside the container
WORKDIR /app

# Copy the package.json file and install dependencies
COPY package.json ./
RUN npm install

# Copy the rest of the application code
COPY . .

# Expose the port the application runs on
EXPOSE 3000

# Command to run the application
CMD ["npm", "start"]

Explanation:

FROM node:14: Uses Node.js version 14 as the base image.
WORKDIR /app: Sets the working directory inside the container to /app.
COPY package.json ./ and RUN npm install: Copies the package.json file and installs the dependencies.
COPY . .: Copies all the application files into the container.
EXPOSE 3000: Exposes port 3000 to allow access to the application.
CMD ["npm", "start"]: Specifies the command to start the application.

Step 2 : Setting Up a Docker Swarm Cluster

A Docker Swarm cluster consists of multiple nodes (machines). There are two types of nodes:

Manager Nodes: Manage the Swarm and distribute tasks to worker nodes.
Worker Nodes: Execute the tasks assigned by manager nodes.

Initialize a Docker Swarm:

On the manager node, run:
```
 docker swarm init
```
This command provides a token. Use this token to join worker nodes to the Swarm. On each worker node, run:
```
 docker swarm join --token <TOKEN> <MANAGER-IP>:2377
```
Replace <TOKEN> with the token provided by the swarm init command and <MANAGER-IP> with the IP address of the manager node.

Step 3 : Deploying the Containerized Application

Now, let's deploy our application. We'll use a docker-compose.yml file to define our services. Here’s an example:

version: '3'

services:
  web:
    image: my-web-app:latest
    deploy:
      replicas: 3
      update_config:
        parallelism: 1
        delay: 10s
    ports:
      - "80:3000"

Explanation:

version: '3': Specifies the version of the Docker Compose file format.
services:: Defines the services in the application.
web:: Defines the web service.
- image: my-web-app:latest: Uses the latest version of the my-web-app image.
- deploy:: Specifies deployment configurations.
  - replicas: 3: Deploys three replicas of the web service.
  - update_config:: Configures rolling updates.
    - parallelism: 1: Updates one replica at a time.
    - delay: 10s: Waits 10 seconds between updates.
- ports:: Maps port 80 on the host to port 3000 in the container.

Deploy the stack: Run the following command on the manager node to deploy the stack:

docker stack deploy -c docker-compose.yml my-stack

Step 4 : Configuring the Swarm Cluster

Docker Swarm offers several features out of the box:

Load Balancing: Automatically distributes incoming traffic across all replicas of a service. Users can access the service using the IP address of any Swarm node.
Rolling Updates: Updates services without downtime by replacing old containers with new ones gradually.
Service Discovery: Assigns a DNS name to each service, making it easy for services to communicate.

Example Commands:

Check Swarm status:
```
  docker node ls
```
List services:
```
  docker service ls
```
Scale a service:
```
  docker service scale my-stack_web=5
```

Step 5 : Demonstrating Key Features

Load Balancing: Swarm automatically balances the traffic among the replicas. Simply access your application via the Swarm node's IP, and traffic will be evenly distributed.
Rolling Updates: When you update your application, Swarm replaces the old containers with new ones one at a time, ensuring continuous availability.
Service Discovery: Docker Swarm assigns a unique DNS name to each service, allowing them to communicate using these names instead of IP addresses.
High Availability: If a node fails, Swarm automatically redistributes the tasks to other nodes, maintaining the availability of your services.

Conclusion

Docker Swarm is a powerful tool for managing containerized applications in production environments. It simplifies deploying, managing, and scaling applications, ensuring they are always available and can handle increased load. By following this guide, you can set up your own Swarm cluster and deploy applications with ease.