An open API service indexing awesome lists of open source software.

https://github.com/filipe-oliveiraa/message-queue

The |Message Queue System| is a simple API-based system for message management, developed as part of a project to demonstrate skills in cloud-native technologies, DevOps, and Kubernetes. This project focuses on building a functional and scalable application using best practices in development, containerization, and orchestration.
https://github.com/filipe-oliveiraa/message-queue

Last synced: 2 months ago
JSON representation

The |Message Queue System| is a simple API-based system for message management, developed as part of a project to demonstrate skills in cloud-native technologies, DevOps, and Kubernetes. This project focuses on building a functional and scalable application using best practices in development, containerization, and orchestration.

Awesome Lists containing this project

README

        

# Message Queue Application

## Description

The **Message Queue Application** is a lightweight, containerized backend application built with FastAPI to efficiently handle and manage messaging queues. It demonstrates the use of modern containerization techniques with **Docker** and **Kubernetes** for deployment, scaling, and load balancing.

---

## Table of Contents

- [Getting Started](#getting-started)
- [Features](#features)
- [Running the Application](#running-the-application)
- [Local Setup](#local-setup)
- [Using Docker](#using-docker)
- [Using Kubernetes](#using-kubernetes)
- [Scaling the Application](#scaling-the-application)
- [Testing Load Balancing](#testing-load-balancing)
- [Technologies Used](#technologies-used)

---

## Getting Started

### Prerequisites

1. Install **Python 3.11+**.
2. Install **Docker**.
3. Install **Minikube**.
4. Install **kubectl** for Kubernetes cluster management.

---

## Features

1. **FastAPI Backend**:
- Manage message queues with lightweight endpoints.

2. **Containerized Deployment**:
- Fully containerized using Docker.

3. **Scalable Architecture**:
- Leverages Kubernetes for horizontal scaling.

4. **Load Balancing**:
- Automatic traffic distribution across multiple pods.

---

## Running the Application

### Local Setup

1. Clone the repository:
```bash
git clone
cd message-queue
```

2. Install dependencies:
```bash
python -m venv venv
source venv/bin/activate # On Windows: venv\Scripts\activate
pip install -r requirements.txt
```

3. Run the application locally:
```bash
uvicorn app.main:app --host 0.0.0.0 --port 8000
```

### Using Docker

1. Build the Docker image:
```bash
docker build -t message-queue:latest .
```

2. Run the container:
```bash
docker run -p 8000:8000 message-queue:latest
```

### Using Kubernetes

1. Start Minikube and use the Docker driver:
```bash
minikube start --driver=docker
```

2. Build the Docker image in Minikube's Docker environment:
```bash
eval $(minikube docker-env)
docker build -t message-queue:latest .
```

3. Apply Kubernetes configurations:
```bash
kubectl apply -f kubernetes/deployment.yaml
kubectl apply -f kubernetes/service.yaml
```

4. Get the Minikube service URL:
```bash
minikube service message-queue-service --url
```

---

## Scaling the Application

To scale the application horizontally in Kubernetes:

1. Use the `kubectl scale` command:
```bash
kubectl scale deployment message-queue --replicas=
```
Replace `` with the desired number of pods (e.g., 3).

2. Verify the scaling:
```bash
kubectl get pods
```

3. Ensure functionality by testing endpoints and observing traffic distribution (see Load Balancing section).

---

## Testing Load Balancing

1. Obtain the Minikube service URL:
```bash
minikube service message-queue-service --url
```

2. Send multiple requests to the service URL:
```bash
curl http://
```

3. Monitor pod logs to confirm distributed requests:
```bash
kubectl logs -f
```
Replace `` with the names of different pods. Requests should be distributed across pods.

4. View the enabled pods:
```bash
kubectl get pods
```
This command lists all active pods in the cluster, showing their names, statuses, and other details.

---

## Technologies Used

- **FastAPI**: For the backend application.
- **SQLite**: Lightweight database for queue management.
- **Docker**: Containerization of the application.
- **Kubernetes**: Deployment, scaling, and load balancing.
- **Minikube**: Local Kubernetes cluster setup.

---