Flask REST API with Redis, Celery & MongoDB

Building robust and production-grade backend APIs is not just about CRUD operations it’s about scalability, modularity, and performance.
In this project, I built Flask InkCircle, a backend REST API setup that goes beyond CRUD, using Flask + MongoDB + Celery + Redis, containerized via Docker and deployed securely with Nginx + Let’s Encrypt + DuckDNS on AWS EC2.

🧩 Project Overview

🔗 Repo: github.com/kuldeepghorpade05/flask-InkCircle-beyond-crud

This project represents a production-ready Flask backend architecture complete with authentication, background task handling, and a CI-friendly folder structure.
It’s built from scratch with modular design and scalability in mind.

⚙️ Tech Stack Breakdown

🧱 Project Structure

flask-InkCircle-beyond-crud/
│
├── celery_tasks.py               # Celery background task definitions
├── docker-compose.yml            # Multi-container orchestration
├── Dockerfile                    # Flask app Docker build
├── poetry.lock                   # Poetry lock file for dependencies
├── pyproject.toml                # Project + dependency management
├── requirements.txt              # Exported dependencies (for fallback)
├── run.py                        # Flask app entry point
├── README.md                     # Project documentation
│
└── src/
    ├── app.py                    # Application factory & route registration
    ├── config.py                 # App configuration (env, DB URI, etc.)
    ├── extensions.py             # Initialize DB, JWT, CORS, etc.
    ├── errors.py                 # Global error handlers
    │
    ├── auth/                     # Authentication module
    │   ├── routes.py
    │   ├── service.py
    │   ├── schemas.py
    │   ├── utils.py
    │   ├── dependencies.py
    │   └── __init__.py
    │
    ├── books/                    # Book module (CRUD, search, etc.)
    │   ├── routes.py
    │   ├── service.py
    │   ├── schemas.py
    │   └── __init__.py
    │
    ├── reviews/                  # Review module
    │   ├── routes.py
    │   ├── service.py
    │   ├── schemas.py
    │   └── __init__.py
    │
    ├── tags/                     # Tag management module
    │   ├── routes.py
    │   ├── service.py
    │   ├── schemas.py
    │   └── __init__.py
    │
    ├── db/                       # Database layer (models, connection)
    │   ├── models.py
    │   └── __init__.py
    │
    └── __init__.py

Additional Files

• run.py → Flask entry command

• celery_tasks.py → Celery worker setup

• Dockerfile → Defines container build

• docker-compose.yml → Multi-container orchestration

• .env → Environment variables

• pyproject.toml → Poetry-managed dependencies

🐍 Dependency Management with Poetry

Instead of pip and requirements.txt, I used Poetry for cleaner and reproducible environments.

✅ Advantages of Poetry

• Automatically manages dependency versions

• Creates isolated virtual environments

• Simplifies build and deployment pipelines

# Install dependencies
poetry install

# Add new package
poetry add flask pymongo redis celery flask-jwt-extended flask-cors

🐳 Dockerization

The app is fully Dockerized with separate containers for:

• Flask app (web)

• Redis (message broker)

• Celery worker (background task runner)

docker-compose.yml

version: '3.8'

services:
  web:
    build: .
    container_name: flask_inkcircle_app
    restart: always
    env_file:
      - .env
    ports:
      - "8000:8000"
    depends_on:
      - redis
    networks:
      - app-network
    volumes:
      - ./src:/app/src
      - ./celery_tasks.py:/app/celery_tasks.py
      - ./run.py:/app/run.py
    command: python run.py

  redis:
    image: redis:7-alpine
    container_name: redis
    restart: always
    ports:
      - "6379:6379"
    networks:
      - app-network
    volumes:
      - redis_data:/data

  celery:
    build: .
    container_name: celery_worker
    env_file:
      - .env
    command: celery -A celery_tasks.celery worker --loglevel=info
    depends_on:
      - redis
      - web
    networks:
      - app-network
    volumes:
      - ./src:/app/src
      - ./celery_tasks.py:/app/celery_tasks.py

networks:
  app-network:
    driver: bridge

volumes:
  redis_data:

🔁 Run the App

docker-compose up -d --build

This builds and runs all containers in the background.

🔐 Deployment & HTTPS Setup

The entire stack was deployed on AWS EC2 (Ubuntu) with Nginx as a reverse proxy.

Key steps:

1. Installed Nginx and configured reverse proxy

2. Used Certbot (Let’s Encrypt) for automatic SSL

3. Mapped custom domain using DuckDNS

4. Redirected all HTTP → HTTPS for security

sudo certbot --nginx -d kuldeepghorpade-flask-inkcircle.duckdns.org

✅ SSL renewed automatically via Certbot
✅ Nginx forwards all requests to port 8000 (Flask inside Docker)

🔑 Authentication & Security

• JWT-based Authentication (flask-jwt-extended)

• API key security can be integrated for frontend access control

• HTTPS enforced via Nginx

• Tokens expire periodically, requiring re-login for safety

🌐 Frontend Integration

A minimal frontend (React or Vanilla JS) can easily consume these REST APIs.
Even if hosted separately (e.g., Netlify or Vercel), HTTPS ensures secure communication.

🔀 Git Branching & CI-Readiness

• main → stable production code

• dockerized-app → container-focused branch for CI/CD

• Used git merge dockerized-app to sync production-ready setup

• Ready for pipeline integration with GitHub Actions

🚀 Conclusion

With Flask InkCircle, I built a complete backend architecture not just for CRUD, but for scalable, synchronous, and secure backend development.

It’s a great foundation for any Flask-based microservice or API-first application.

💡 Highlights

• 🧠 Modular Flask REST architecture

• 📦 Poetry-managed dependencies

• 🐳 Dockerized setup with Redis & Celery

• 🌐 Nginx reverse proxy + HTTPS (Let’s Encrypt)

• ☁️ Deployed on AWS EC2 with DuckDNS

• 🔒 JWT Auth + Secure HTTPS endpoints

• 🔀 Git branching for CI/CD readiness

🟢 Live: https://kuldeepghorpade-flask-inkcircle.duckdns.org/

📘 Docs: https://kuldeepghorpade-flask-inkcircle.duckdns.org/docs

Connect with me

• GitHub

• LinkedIn