A Mild Introduction to Docker for Python Builders

Picture by Creator | 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 exams in CI, however now it is throwing mysterious import errors in manufacturing. Sound acquainted? Or possibly you are onboarding a brand new developer who spends three days simply making an attempt to get your mission working regionally. They’re on Home windows, you developed on Mac, the manufacturing server runs Ubuntu, and by some means everybody has completely 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 whole software atmosphere right into a container that runs identically in all places. No extra “works on my machine” excuses. No extra spending weekends debugging deployment points. This text introduces you to Docker and the way you need to use Docker to simplify software improvement. You may additionally discover ways to containerize a easy Python software 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 your entire runtime atmosphere: the precise Python model, all of your dependencies, system libraries, atmosphere variables, and even the working system your app expects.

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

Properly, while you’re containerizing Python apps with Docker, you do the next. You bundle your app into a conveyable artifact known as an “picture”. Then, you begin “containers” — working cases of photographs — and run your purposes within the containerized atmosphere.

# Constructing a Python Internet API

 
As a substitute of beginning with toy examples, let’s containerize a practical Python software. 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 mission 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",
        "atmosphere": 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.put up("/todos", response_model=Todo)
def create_todo(todo_data: TodoCreate):
    international 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):
    international 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 regionally with pip set up -r necessities.txt && python app.py, you may have an API working regionally. Now let’s proceed to containerize the applying.

# Writing Your First Dockerfile

 
You’ve gotten your app, you have got a listing of necessities, and the precise atmosphere to your app to run. So how do you go from these disparate parts into one Docker picture that comprises each your code and dependencies? You may specify this by writing a Dockerfile to your software.

Consider it as a recipe to construct a picture from the completely different parts of your mission. Create a Dockerfile in your mission listing (no extension).

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

# Set atmosphere 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 software code:
COPY . .

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

This Dockerfile builds a Python internet software 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 Operating Your First Container

 
Now let’s construct and run our containerized software:

# 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 may go to http://localhost:8000 to see in case your API is working 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 working containers
docker ps

# View container logs
docker logs myapp-container

# Get a shell inside a working 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, photographs
docker system prune

# Some Docker Finest Practices That Matter

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

All the time use particular model tags for base photographs:

# 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

Preserve your photographs 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/*

All the time 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, study container orchestration platforms like Kubernetes or cloud-specific providers like AWS Elastic Container Service (ECS), Google Cloud Run, or Azure Container Cases.

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

Completely satisfied 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! At the moment, 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.