A Mild Introduction to Docker for Python Builders

Picture by Writer | Ideogram

# Introduction

 
You simply pushed your Python app to manufacturing, and abruptly every thing breaks. The app labored completely in your laptop computer, handed all assessments in CI, however now it is throwing mysterious import errors in manufacturing. Sound acquainted? Or perhaps you are onboarding a brand new developer who spends three days simply making an attempt to get your venture operating domestically. They’re on Home windows, you developed on Mac, the manufacturing server runs Ubuntu, and one way or the other everybody has totally different Python variations and conflicting bundle installations.

We have all been there, frantically debugging environment-specific points as an alternative of constructing options. Docker solves this mess by packaging your total utility surroundings right into a container that runs identically in every single place. No extra “works on my machine” excuses. No extra spending weekends debugging deployment points. This text introduces you to Docker and the way you should utilize Docker to simplify utility improvement. You will additionally learn to containerize a easy Python utility utilizing Docker.

🔗 Hyperlink to the code on GitHub

# How Docker Works and Why You Want It

 
Consider Docker as analogous to delivery containers, however to your code. Once you containerize a Python app, you are not simply packaging your code. You are packaging the complete runtime surroundings: the precise Python model, all of your dependencies, system libraries, surroundings variables, and even the working system your app expects.

The outcome? Your app runs the identical method in your laptop computer, your colleague’s Home windows machine, the staging server, and manufacturing. Each time. However how do you try this?

Properly, whenever you’re containerizing Python apps with Docker, you do the next. You bundle your app into a conveyable artifact referred to as an “picture”. Then, you begin “containers” — operating cases of photos — and run your purposes within the containerized surroundings.

# Constructing a Python Net API

 
As a substitute of beginning with toy examples, let’s containerize a practical Python utility. We’ll construct a easy FastAPI-based todo API (with Uvicorn because the ASGI server) that demonstrates the patterns you may use in actual initiatives, and use Pydantic for information validation.

In your venture listing, create a necessities.txt file:

fastapi==0.116.1
uvicorn[standard]==0.35.0
pydantic==2.11.7

Now let’s create the fundamental app construction:

# app.py
from fastapi import FastAPI
from pydantic import BaseModel
from typing import Record
import os

app = FastAPI(title="Todo API")
todos = []
next_id = 1

Add information fashions:

class TodoCreate(BaseModel):
    title: str
    accomplished: bool = False

class Todo(BaseModel):
    id: int
    title: str
    accomplished: bool

Create a well being test endpoint:

@app.get("https://www.kdnuggets.com/")
def health_check():
    return {
        "standing": "wholesome",
        "surroundings": os.getenv("ENVIRONMENT", "improvement"),
        "python_version": os.getenv("PYTHON_VERSION", "unknown")
    }

Add the core todo performance:

@app.get("/todos", response_model=Record[Todo])
def list_todos():
    return todos

@app.submit("/todos", response_model=Todo)
def create_todo(todo_data: TodoCreate):
    world next_id
    new_todo = Todo(
        id=next_id,
        title=todo_data.title,
        accomplished=todo_data.accomplished
    )
    todos.append(new_todo)
    next_id += 1
    return new_todo

@app.delete("/todos/{todo_id}")
def delete_todo(todo_id: int):
    world todos
    todos = [t for t in todos if t.id != todo_id]
    return {"message": "Todo deleted"}

Lastly, add the server startup code:

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)

For those who run this domestically with pip set up -r necessities.txt && python app.py, you may have an API operating domestically. Now let’s proceed to containerize the applying.

# Writing Your First Dockerfile

 
You’ve got your app, you have got an inventory of necessities, and the precise surroundings to your app to run. So how do you go from these disparate elements into one Docker picture that comprises each your code and dependencies? You’ll be able to specify this by writing a Dockerfile to your utility.

Consider it as a recipe to construct a picture from the totally different elements of your venture. Create a Dockerfile in your venture listing (no extension).

# Begin with a base Python picture:
FROM python:3.11-slim

# Set surroundings variables:
ENV PYTHONDONTWRITEBYTECODE=1 
    PYTHONUNBUFFERED=1 
    ENVIRONMENT=manufacturing 
    PYTHON_VERSION=3.11

# Arrange the working listing:
WORKDIR /app

# Set up dependencies (this order is vital for caching):
COPY necessities.txt .
RUN pip set up --no-cache-dir -r necessities.txt

# Copy your utility code:
COPY . .

# Expose the port and set the startup command:
EXPOSE 8000
CMD ["python", "app.py"]

This Dockerfile builds a Python net utility container. It makes use of Python 3.11 (slim model) picture as the bottom, units up a working listing, installs dependencies from necessities.txt, copies the app code, exposes port 8000, and runs the applying with python app.py. The construction follows greatest practices by putting in dependencies earlier than copying code to make use of Docker’s layer caching.

# Constructing and Working Your First Container

 
Now let’s construct and run our containerized utility:

# Construct the Docker picture
docker construct -t my-todo-app .

# Run the container
docker run -p 8000:8000 my-todo-app

Once you run docker construct, you may see that every line in your Dockerfile is constructed as a layer. The primary construct may take a bit as Docker downloads the bottom Python picture and installs your dependencies.

⚠️ Use docker buildx construct to construct a picture from the directions within the Dockerfile utilizing BuildKit.

The -t my-todo-app flag tags your picture with a greater title as an alternative of a random hash. The -p 8000:8000 half maps port 8000 contained in the container to port 8000 in your host machine.

You’ll be able to go to http://localhost:8000 to see in case your API is operating inside a container. The identical container will run identically on any machine that has Docker put in.

# Important Docker Instructions for Every day Use

 
Listed below are the Docker instructions you may use most frequently:

# Construct a picture
docker construct -t myapp .

# Run a container within the background
docker run -d -p 8000:8000 --name myapp-container myapp

# View operating containers
docker ps

# View container logs
docker logs myapp-container

# Get a shell inside a operating container
docker exec -it myapp-container /bin/sh

# Cease and take away containers
docker cease myapp-container
docker rm myapp-container

# Clear up unused containers, networks, photos
docker system prune

# Some Docker Finest Practices That Matter

 
After working with Docker in manufacturing, listed below are the practices that really make a distinction.

At all times use particular model tags for base photos:

# As a substitute of this
FROM python:3.11

# Use this
FROM python:3.11.7-slim

Create a .dockerignore file to exclude pointless information:

__pycache__
*.pyc
.git
.pytest_cache
node_modules
.venv
.env
README.md

Maintain your photos lean by cleansing up bundle managers:

RUN apt-get replace && apt-get set up -y --no-install-recommends 
    build-essential 
    && rm -rf /var/lib/apt/lists/*

At all times run containers as non-root customers in manufacturing.

# Wrapping Up

 
This tutorial coated the basics, however Docker’s ecosystem is huge. Listed below are the subsequent areas to discover. For manufacturing deployments, find out about container orchestration platforms like Kubernetes or cloud-specific providers like AWS Elastic Container Service (ECS), Google Cloud Run, or Azure Container Situations.

Discover Docker’s safety features, together with secrets and techniques administration, picture scanning, and rootless Docker. Find out about optimizing Docker photos for quicker builds and smaller sizes. Arrange automated build-and-deploy pipelines utilizing steady integration/steady supply (CI/CD) methods corresponding to GitHub Actions and GitLab CI.

Comfortable studying!
 
 

Bala Priya C is a developer and technical author from India. She likes working on the intersection of math, programming, information science, and content material creation. Her areas of curiosity and experience embody DevOps, information science, and pure language processing. She enjoys studying, writing, coding, and low! Presently, she’s engaged on studying and sharing her data with the developer neighborhood by authoring tutorials, how-to guides, opinion items, and extra. Bala additionally creates participating useful resource overviews and coding tutorials.