Dockerized Application Deployment Using Ansible

Task Overview

This Task focuses on automating the deployment of a multi-container application using Ansible. The goal is to install Docker, configure the environment, and deploy a containerized application with Docker Compose on multiple servers. The project follows Infrastructure as Code (IaC) principles to ensure consistency and automation.

Technology Stack

• Infrastructure: AWS EC2 (or any cloud-based VM)
• Configuration Management: Ansible
• Containerization: Docker & Docker Compose
• Application Stack: Nginx (Reverse Proxy), MySQL (Database), Redis (Cache), Python (Flask-based Web App)
• Version Control: GitHub/GitLab
• Monitoring & Logging: Prometheus & Grafana (optional)
• Security & Access Management: SSH & Ansible Vault

Architecture Diagram

                    +----------------------+
                    |    User Request      |
                    +----------+-----------+
                               |
                               v
                      +----------------+
                      |    Nginx       |  --> Reverse Proxy
                      +----------------+
                               |
          +-------------------------------------+
          |           Docker Network           |
          +-------------------------------------+
                |                   |
         +------------+      +--------------+
         |   Flask    |      |    MySQL     |  --> Database
         +------------+      +--------------+
                |
        +---------------+
        |    Redis      |  --> Caching Layer
        +---------------+
    

Implementation Plan

1. Infrastructure Setup

• Provision EC2 instances (Ubuntu 22.04 or Amazon Linux 2) and configure security groups.
• Configure Security Groups:
• Allow SSH (22)
• Allow HTTP (80) & HTTPS (443)
• Allow MySQL (3306) (for internal access)
• Allow Redis (6379) (for internal access)

2. Ansible Playbook for Docker Installation

Create an Ansible playbook to install Docker, configure the user, and deploy the application.

• Install Docker and Docker Compose
• Add the current user to the Docker group
• Enable and start the Docker service
• Deploy a multi-container application using Docker Compose

Ansible Inventory File (inventory.ini)

[web_servers]
server1 ansible_host=192.168.1.10 ansible_user=ubuntu ansible_ssh_private_key_file=~/.ssh/id_rsa
server2 ansible_host=192.168.1.11 ansible_user=ubuntu ansible_ssh_private_key_file=~/.ssh/id_rsa
    

Ansible Playbook (docker-setup.yml)

---
- name: Install Docker and Deploy Application
  hosts: web_servers
  become: yes
  tasks:
    - name: Install required packages
      apt:
        name:
          - docker.io
          - docker-compose
          - python3-pip
          - python3-docker
        state: present
        update_cache: yes

    - name: Add user to Docker group
      user:
        name: ubuntu
        groups: docker
        append: yes

    - name: Start Docker service
      systemd:
        name: docker
        state: started
        enabled: yes

    - name: Copy Docker Compose file to remote servers
      copy:
        src: ./docker-compose.yml
        dest: /home/ubuntu/docker-compose.yml

    - name: Deploy Application with Docker Compose
      command: docker-compose -f /home/ubuntu/docker-compose.yml up -d
      args:
        chdir: /home/ubuntu/

    

3. Docker Compose Configuration

The docker-compose.yml file defines the multi-container application with services for:

1. Flask Web App
2. Nginx Reverse Proxy
3. MySQL Database
4. Redis Cache

docker-compose.yml

version: '3.8'

services:
  web:
    image: myflaskapp:latest
    build: ./app
    container_name: flask_app
    restart: always
    ports:
      - "5000:5000"
    environment:
      - DATABASE_URL=mysql://user:password@db/mydb
      - REDIS_URL=redis://redis:6379
    depends_on:
      - db
      - redis

  db:
    image: mysql:5.7
    container_name: mysql_db
    restart: always
    environment:
      MYSQL_ROOT_PASSWORD: rootpassword
      MYSQL_DATABASE: mydb
      MYSQL_USER: user
      MYSQL_PASSWORD: password
    ports:
      - "3306:3306"
    volumes:
      - db_data:/var/lib/mysql

  redis:
    image: redis:alpine
    container_name: redis_cache
    restart: always
    ports:
      - "6379:6379"

  nginx:
    image: nginx:latest
    container_name: nginx_proxy
    restart: always
    ports:
      - "80:80"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf
    depends_on:
      - web

volumes:
  db_data:

    

4. Running the Deployment

Step 1: Clone the Repository

git clone https://github.com/your-repo/dockerized-app.git
cd dockerized-app
ansible-playbook -i inventory.ini docker-setup.yml
    

Step 2: Run the Ansible Playbook

ansible-playbook -i inventory.ini docker-setup.yml

5. Verification & Testing

• Check running containers

docker ps

• Access the application at http://
• Connect to MySQL database:

mysql -u user -p -h 127.0.0.1 -P 3306

• Verify logs

docker-compose logs -f

Enhancements & Next Steps

• CI/CD Integration: Use GitHub Actions or Jenkins to automate Docker builds & deployments.
• Monitoring: Add Prometheus & Grafana to monitor container performance.
• Security:Use Ansible Vault for storing sensitive credentials and Implement SSL/TLS for secure communication.

Conclusion

This project provides an automated way to deploy a multi-container application using Docker Compose and Ansible. It ensures scalability, consistency, and ease of management.