How rewyekha/python-microservices-app works
Based on our analysis of the file tree and README, this project is a Python-based microservices application called “video-converter” that converts mp4 videos to mp3. It is designed to run on AWS EKS using Kubernetes and Helm for deployment. The architecture uses several microservices and external components (databases and a message broker) to manage a complete end-to-end video conversion workflow.
Main Components
• AWS EKS Cluster – Represent the deployment environment where all Kubernetes workloads (node groups, pods, etc.) run.
• Helm Charts – Show separate Helm charts for managing external services like MongoDB, PostgreSQL, and RabbitMQ.
• Microservices:
• Auth Service (“auth-service”): Handles authentication, deployed via its own manifest with Dockerfile and associated configuration.
• Gateway Service (“gateway-service”): Acts as the API gateway handling requests (login, file upload/download) and redirects to respective services.
• Converter Service (“converter-service”): Contains the logic for converting mp4 videos to mp3. It interacts with RabbitMQ queues (named “mp3” and “video”) for asynchronous processing.
• Notification Service (“notification-service”): Responsible for sending status updates and notifications (e.g., via email and 2FA).
• External Systems:
• Databases: PostgreSQL and MongoDB (for storing application data); each has its own Helm chart with configuration and initialization (init.sql for Postgres).
• Message Broker: RabbitMQ, used for queuing video conversion tasks.
Relationships and Interactions
• When a user logs in or uploads a video, the request flows through the Gateway Service.
• The Gateway Service then interacts with the Auth Service for authentication.
• Upon successful verification, the upload triggers the Converter Service which reads from a designated queue (“video”) in RabbitMQ.
• The Converter Service processes the video (conversion from mp4 to mp3) and may then trigger notification messages or use the “mp3” queue for delivering results.
• Data persistence happens via MongoDB and PostgreSQL as needed.
• Connections to external messaging (RabbitMQ) and database connection flows from Helm charts to the relevant microservices.
Architectural Patterns & Design Principles
• Microservices Architecture: Emphasize the separation of concerns between discrete services (auth, gateway, converter, notification).
• Containerization & Orchestration: Represent Docker containers for each service and Kubernetes as the platform orchestrating these containers.
• Declarative Infrastructure: Highlight that all services and external components are deployed using Helm charts and Kubernetes manifests.
• Messaging Driven: Indicate usage of RabbitMQ for decoupling and asynchronous communication (message queuing for conversion tasks).
Including Technologies, Frameworks, and Libraries
• Technologies: AWS EKS, Kubernetes, Helm, Docker.
• Databases: MongoDB, PostgreSQL.
• Messaging: RabbitMQ.
• Programming Language: Python (evident from requirements.txt and Python-based code in each service).
• Other: Kubernetes manifests for deployment, ConfigMaps, Secrets, and volume definitions as part of Helm charts.
Overall Detail and Clarity
• As many components as possible to represent all parts of the system. Avoid oversimplification—include every subsystem mentioned (from Helm charts for MongoDB, PostgreSQL, RabbitMQ to each microservice’s manifest deployments).
• How the system’s components are interconnected in the AWS EKS environment.