DEV Community: Adetola Hannah

Deploying a FastAPI Application with CI/CD and Nginx

Adetola Hannah — Wed, 12 Mar 2025 12:52:40 +0000

Introduction

In this blog post, we will walk through deploying a FastAPI application with a Continuous Integration (CI) and Continuous Deployment (CD) pipeline. The application will be served using Nginx as a reverse proxy.

Prerequisites

Basic knowledge of FastAPI and Python
A GitHub repository (fork the provided FastAPI template repository)
Docker installed on your machine
An Ubuntu server or cloud VM for deployment
Nginx installed on the server
GitHub Actions for CI/CD

Step 1: Clone the Repository and Create a Virtual Environment

# Clone the repository
git clone https://github.com/your-username/fastapi-book-project.git
cd fastapi-book-project

# Create and activate a virtual environment
python -m venv venv
source venv/bin/activate  # On Windows use `venv\Scripts\activate`

# Install dependencies
pip install -r requirements.txt

Step 2: Implement the Missing Endpoint

Edit main.py and add the following code:

from fastapi import FastAPI, HTTPException
from typing import Dict

app = FastAPI()

books = {
    1: {"title": "Book One", "author": "Author One"},
    2: {"title": "Book Two", "author": "Author Two"}
}

@app.get("/api/v1/{book_id}")
def get_book(book_id: int) -> Dict:
    if book_id in books:
        return books[book_id]
    raise HTTPException(status_code=404, detail="Book not found")

Step 3: Add Tests with Pytest

Create a test_main.py file in the root directory:

from fastapi.testclient import TestClient
from main import app

client = TestClient(app)

def test_get_existing_book():
    response = client.get("/api/v1/1")
    assert response.status_code == 200
    assert response.json() == {"title": "Book One", "author": "Author One"}

def test_get_nonexistent_book():
    response = client.get("/api/v1/999")
    assert response.status_code == 404
    assert response.json() == {"detail": "Book not found"}

Run the tests locally:

pytest

Step 4: Set Up the CI Pipeline with GitHub Actions

Create .github/workflows/test.yml:

name: CI Pipeline

on:
  pull_request:
    branches:
      - main

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - name: Set up Python
        uses: actions/setup-python@v2
        with:
          python-version: "3.9"
      - name: Install dependencies
        run: |
          python -m venv venv
          source venv/bin/activate
          pip install -r requirements.txt
          pip install pytest
      - name: Run tests
        run: |
          source venv/bin/activate
          pytest

Step 5: Create a Dockerfile

Create a Dockerfile:

FROM python:3.9-slim
WORKDIR /app
COPY . .
RUN pip install --no-cache-dir -r requirements.txt
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

Build and run the Docker container:

docker build -t fastapi-app .
docker run -p 8000:8000 fastapi-app

Step 6: Configure Nginx as a Reverse Proxy

Create an Nginx config file /etc/nginx/sites-available/fastapi:


nginx
server {
    listen 80;
    server_name your_domain_or_IP;

    location / {
        proxy_pass http://127.0.0.1:8000;
        proxy_set_header Host $host;
        proxy_set_h

Deploying a Simple Number Classification API with Node.js and Render

Adetola Hannah — Mon, 24 Feb 2025 21:00:38 +0000

Building and deploying an API is an essential skill for any developer, especially in DevOps. In this blog post, I will walk you through how I built and deployed a Number Classification API using JavaScript (Node.js & Express.js) and deployed it on Render

Introduction

The Number Classification API is a lightweight RESTful service built with Node.js and Express.js. It takes a number as input and returns its classification: positive, negative, or zero. This API is useful for educational purposes, small-scale applications, and learning the basics of API development.

Setting Up the Project

To get started, clone the repository from GitHub:

$ git clone https://github.com/ajalaadetola/number-classification-api.git
$ cd number-classification-api

Next, install the required dependencies:

$ npm install

Understanding the Code

Let's break down the core logic of the API. The main entry point of the application is index.js. Here’s a look at its key components:

1. Importing Dependencies

const express = require('express');
const app = express();

We use Express.js to set up a simple web server.

2. Creating the Classification Logic

// API Endpoint
app.get("/api/classify-number", async (req, res) => {
    const { number } = req.query;

    // Validate input: Ensure the number is provided and valid
    if (!number || isNaN(number)) {
        return res.status(400).json({ 
            number,  // ✅ Include the invalid input as it was received
            error: "Invalid number" 
        });
    }

    const num = Number(number); // Convert to a valid number

    const properties = [];
    if (isArmstrong(num)) properties.push("armstrong");
    properties.push(num % 2 === 0 ? "even" : "odd");

    const funFact = await getFunFact(num);

    // ✅ Fix: Ensure digit_sum is numeric, even for negative numbers
    const digitSum = Math.abs(num)
        .toString()
        .split("")
        .filter(char => !isNaN(char)) // Remove non-numeric characters like "-"
        .reduce((sum, digit) => sum + parseInt(digit), 0);

    res.json({
        number: num,
        is_prime: isPrime(num),
        is_perfect: isPerfect(num),
        properties,
        digit_sum: digitSum,
        fun_fact: funFact
    });
});

3. Running the Server

const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
    console.log(`Server running on port ${PORT}`);
});

This sets up the server to listen on port 3000 or an environment-specified port.

Testing the API

You can test the API locally using Postman or your web browser. Start the server:

$ node index.js

Then, open your browser and enter the following URL:

http://localhost:3000/api/classify-number?number=10

You should receive a response like:

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

Deploying the API on Render

You can deploy this API using Render, a cloud hosting platform that provides seamless deployment for Node.js applications.

Steps to Deploy on Render:

Create an account on Render.
Click New Web Service and connect your GitHub repository.
Select the repository number-classification-api.
Set the runtime environment to Node.js.
Configure the start command as:

   node index.js

Click Deploy and wait for the build to complete.

Once deployed, Render will provide a public URL where your API can be accessed.

Conclusion

This simple Number Classification API demonstrates how to build and deploy a basic REST API using Node.js and Express.js. By understanding the fundamentals of request handling and data validation, you can extend this project further—perhaps by integrating a machine learning model for more complex classifications.

Check out the full code on GitHub: Number Classification API 🚀.

Happy coding! 🎉

My Journey Deploying an NGINX Web Server: HNG Internship DevOps Stage 0

Adetola Hannah — Fri, 31 Jan 2025 14:18:25 +0000

Introduction
Starting my journey in the HNG DevOps Internship was both exciting and challenging. The first task, "DevOps Stage 0," required me to set up and configure an NGINX web server on a cloud platform. This task tested my ability to work with Linux servers, web server configurations, and deployment processes. In this post, I’ll share my approach, the challenges I faced, and how this experience aligns with my professional goals.

Task Overview
The goal was to install NGINX on an Ubuntu server and configure it to serve a custom HTML page. The HTML page needed to display:
Welcome to DevOps Stage 0 - [Adetola Ajala]/[Annie]
Additionally, the task required documentation of the entire process in a well-written blog post.

My Approach

Create a Linux Server on any cloud provider of your choice, for this article, i used the AWS cloud provider and launched an EC2 instance running on Ubuntu server 24.04 LTS.

Installing and Configuring NGINX:To ensure a smooth setup, I updated and upgraded the server packages.

Once installed, I verified that NGINX was running:

It displayed "active (running)", meaning my server was ready to serve web pages.

Creating a Custom HTML Page Next, I customized the default NGINX web page. I edited the index.html file:

After saving the file, I restarted NGINX:

then to ensure my application was running properly on the server, i went to the IP address of the server

Personal Growth from the HNG Internshp DevOps Stage 0 Task
This task has been a great learning experience, strengthening my Linux server management, troubleshooting, and web server configuration skills. I now have a better understanding of NGINX, firewall settings, and networking concepts.

Encountering and resolving challenges—like ensuring NGINX served the correct page and configuring firewall rules—helped improve my problem-solving abilities. Additionally, writing this blog enhanced my technical documentation skills, which are crucial for any DevOps role.

Overall, this task has boosted my confidence and motivation to explore automation, CI/CD pipelines, and cloud deployments in my DevOps journey.

Lessons Learned
🔹 Server Management: This task improved my skills in setting up an Ubuntu server, installing software, and configuring services.
🔹 Troubleshooting: I encountered and resolved issues related to firewall settings, browser caching, and file permissions.
🔹 Web Server Basics: I now understand how NGINX works and how to serve static web pages.

References
As part of the task, I referenced the following resources:

https://hng.tech/hire/devops-engineers
https://hng.tech/hire/cloud-engineers