DEV Community: Olasubomi Onasanwo

Microservices Application Containerization and Infrastructure Automation

Olasubomi Onasanwo — Wed, 19 Mar 2025 13:46:20 +0000

Project Overview
This project successfully accomplished the containerization and automated deployment of a microservices-based TODO application. The implementation followed modern DevOps practices, utilizing container technologies, infrastructure as code, and configuration management to create a seamless deployment pipeline.
Key Achievements
Application Containerization

Forked and enhanced the original TODO application repository
Created optimized Dockerfiles for each microservice component:

Frontend (Vue.js)
Auth API (Go)
Todos API (Node.js)
Users API (Java/Spring Boot)
Log Message Processor (Python)
Redis Queue

Implemented a comprehensive docker-compose.yml configuration for single-command application startup
Configured Traefik as a reverse proxy with automated SSL certificate management
Established secure endpoints with proper domain routing

Infrastructure Automation

Developed a dedicated infrastructure repository with Terraform and Ansible configurations
Created modular Terraform code for provisioning cloud resources with appropriate security configurations
Implemented Ansible roles for:

System dependencies installation (Docker, Docker Compose)
Application deployment and configuration
SSL/TLS setup with Traefik integration

Achieved complete end-to-end automation with single-command deployment
Produced detailed documentation for infrastructure setup and management

Technical Implementation Details
The solution implements a modern microservices architecture with containerized components, each running in its own Docker container. The infrastructure code provisions the necessary cloud resources and configures the deployment environment, ensuring consistency and repeatability. The entire system can be deployed with a single terraform apply -auto-approve command, demonstrating the power of infrastructure as code.
Technologies Used

Docker and Docker Compose for containerization
Terraform for infrastructure provisioning
Ansible for configuration management
Traefik for reverse proxy and SSL management
Various programming languages (Vue.js, Go, Node.js, Java, Python)

Results
The completed project demonstrates a production-ready microservices application with proper security measures, scalable architecture, and automated deployment capabilities. This implementation showcases advanced DevOps skills and provides a solid foundation for future enhancements.
Project Links

Application Repository: https://github.com/hngprojects/DevOps-Stage-4.git
Infrastructure Repository: https://github.com/sdrock83/DevOps-Stage-4-Infrastructure.git

This project successfully met all the requirements specified in the Stage 4 task, including containerization, secure domain configuration, infrastructure automation, and single-command deployment.

Task
DevOps Stage 4 Task: Containerize, Deploy, and Automate a Microservices TODO ApplicationOverview
This task consists of two parts:
1. Containerizing a microservices application (in a forked repository)
2. Creating infrastructure automation code (in a new repository)
Part 1: Application Containerization

Repository Setup • Fork the original application repository from: GITHUB REPOSITORY • Clone your forked repository to your local machine • Make all containerization changes in this repository
Application Components • Frontend (Vue.js) • Auth API (Go) • Todos API (Node.js) • Users API (Java/Spring Boot) • Log Message Processor (Python) • Redis Queue
Containerization Tasks • Create Dockerfiles for each service in their respective folders • Set up docker-compose.yml in the root directory • Ensure the application builds with a single command: docker-compose up -d
Domain & SSL Configuration • Configure a custom domain for the application • Set up Traefik as reverse proxy • Implement HTTP to HTTPS redirection • Configure endpoints: ◦ Frontend: https://domain.com ◦ Auth API: https://auth.domain.com or https://domain.com/api/auth ◦ Todos API: https://todos.domain.com or https://domain.com/api/todos ◦ Users API: https://users.domain.com or https://domain.com/api/users
Expected Behaviors • Login page should be accessible at your custom domain • Successful login should redirect to TODO dashboard • Direct API access should return: ◦ Auth API: "Not Found" response ◦ Todos API: "Invalid Token" message ◦ Users API: "Missing or invalid Authorization header"
Push Changes • Commit and push all your changes to your forked repository Part 2: Infrastructure as Code and Configuration Management
New Repository Creation • Create a new repository specifically for infrastructure code • This repository should contain all Terraform and Ansible files
Terraform Module • Create Terraform configurations to: ◦ Provision cloud server(s) ◦ Configure security groups ◦ Dynamically create Ansible inventory files ◦ Trigger Ansible playbook execution after provisioning
Ansible Module Create Ansible roles for: • Dependencies Role: ◦ Installing Docker, Docker Compose, and other required dependencies • Deployment Role: ◦ Cloning the application repository (your forked repo from Part 1) ◦ Executing Docker Compose to deploy the application ◦ Setting up SSL/TLS with Traefik
Single Command Deployment • The entire infrastructure setup and application deployment should be executable with a single command: terraform apply -auto-approve • This command should provision infrastructure, configure the server, and deploy the application automatically
README Documentation • Create a detailed README.md file in the infrastructure repository with: ◦ Setup instructions ◦ Requirements ◦ Description of the infrastructure and deployment process ◦ Any environment variables or configuration needed Submission Requirements
Repository URLs • Forked application repository URL (Part 1) • New infrastructure repository URL (Part 2)
Required Screenshots • Login page at domain.com • TODO dashboard after successful login • Successful Terraform and Ansible playbook execution
URLs to Submit • Both GitHub repository links • Frontend application URL Grading Criteria
Application Repository Validation • Proper Dockerfile configuration for all services • Working docker-compose.yml • All required services present and properly containerized
Infrastructure Repository Validation • Well-structured Terraform modules • Properly implemented Ansible roles • Successful single-command deployment (terraform apply -auto-approve)
Endpoint and Functionality Validation • Working application with proper routing • Secure endpoints (HTTPS) • Successful login and TODO dashboard access

Deploying a FastAPI Application with Docker and Nginx: A Comprehensive Guide

Olasubomi Onasanwo — Mon, 17 Feb 2025 23:47:53 +0000

This project demonstrates the deployment of a modern web API using FastAPI, a high-performance Python web framework, integrated with industry-standard DevOps practices. The core application is a book management system that allows users to perform CRUD (Create, Read, Update, Delete) operations on a collection of books, with each book containing details such as title, author, publication year, and genre. The system maintains data consistency through a structured schema and provides RESTful endpoints for interacting with the book inventory.
The deployment architecture showcases the implementation of containerization using Docker and reverse proxy configuration using Nginx, essential components in modern web application deployment. The solution utilizes Docker Compose for container orchestration, managing two main services: the FastAPI application and an Nginx reverse proxy. This setup ensures proper request routing, header management, and service isolation, while maintaining high availability and scalability. The deployment process includes comprehensive configuration of server headers, network settings, and proper integration between the FastAPI service and Nginx proxy, demonstrating a production-ready implementation that follows DevOps best practices.

Prerequisites

AWS EC2 instance (Ubuntu 22.04)
Basic knowledge of Python, Docker, and Nginx
Domain name (optional)

System Architecture
Our deployment stack consists of:

FastAPI application serving the API
Nginx acting as a reverse proxy
Docker containers for isolation and portability
Docker Compose for service orchestration

Step 1: Server Setup
1.1 Launch EC2 Instance

Launch Ubuntu 22.04 EC2 instance
Configure security groups:
HTTP (80) : 0.0.0.0/0
HTTPS (443) : 0.0.0.0/0
SSH (22) : Your IP

1.2 Connect to Server
ssh -i your-key.pem ubuntu@your-ec2-public-ip

1.3 Update System
sudo apt update
sudo apt upgrade -y

Step 2: Installing Required Software
2.1 Install Python and Virtual Environment

Install Python 3

sudo apt install python3 python3-pip -y

Install venv

sudo apt install python3.10-venv -y

Create virtual environment

python3 -m venv venv

Activate virtual environment

source venv/bin/activate

2.2 Install Docker and Docker Compose

Install Docker

sudo apt install docker.io -y

Install Docker Compose

sudo apt install docker-compose -y

Add user to docker group

sudo usermod -aG docker $USER

Verify installations

docker --version
docker-compose --version

Step 3: Application Setup
3.1 Clone and Configure Project

Clone project repository

git clone your-repository-url
cd fastapi-book-project

Create project structure

mkdir -p api/db api/routes

3.2 Create Application Files
main.py
from fastapi import FastAPI
from fastapi.middleware.cors import CORSMiddleware
from api.router import router

app = FastAPI(
title="Book Management API",
description="A simple API for managing books",
version="1.0.0"
)

app.add_middleware(
CORSMiddleware,
allow_origins=[""],
allow_credentials=True,
allow_methods=[""],
allow_headers=["*"],
)

app.include_router(router)

api/router.py
from fastapi import APIRouter
from api.routes import books

router = APIRouter()

router.include_router(
books.router,
prefix="/api/v1/books",
tags=["books"]
)

Step 4: Docker Configuration
4.1 Create Dockerfile
FROM python:3.12-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
EXPOSE 8000
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

4.2 Create docker-compose.yml
version: '3.8'
services:
fastapi-app:
build: .
container_name: fastapi_app
restart: always
networks:
- app_network

nginx:
image: nginx:alpine
container_name: fastapi_nginx
ports:
- "80:80"
volumes:
- ./nginx.conf:/etc/nginx/conf.d/default.conf
depends_on:
- fastapi-app
networks:
- app_network

networks:
app_network:
driver: bridge

Step 5: Nginx Configuration
5.1 Create nginx.conf
server {
listen 80;
server_name your-domain;

proxy_hide_header Server;
add_header Server nginx always;

location /api/v1/books {
    proxy_pass http://fastapi-app:8000/api/v1/books/;
    proxy_set_header Host $host;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header X-Forwarded-Proto $scheme;
}

location / {
    proxy_pass http://fastapi-app:8000;
    proxy_set_header Host $host;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header X-Forwarded-Proto $scheme;
}

}

Step 6: Deployment
6.1 Build and Start Services

Build images

docker-compose build

Start services

docker-compose up -d

Verify services

docker-compose ps

6.2 Check Logs

Check FastAPI logs

docker-compose logs fastapi-app

Check Nginx logs

docker-compose logs nginx

Step 7: Testing
7.1 API Endpoint Testing

Test list endpoint

curl http://your-domain/api/v1/books/

Test single book endpoint

curl http://your-domain/api/v1/books/1

Test server headers

curl -I http://your-domain/api/v1/books/

7.2 Browser Testing
Navigate to http://your-domain/docs
Test endpoints through Swagger UI

Step 8: Maintenance and Monitoring
8.1 View Container Stats
docker stats
8.2 Monitor Logs
docker-compose logs -f

8.3 Backup Configuration

Backup important files

tar -czf backup.tar.gz docker-compose.yml nginx.conf Dockerfile

Best Practices

Security

Keep Docker and system packages updated
Use specific container versions
Implement proper firewall rules

Performance

Enable Nginx caching when appropriate
Monitor resource usage
Implement rate limiting

Maintenance

Regular backups
Log rotation
Health checks

Conclusion
This deployment architecture provides a robust, scalable solution for hosting FastAPI applications. The combination of Docker containers and Nginx reverse proxy ensures:

Isolated application environment
Proper request handling
Scalability options
Easy maintenance

Regular monitoring and maintenance will ensure optimal performance and reliability of your deployed application.

Number Classification API: A Smart Way to Classify Numbers

Olasubomi Onasanwo — Fri, 07 Feb 2025 11:07:38 +0000

Number Classification API: A Smart Way to Classify Numbers

Introduction

Numbers are more than just digits; they have fascinating properties that make them unique. Whether a number is prime, perfect, or an Armstrong number, these properties can reveal interesting mathematical patterns. To automate this classification process, we built the Number Classification API, a powerful yet simple API that categorizes numbers based on their mathematical properties and even provides fun facts about them!

This blog post will walk you through the features, use cases, and how you can start using the API today.

What is the Number Classification API?

The Number Classification API is a RESTful web service that allows users to classify numbers based on predefined mathematical rules. Given any number as input, the API will return structured JSON output containing its properties and an interesting fact.

Key Features

✅ Checks if a number is prime
✅ Identifies perfect numbers
✅ Detects Armstrong numbers
✅ Computes the sum of digits
✅ Provides an interesting fun fact about the number
✅ Simple and lightweight API with fast response times

How It Works

The API takes a number as input via a simple HTTP request and returns a JSON response with detailed classifications.

Example Request

curl "http://your-api-domain/api/classify-number?number=153"

Example Response

{
"number": 153,
"is_prime": false,
"is_perfect": false,
"properties": ["armstrong", "odd"],
"digit_sum": 9,
"fun_fact": "153 is a narcissistic number."
}

Deployment & Technology Stack

The Number Classification API is hosted on an AWS EC2 instance and is powered by:

Flask (Python) – for the backend framework

Gunicorn & Nginx – for efficient web server performance

Ubuntu – as the cloud-hosted environment

Deployment Architecture

The Flask application runs behind Gunicorn, a Python WSGI server.

Nginx is used as a reverse proxy to forward client requests to Gunicorn.

The API is hosted on AWS EC2, making it publicly accessible.

Use Cases & Applications

The Number Classification API can be integrated into various applications:

🎯 Math Education Apps – Helps students explore number properties interactively.
🎯 Data Science Projects – Useful for classifying numerical datasets based on their properties.
🎯 Puzzle & Game Development – Can be used to generate challenges and logic-based puzzles.
🎯 Trivia & Chatbots – Enhances AI bots with number-based trivia.

How to Get Started

You can start using the Number Classification API in just a few simple steps:

1️⃣ Clone the repository from GitHub:

git clone https://github.com/yourusername/number-classification-api.git

2️⃣ Install dependencies:

cd number-classification-api
python3 -m venv venv
source venv/bin/activate
pip install -r requirements.txt

3️⃣ Start the API locally:

python3 app.py

4️⃣ Deploy on an EC2 instance and set up Nginx & Gunicorn for production.

Future Enhancements

We plan to enhance the API with:

Factorization feature – Breaking down numbers into their prime factors.

More mathematical classifications – Including sequences and perfect squares.

User authentication & rate limiting – For better security and API access control.

Conclusion

The Number Classification API is a practical tool for number lovers, educators, and developers. Whether you’re working on a math-related project or just curious about the properties of numbers, this API provides instant insights.

🚀 Give it a try, integrate it into your projects, and let us know your thoughts!

👉 Check out the GitHub Repo: https://github.com/Subby12/apiserver

Documenting My Experience with NGINX Installation and Configuration

Olasubomi Onasanwo — Fri, 31 Jan 2025 16:33:12 +0000

Introduction
This post details the installation and configuration of the NGINX web server as part of a DevOps assignment, enhancing technical skills and offering insights into web server management.
Approach to Completing the Task

Step 1: Launching an Ubuntu Instance on AWS
The process began by logging into the AWS Management Console and launching an Ubuntu Server instance. The t2.micro instance type was selected for the free tier, with the security group configured to allow HTTP traffic on port 80.

Step 2: Connecting to the Instance
After launching the instance, the connection was established using SSH, authenticating with the key pair created during setup.

Step 3: Installing NGINX
With a successful connection, the package index was updated, and NGINX was installed using:

sudo apt update
sudo apt install nginx -y

Step 4: Starting and Enabling NGINX
Once installed, the service was started and enabled to launch on boot:

sudo systemctl start nginx
sudo systemctl enable nginx
The status of NGINX was checked to confirm it was running without errors.

Step 5: Creating a Custom HTML Page
A custom HTML page was created to serve as the default welcome message. The index.html file was placed in the /var/www/html directory with the following content:

<!DOCTYPE html>

Welcome to DevOps Stage 0 - Onas/Subomi

Step 6: Testing the NGINX Configuration
To ensure proper setup, the configuration was tested for syntax errors:

sudo nginx -t

NGINX was then reloaded to apply changes, allowing access to the custom page via the public IP address of the instance.

Challenges Faced and Solutions
Firewall Configuration
An initial challenge involved ensuring the security group rules allowed HTTP traffic. This was resolved by adjusting the settings in the AWS console.
Syntax Errors in HTML
A mistake in the HTML tag structure caused rendering issues. After testing the NGINX configuration, the error was identified and corrected.

Contribution to Learning and Professional Goals

This task significantly contributed to learning and professional goals:
Hands-on Experience: Practical experience in deploying a web server is crucial for any DevOps Engineer . “Visit: https://hng.tech/hire/devops-engineers"

Problem-Solving Skills: Overcoming challenges improved troubleshooting abilities.

Understanding Web Technologies: This exercise deepened understanding of web technologies and their interactions.

Conclusion
In summary, the installation and configuration of NGINX provided valuable learning experiences that enhanced technical skills and problem-solving abilities, beneficial for future projects and career pursuits in DevOps.