Forem: Aglili Selorm Cecil

Fastapi from localhost to production (part 1)

Aglili Selorm Cecil — Wed, 16 Apr 2025 12:38:54 +0000

Deploying FastAPI to a VPS: Part 1 - Building and Dockerizing

I'm starting this series to walk through how I deploy my FastAPI apps to a VPS. Getting stuff from your local machine to a live server can be a bit of a headache, so I figured I'd document my process using the tools I've found work best.

Tools I'm using:

FastAPI: My go-to Python framework
Docker: Because you have to know it😂
Docker Compose: We'll use this in part 2 to manage multiple containers
Gunicorn: The production server for Python apps
Uvicorn: Needed for FastAPI's async magic, but we'll run it under Gunicorn's supervision

What we're covering in Part 1:

Setting up a basic FastAPI app
Testing locally with Gunicorn (the way we'll run it in production)
Dockerizing everything with multi-stage builds to keep our images small

Step 1: Project Setup and Environment

First, let's get our project structure and virtual environment going:

# Create the project directory
mkdir fast-microservice

# Navigate into the new directory
cd fast-microservice

# Create a Python virtual environment
# (Use python3 -m venv venv if virtualenv command is not available)
virtualenv venv

# Activate the virtual environment
# On Windows use: .\venv\Scripts\activate
source venv/bin/activate

Step 2: Install Dependencies

We need a few packages to get started:

# Install necessary Python packages
pip install fastapi "uvicorn[standard]" gunicorn pydantic

# Freeze the installed packages and versions into requirements.txt
pip freeze > requirements.txt

Step 3: Create the FastAPI Application

Let's create our main app file:

touch main.py

Here's the code for our basic user management API:

from fastapi import FastAPI,HTTPException
from pydantic import BaseModel
from typing import List, Optional
from fastapi.middleware.cors import CORSMiddleware
from fastapi.responses import JSONResponse
import logging 

# Configure logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

app = FastAPI(
    title="Fast Microservice",
    description="A simple FastAPI microservice for user management",
    version="1.0.0",
)

class UserCreate(BaseModel):
    name: str
    email: str

# Use a separate model for output data (includes the ID)
class User(UserCreate):
    id: int

# --- In-Memory Storage ---
# A simple list to act as our database for this example
# In a real app, you'd use a database.
users_db: List[User] = []
next_user_id = 1 # Simple ID counter

# --- CORS Middleware ---
# Allows requests from any origin (useful for frontend development)
# For production, you might want to restrict this to specific origins.
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"], # Allows all origins
    allow_credentials=True,
    allow_methods=["*"], # Allows all methods (GET, POST, etc.)
    allow_headers=["*"], # Allows all headers
)

# --- API Endpoints ---
@app.get("/health", summary="Check service health")
async def health_check():
    """
    Simple health check endpoint.
    """
    logger.info("Health check endpoint called")
    return {"status": "ok"}

@app.post("/users", response_model=User, status_code=201, summary="Create a new user")
async def create_user(user_data: UserCreate):
    """
    Creates a new user if email doesn't exist and limit is not reached.
    """
    global next_user_id 
    logger.info(f"Attempting to create user with email: {user_data.email}")

    # Simple validation examples
    if len(users_db) >= 100:
        logger.warning("User limit reached. Cannot create more users.")
        raise HTTPException(status_code=400, detail="User limit reached")

    if any(u.email == user_data.email for u in users_db):
        logger.warning(f"Email {user_data.email} already exists.")
        return JSONResponse(content={"error": "Email already exists"}, status_code=400)

    new_user = User(id=next_user_id, **user_data.dict())
    users_db.append(new_user)
    next_user_id += 1 # Increment ID for the next user
    logger.info(f"User {new_user.email} created successfully with ID {new_user.id}")
    return new_user


@app.get("/users", response_model=List[User], summary="Get all users")
async def get_users():
    """
    Retrieves a list of all created users.
    """
    logger.info(f"Retrieving all {len(users_db)} users.")
    return users_db

Step 4: Local Testing with Gunicorn

Before we move to the docker part, let's make sure our app works with Gunicorn:

gunicorn main:app \
  --workers 4 \
  --worker-class uvicorn.workers.UvicornWorker \
  --bind 0.0.0.0:8000

Quick breakdown:

main:app - points to the app variable in main.py
--workers 4 - I usually go with 2x CPU cores + 1, but adjust as needed
--worker-class uvicorn.workers.UvicornWorker - this is the magic that lets Gunicorn handle FastAPI's async stuff
--bind 0.0.0.0:8000 - listen on all interfaces (important for Docker)

Hit up http://localhost:8000/docs in your browser to see the Swagger UI. You can test creating users and retrieving the list.

Once you're done, hit Ctrl+C to stop the server.

Step 5: Dockerizing with a Multi-Stage Build

Now for the fun part - let's containerize our app with a multi-stage build to keep things lean:

touch Dockerfile

Here's my Dockerfile:

# --- Stage 1: Builder ---
# Use a specific Python version slim image as the base for building
FROM python:3.11-slim AS builder
LABEL stage=builder

# Set the working directory inside the container
WORKDIR /app

# Copy only the requirements file first to leverage Docker cache
COPY requirements.txt .

# Install Python dependencies
# Using --no-cache-dir reduces image size slightly
# Using --prefix=/install makes it easy to copy installed packages later
RUN pip install --no-cache-dir --prefix=/install -r requirements.txt


# --- Stage 2: Runtime ---
# Use the same slim Python image for the final runtime environment
FROM python:3.11-slim

# Set the working directory
WORKDIR /app

# Copy installed packages from the builder stage's /install directory
COPY --from=builder /install /usr/local

# Copy the application code into the container
COPY . .

# Copy the startup script and make it executable
COPY start.sh /app/start.sh
RUN chmod +x /app/start.sh

# Create a non-root user for security best practices
RUN addgroup --system nonroot && adduser --system --ingroup nonroot nonroot
USER nonroot

# Expose the port the application will run on
EXPOSE 8000

# Set environment variables (optional but good practice)
ENV PYTHONUNBUFFERED=1 
ENV PYTHONPATH=/app  

# Command to run the application using the startup script
CMD ["/app/start.sh"]

Why multi-stage? Simple - I want the smallest possible production image. The first stage installs all dependencies, then the second stage only copies what we need, leaving behind all the build tools and cache. Plus, we run as a non-root user for better security.

Step 6: Create the Startup Script

Let's create a simple script to launch Gunicorn:

touch start.sh

And here's what goes in it:

#!/bin/bash

# Exit immediately if a command exits with a non-zero status.
set -e

# Print a message to the logs
echo "Starting application with Gunicorn..."

# Execute Gunicorn
exec gunicorn main:app \
  --workers 4 \
  --worker-class uvicorn.workers.UvicornWorker \
  --bind 0.0.0.0:8000

Step 7: Build and Run the Docker Container

Finally, let's see this thing in action:

# Build the Docker image
docker build -t fast-microservice .

# Run a container from the image
docker run -d -p 8000:8000 --name fast-app fast-microservice

Check the logs to make sure everything started up correctly:

docker logs fast-app

Now try http://localhost:8000/docs again - should work just like before, but now it's running in Docker!

When you're done playing around:

docker stop fast-app
docker rm fast-app

Wrapping Up

In the next part of this series, I'll show you how to use Docker Compose with Traefik as a reverse proxy to handle HTTPS and routing. This setup has served me well for managing multiple services on a single VPS.

Drop a comment if you run into any issues!

Who Will Bell the Cat? - What I Learned in 2024

Aglili Selorm Cecil — Mon, 30 Dec 2024 10:11:11 +0000

This year was probably one of the best years of my life so far. I loved the most part of it, learnt a lot of things too and i thought it would be wise to share and document the lessons i learnt.

Always Volunteer to Bell the Cat

From the popular story, the mice in a certain kingdom's lives were threatened by a cat. They held a meeting to decide how to protect themselves. Eventually, they came up with a clever idea: to put a bell around the cat's neck, so they would be alerted whenever the cat was on the move. However, when the time came to volunteer for the mission, no one stepped forward. They were all afraid of losing their lives should the cat wake up.

This year i learnt the importance of stepping up to do the "hard" or "difficult" work. It’s through these challenges that we grow and truly learn. Everything we know today was once difficult when we first started, and by taking on tasks that seem intimidating, we open the door to new opportunities and personal development.

Consistency is growth

At the beginning of doing these "hard/difficult" things, the urge to give up is very strong because we don’t see immediate results. I often end up doubting my skills and abilities. That’s where consistency comes in. If you did the same thing for one hour every day for a month, by the 30th day, you’d be doing that thing with ease. Most of the things we consume on social media promise us easy success, but as the saying goes, "All good things take time."

Don't to fight things you don't control

One of the biggest lessons I learned this year is the importance of letting go of things beyond my control. Life has a way of throwing unexpected challenges our way—situations, people, or outcomes that we cannot influence no matter how hard we try. Fighting these uncontrollable circumstances only leads to frustration, stress, and wasted energy.

Instead, I’ve learned to focus on what I can control: my attitude, my actions, and how I respond to adversity. Accepting that some things are simply out of my hands has brought me a sense of peace and clarity. It has also helped me channel my energy into productive efforts, rather than getting stuck in a cycle of resistance and negativity.

As the Stoics often say, “You cannot control the wind, but you can adjust your sails.” This mindset doesn’t mean giving up—it means choosing your battles wisely and finding strength in the areas where you do have power.

Summary
Each experience, whether good or challenging, has taught me something valuable. I hope you find these useful and perhaps offer some guidance or inspiration as you continue your own journey. Wishing you a happy new year

Demystifying the Python Datetime Library

Aglili Selorm Cecil — Wed, 22 May 2024 05:45:53 +0000

The python datetime library is a standard library package that comes with classes for manipulating or working with date and time.

In this 4 part guide we are going to look at the 4 basic classes this library comes with and how to work with them. These classes are

1.datetime.datetime
2.datetime.date
3.datetime.timedelta
4.datetime.time

PART ONE

datetime.datetime Class

a datetime is an object which consists of the combination of a date object and a time object.To create a datetime object:

#import datetime library
from datetime import datetime

#creating a datetime object
datetime_object = datetime(year,month,day,hour=0,minute=0,second=0,
microsecond=0,tzinfo=None)

# year : MINYEAR <= year <= MAXYEAR 
# month: 1 <= month <= 12
# hour : 0 <= hour < 24,
# minute : 0 <= minute < 60 
# second : 0 <= second < 60
# microsecond: 0 <= microsecond < 1000000

# if we wanted to create a datetime object for 1 January 1999 
date = datetime(1999,1,1)
print(date) 
result => 1999-01-01 00:00:00

Note

hour,minute,second and microsecond are optional and default to zero
Any argument outside the specified ranges raise a ValueError

This class has some useful methods too
datetime.now() : this returns the datetime object for the current moment.

time_now = datetime.now()
print(time_now)
result => 2024-05-21 15:49:17.632276

datetime.fromisoformat(): Return a datetime corresponding to a date_string in any valid ISO 8601 format, with the following exceptions.

date_string = "2024-05-21 15:49:17.632276"
result = datetime.fromisoformat(date_string)
print("Result Year": result.year)
print("Result Month": result.month)
=>Result Year : 2024
=>Result Month : 5

datetime.strptime(): Parses a string representation of a date/time and returns a datetime object.

date_string = "21/05/2024 15:49"
format_string = "%d/%m/%Y %H:%M"
parsed_date = datetime.strptime(date_string, format_string)
print(parsed_date)  

result => 2024-05-21 15:49:00

datetime.strftime(): Parses a datetime object into a string given a specific format

now = datetime.now()
format_string = "%A, %d %B %Y %I:%M %p"
formatted_date = now.strftime(format_string)
print(formatted_date)
result => Tuesday, 21 May 2024 03:49 PM

for more information on the datetime formatting codes refer to w3 schools

My First Month As A Software Engineer

Aglili Selorm Cecil — Sun, 05 May 2024 11:53:03 +0000

INTRODUCTION

Like most people in the tech space that I have come across, my journey with tech or computers started as a kid.I had lots of interest in computers and I have carried that interest till this day.

FIRST IMPRESSIONS

As someone who has built or worked with personal projects a lot, every time I see a new codebase the first thing that comes to mind is that "there’s a lot to learn". This is because there's always something newer or something simpler than how I would usually do it. In my first week, I felt overwhelmed by most of the tasks but after that I started to get hold of the standards or inputs that were required of me.

ON-BOARDING EXPERIENCE

My onboarding experience was such a calm journey, my seniors and colleagues really made me feel at home and explained most of the things and standards to me. They also took me through the tools we use and all other stuff I would need to know. As an introvert I barely spoke or asked questions because i was shy but i'm gradually fitting in.

TECHNICAL CHALLENGES

Even though I was abreast with OOP, I soon realised it wasn't the standard that I was required to have. I also realised my SQL skills would be put to a test because I only got my hands dirty with "ORMS". So far I have been putting in effort to quickly get the above skills so I can effectively contribute to my team

LEARNING CURVE

So far the learning curve has been okay, this is because i'm quite knowledgeable with most of the technologies or frameworks we use here. I have also been passed some resources I could use to speed up my learning process

COLLABORATION AND TEAM DYNAMICS

When I started, I was given the basic tasks to perform so as to build some "stamina". In the past weeks I have been given actual tasks that require research and lots of logic to build. I have also been allowed to take some decisions on how things should be and when the team didn't agree, I am made to understand why my decision or choice was not good enough.Interacting with my seniors has given me a specific line of thought to take when I try to tackle or solve problems

ACHIEVEMENTS

No major achievements but I have been able to close all the tickets i have been assigned without making a mess of anything.

GROWTH

I can say I have experienced some level of growth in several aspects. A few of them include my confidence , problem solving skills, time management and communication.

CONCLUSION

So far I have enjoyed my experience at the workplace, the people, the benefits and the learning experience make me happy. Sometimes we may not even remember the simplest things and sometimes we write 100+ lines and everything works on the first run. Everyday isn't the same, we can only try our best and if things don't go well we try another day.