DEV Community: Santosh Yadav

Monolithic vs Microservices Architecture

Santosh Yadav — Wed, 27 Aug 2025 12:54:53 +0000

🏗 Monolithic vs Microservices Architecture – A Clear Comparison

When building applications, one of the most important architectural choices is whether to go Monolithic or Microservices.

Let’s break them down with advantages, disadvantages, and real-world use cases.

🔹 Monolithic Architecture

👉 Definition: Entire application is built as a single, unified codebase. All modules (auth, product, cart, payments) run together and share the same database.

✅ Advantages

Simple to develop, test, and deploy.
Easier debugging (single codebase).
Slightly better performance (intra-process calls).
Good for small teams & MVPs.

⚠️ Disadvantages

Hard to scale specific features (must scale the whole app).
Slower deployments (a small change redeploys everything).
Large codebase → harder to manage as it grows.
Technology stack is locked.
Failure in one module can bring down the entire app.

📌 Use Case: Startups, MVPs, and small applications.

🔹 Microservices Architecture

👉 Definition: Application is broken into small, independent services (e.g., Auth Service, Cart Service, Payment Service) communicating via APIs (REST/gRPC/Message Queues).

✅ Advantages

Independent development & deployment.
Scalability at the service level.
Polyglot freedom (different tech stacks).
Fault isolation (failure in one service doesn’t crash the whole app).
Great fit for CI/CD and DevOps practices.

⚠️ Disadvantages

More complex (service discovery, API gateways, communication overhead).
Data consistency challenges.
Requires strong DevOps, monitoring, and observability.
Higher latency (network calls).
Debugging across services is harder.

📌 Use Case: Large-scale apps like Netflix, Amazon, Uber needing scalability, agility, and high availability.

🔹 Quick Comparison

Aspect	Monolithic 🏠	Microservices 🧩
Deployment	Single unit	Independent per service
Scalability	Whole app	Per service
Technology Stack	One stack	Multiple allowed
Fault Isolation	Low	High
Team Structure	Single team	Multiple small teams
Best for	Small apps, MVPs	Large-scale, fast-growing apps

🔹 Final Thoughts

Think of Monolithic like a big restaurant kitchen 🍳 (everything in one place, easy at the start, chaotic as it grows),

while Microservices is like a food court 🍔🍕🍜 (independent kitchens, scalable, but requires more coordination).

💡 Pro Tip: Start with a monolith if you’re small → migrate to microservices when you hit scaling and agility challenges.

👉 What architecture do you prefer for your projects? Drop your thoughts in the comments!

Running Flask + MySQL with Docker Compose

Santosh Yadav — Wed, 27 Aug 2025 12:07:22 +0000

Flask + MySQL with Docker Compose

This guide shows how to set up a Flask application with MySQL database using Docker Compose.

1. Project Structure

flask-mysql-app/
│── docker-compose.yml
│── flask-app/
│   ├── Dockerfile
│   ├── requirements.txt
│   ├── app.py

2. `docker-compose.yml`

version: "3.9"

services:
  flask-web:
    build: ./flask-app
    container_name: flask-web
    ports:
      - "5000:5000"
    environment:
      - DB_HOST=mysql-db
      - DB_USER=root
      - DB_PASSWORD=rootpassword
      - DB_NAME=testdb
    depends_on:
      - mysql-db
    networks:
      - app-network

  mysql-db:
    image: mysql:8.0
    container_name: mysql-db
    restart: always
    environment:
      MYSQL_ROOT_PASSWORD: rootpassword
      MYSQL_DATABASE: testdb
    ports:
      - "3306:3306"
    volumes:
      - mysql_data:/var/lib/mysql
    networks:
      - app-network

volumes:
  mysql_data:

networks:
  app-network:
    driver: bridge

3. `flask-app/Dockerfile`

# Use official Python image
FROM python:3.11-slim

# Set working directory
WORKDIR /app

# Install dependencies
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Copy app code
COPY . .

# Expose port 5000
EXPOSE 5000

# Run the application
CMD ["python", "app.py"]

4. `flask-app/requirements.txt`

flask
mysql-connector-python

5. `flask-app/app.py`

from flask import Flask, jsonify
import mysql.connector
import os

app = Flask(__name__)

# Read DB configs from environment variables
db_config = {
    'host': os.getenv("DB_HOST", "localhost"),
    'user': os.getenv("DB_USER", "root"),
    'password': os.getenv("DB_PASSWORD", "rootpassword"),
    'database': os.getenv("DB_NAME", "testdb")
}

@app.route('/')
def hello_world():
    return "Hello from Flask + MySQL in Docker!"

@app.route('/users')
def get_users():
    try:
        conn = mysql.connector.connect(**db_config)
        cursor = conn.cursor()
        cursor.execute("CREATE TABLE IF NOT EXISTS users (id INT AUTO_INCREMENT PRIMARY KEY, name VARCHAR(50))")
        cursor.execute("INSERT INTO users (name) VALUES ('Santosh'), ('Amit'), ('Priya')")
        conn.commit()
        cursor.execute("SELECT * FROM users")
        result = cursor.fetchall()
        cursor.close()
        conn.close()
        return jsonify(result)
    except Exception as e:
        return jsonify({"error": str(e)})

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=5000)

6. Run the Setup

Build and start services:

docker-compose up --build

Access Flask app:

Open: http://localhost:5000 → "Hello from Flask + MySQL in Docker!"
Open: http://localhost:5000/users → returns user list from MySQL DB.

👉 This setup proves portability:

You can run it on any system with Docker & Docker Compose.
It ships Flask + MySQL together, fully isolated in containers.
No manual installation of Python/MySQL needed.

Docker Cheat Sheet

Santosh Yadav — Wed, 27 Aug 2025 06:26:52 +0000

🐳 Docker Cheat Sheet: From Beginner to Expert

Docker makes it easy to build, ship, and run applications in containers. This cheat sheet is a progressive guide — starting from the basics and moving into advanced concepts.

🔹 1. Basics

Docker

A platform to run applications in isolated environments called containers. Think of it as lightweight virtual machines.

Image

A blueprint (snapshot) of your app — contains code, dependencies, and environment setup.

Container

A running instance of an image. You can start/stop/delete it.

Docker Hub

A public registry of prebuilt images (nginx, mysql, node, etc.).

🔹 2. Installation & Setup

docker --version         # Check Docker version
docker info              # System info (containers, images, storage driver, etc.)
docker login             # Login to Docker Hub

🔹 3. Working with Images

docker pull nginx        # Download image from Docker Hub
docker images            # List images
docker rmi nginx         # Remove image
docker build -t myapp .  # Build image from Dockerfile

-t myapp → Tags the image with a name.
. → Uses current directory (Dockerfile must be here).

🔹 4. Working with Containers

docker run hello-world         # Run a test image
docker ps                      # List running containers
docker ps -a                   # List all containers (even stopped)
docker stop <id>               # Stop a container
docker rm <id>                 # Remove a container

👉 Useful Flags for docker run:

-d → Run in background (detached).
-p 8080:80 → Map host port to container port.
--name mycontainer → Give custom name.

Example:

docker run -d -p 8080:80 nginx

🔹 5. Inspect & Logs

docker logs <id>               # View container logs
docker exec -it <id> bash      # Access shell inside container
docker inspect <id>            # Detailed info (JSON)

🔹 6. Dockerfile (Build Custom Images)

A Dockerfile defines how to build your image. Example:

FROM node:18
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
CMD ["node", "server.js"]

👉 Commands used:

FROM → Base image.
WORKDIR → Working directory inside container.
COPY → Copy files from host to container.
RUN → Execute commands (install, setup).
CMD → Default command when container starts.

🔹 7. Volumes (Persistent Storage)

Containers are ephemeral (data is lost if removed). Volumes persist data.

docker volume create mydata
docker run -v mydata:/var/lib/mysql mysql

👉 Bind mount example:

docker run -v $(pwd):/app myapp

(Mounts current folder into container).

🔹 8. Networking

docker network ls                # List networks
docker network create mynetwork  # Create custom network
docker run --network=mynetwork ...

👉 Allows containers to communicate with each other.

🔹 9. Docker Compose (Multi-Container Apps)

Instead of running multiple containers manually, use docker-compose.yml:

version: "3"
services:
  db:
    image: mysql:8
    environment:
      MYSQL_ROOT_PASSWORD: root
  web:
    build: .
    ports:
      - "8080:80"
    depends_on:
      - db

Run with:

docker compose up -d
docker compose down

🔹 10. Advanced Commands

docker stats                   # Real-time CPU/memory usage
docker system prune            # Clean up unused data
docker save -o myimage.tar app # Save image to tar file
docker load -i myimage.tar     # Load image from tar file
docker cp <id>:/file .         # Copy file from container

DEV Community: Santosh Yadav

Monolithic vs Microservices Architecture

🏗 Monolithic vs Microservices Architecture – A Clear Comparison

🔹 Monolithic Architecture

✅ Advantages

⚠️ Disadvantages

🔹 Microservices Architecture

✅ Advantages

⚠️ Disadvantages

🔹 Quick Comparison

🔹 Final Thoughts

Running Flask + MySQL with Docker Compose

Flask + MySQL with Docker Compose

1. Project Structure

2. docker-compose.yml

3. flask-app/Dockerfile

4. flask-app/requirements.txt

5. flask-app/app.py

6. Run the Setup

Build and start services:

Access Flask app:

Docker Cheat Sheet

🐳 Docker Cheat Sheet: From Beginner to Expert

🔹 1. Basics

Docker

Image

Container

Docker Hub

🔹 2. Installation & Setup

🔹 3. Working with Images

🔹 4. Working with Containers

🔹 5. Inspect & Logs

🔹 6. Dockerfile (Build Custom Images)

🔹 7. Volumes (Persistent Storage)

🔹 8. Networking

🔹 9. Docker Compose (Multi-Container Apps)

🔹 10. Advanced Commands

2. `docker-compose.yml`

3. `flask-app/Dockerfile`

4. `flask-app/requirements.txt`

5. `flask-app/app.py`