Docker Chapter 1: A Beginner's Introduction to Containerization.

wizcoderx — Sun, 06 Jul 2025 13:07:29 +0000

As a software developer , I've discovered that Docker has become an indispensable tool in my development workflow. Let me break down what Docker is, why you should use it, and how it revolutionizes traditional software development.

What is Docker?

Technical Definition: Docker is a containerization platform that allows you to package your applications or microservices into lightweight, portable containers. These containers can then be deployed and started (or "spun up") across different environments.

Simple Explanation: Think of Docker as a standardized shipping container for your software. Just like how physical shipping containers can be moved from ships to trucks to trains without unpacking, Docker containers can run your application on any system that has Docker installed.

When you containerize your application, it gets stored in what we call a container (this terminology is crucial in technical communication). You can then distribute this container to clients or team members, and they can simply "UP" or start the services with a single command.

For example, if you've built a microservice using FastAPI, once someone starts your Docker container, they can:

Access your API endpoints by sending requests with the required payload
View the interactive Swagger UI documentation
Use your service without worrying about local setup complexities

Why Should You Use Docker?

The answer is simple: efficiency and reliability. As developers, we know that life is short, and time spent on complex deployment processes is time taken away from actual development.

Docker eliminates the "it works on my machine" problem. Once you containerize your application, you can be confident it will run consistently across different environments. This reliability becomes especially important when working with AI/ML applications that often have complex dependency requirements.

Advantages Over Traditional Software Development

1. Code Security and Intellectual Property Protection

Your source code remains secure within the container. Clients receive a packaged application without access to your underlying codebase, reducing concerns about code piracy or intellectual property leaks.

2. Cross-Platform Compatibility

Here's where Docker truly shines. Traditional development often faces the challenge: "Will my Linux-developed application run on a Mac?" or "What about Windows compatibility?"

Docker abstracts away these OS-level differences. Whether you develop on:

Linux
Windows
macOS

Your containerized application will run consistently across all these platforms. Docker handles the underlying OS dependencies and compatibility issues, so you don't have to worry about platform-specific implementations.

3. Dependency Management

Docker bundles your application with all its dependencies, libraries, and runtime requirements. This means no more version conflicts or missing dependencies on deployment machines.

4. Scalability and Resource Efficiency

Containers are lightweight compared to virtual machines, allowing you to run multiple instances of your application efficiently. This is particularly valuable for microservices architectures.

Real-World Impact

In my experience developing applications, Docker has been a game-changer. AI models often require specific Python versions, CUDA drivers, and various ML libraries. Docker ensures that these complex environments are reproducible and portable.

Next Steps

Docker fundamentals are just the beginning. In my next article Chapter 2, I'll provide hands-on examples of containerizing a real application developed in fast api, including:

Writing effective Dockerfiles
Managing multi-container applications with Docker Compose
Best practices for production deployments

If you are not aware of fastapi take a look at this article before moving towards Chapter 2 - Getting Started with FastAPI: A Beginner’s Guide Using Python

Getting Started with FastAPI: A Beginner’s Guide Using Python 🐍

wizcoderx — Sun, 01 Jun 2025 13:26:17 +0000

Introduction to FastAPI

Imagine you're at a restaurant. You tell the waiter your order, and the waiter communicates it to the kitchen and brings back your food. FastAPI works just like that waiter. It is a modern, high-performance web framework for building APIs with Python, letting your app/application talk to other apps/applications efficiently.

Official FastAPI Docs

So, why FastAPI instead of Flask or Django REST?

Because FastAPI is as fast as Node.js and Go, uses Python type hints for validation, generates automatic docs, and is asynchronous by design. Compared to Flask, it's more scalable out of the box. Unlike Django REST Framework, it's minimal and lightning fast.

In the real world, FastAPI is used in production by companies building GenAI backends, microservices, ML model deployment, and startups that need to move fast with clean code and performance in mind.

Implementation

To follow along, make sure Python is installed on your system. You can download it from python.org.

We'll use a virtual environment (venv) to isolate dependencies — this helps avoid breaking your global packages and keeps the project clean.

Next, we'll use PyCharm IDE Community Edition, because the community edition is free :) — it offers smart code suggestions, automatic virtual environment detection, and built-in terminal, making Python development smooth and efficient. You can download it from PyCharm Download and search for PyCharm Community Edition.

Now, let's build your first FastAPI app:

Create a folder named fastapi_intro
Open PyCharm and create a new Python project inside that folder. OR right-click on the folder and click "open with PyCharm", this will create a main.py file automatically.
Open the terminal inside PyCharm which is mostly at the bottom left of the screen and run:

python -m venv venv
source venv/bin/activate  # or venv\Scripts\activate on Windows
pip install fastapi uvicorn

Create a file named main.py if it doesn't exist

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def read_root():
    return {"message": "Hello, FastAPI"}

Run it using the below command in terminal:

uvicorn main:app --reload

Open your browser and go to http://127.0.0.1:8000/docs — FastAPI auto-generates interactive Swagger docs! 🎉

A Quick Note on BaseModel

Before we jump into the mini project, let's understand this line:

from pydantic import BaseModel

FastAPI uses Pydantic for data validation. BaseModel lets you define the structure of the data your API expects. When a request is made, FastAPI uses that model to:

Validate the input (e.g., check if it's an int)
Parse and document it automatically in the Swagger UI

Think of it as a Python class that ensures your API only accepts clean, structured data — no manual checks needed!

Think of BaseModel like a blueprint for incoming data — it tells FastAPI exactly what shape the data should be. Just like a form with required fields, it checks the input and throws an error if something's missing or incorrect.

Mini Project: Simple Calculator API

Let's build a mini calculator with two FastAPI endpoints — one for addition and one for subtraction.

Step-by-step:

NOTE: Installing the correct version of Pydantic is important, so before proceeding with the following step, kindly install Pydantic version 2.

Run the following in your terminal (inside your virtual environment):

pip uninstall pydantic
pip install "pydantic<2.0.0"

Update your main.py:

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class Numbers(BaseModel):
    number_1: int
    number_2: int

@app.post("/add")
def add(numbers: Numbers):
    result = numbers.number_1 + numbers.number_2
    return {
        "number_1": numbers.number_1,
        "number_2": numbers.number_2,
        "result": str(result)
    }

@app.post("/subtract")
def subtract(numbers: Numbers):
    result = numbers.number_1 - numbers.number_2
    return {
        "number_1": numbers.number_1,
        "number_2": numbers.number_2,
        "result": str(result)
    }

Run the server again:

uvicorn main:app --reload

Test both endpoints at http://127.0.0.1:8000/docs using the Swagger UI.

Your input JSON:

{
  "number_1": 10,
  "number_2": 5
}

Expected output:

{
  "number_1": 10,
  "number_2": 5,
  "result": "15"
}

If you want an in-depth understanding of the above code, then please read the below; otherwise, jump to the Challenge section.

In-Depth Analysis of Code:

1. In-depth Explanation (What the Code Does)

This code creates a simple API with FastAPI that exposes two endpoints: one to add and one to subtract two numbers. The FastAPI() class sets up the web app. Then, using BaseModel from Pydantic, a class Numbers is defined which describes the shape of the input data — expecting two integers. When a POST request is made to either /add or /subtract, FastAPI automatically parses the JSON input based on Numbers, validates that number_1 and number_2 are both integers with the help of BaseModel, and injects the validated data into the corresponding function (add or subtract). The function then performs the calculation and returns a JSON response containing the input values and the result as a string. FastAPI also auto-generates interactive docs based on this setup using Swagger.

2. Analogy (Line-by-Line Intuition)

Think of building a tiny calculator counter inside a digital restaurant.

from fastapi import FastAPI: This is like setting up the front desk where people come in with requests.
from pydantic import BaseModel: This brings in the clipboard where we write down what kind of form customers must fill out.
app = FastAPI(): You're now opening the restaurant and saying "we're ready to take orders!"
class Numbers(BaseModel): ...: This is the form customers must fill, saying: "Please give me two whole numbers to work with."
@app.post("/add"): You're putting up a sign at a counter saying "For addition, hand your form here."
def add(numbers: Numbers):: The chef (your function) picks up the form and sees the numbers written.
result = numbers.number_1 + numbers.number_2: The chef does the math using the values from the form.
return {...}: The waiter hands back a neat receipt showing the input numbers and the final total.

Same goes for the /subtract counter — it's just a different chef doing subtraction instead of addition.

Challenge:

Now it's your turn!

Create two more endpoints:

/multiply
/divide

Try writing them yourself — and post your versions in the comments section! 💬

What's Next?

In the next chapter, we will see how we can use FastAPI with GenAI apps like Gemini API to ask questions and get responses back from it.

Stay tuned. It's wizcoderx!

DEV Community: wizcoderx