A Light Introduction to Docker for Python Builders

Picture by Writer | Ideogram

# Introduction

 
You simply pushed your Python app to manufacturing, and instantly 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 perhaps you are onboarding a brand new developer who spends three days simply making an attempt to get your undertaking working domestically. They’re on Home windows, you developed on Mac, the manufacturing server runs Ubuntu, and someway everybody has totally different Python variations and conflicting package deal installations.

We have all been there, frantically debugging environment-specific points as a substitute of constructing options. Docker solves this mess by packaging your total software atmosphere right into a container that runs identically all over the 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 use Docker to simplify software growth. You may additionally learn 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 complete 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 approach in your laptop computer, your colleague’s Home windows machine, the staging server, and manufacturing. Each time. However how do you do this?

Effectively, once you’re containerizing Python apps with Docker, you do the next. You package deal your app into a transportable artifact known as an “picture”. Then, you begin “containers” — working situations 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 sensible Python software. We’ll construct a easy FastAPI-based todo API (with Uvicorn because the ASGI server) that demonstrates the patterns you will use in actual initiatives, and use Pydantic for information validation.

In your undertaking 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 Checklist
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", "growth"),
        "python_version": os.getenv("PYTHON_VERSION", "unknown")
    }

Add the core todo performance:

@app.get("/todos", response_model=Checklist[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)

In case you run this domestically with pip set up -r necessities.txt && python app.py, you will have an API working domestically. Now let’s proceed to containerize the applying.

# Writing Your First Dockerfile

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

Consider it as a recipe to construct a picture from the totally different elements of your undertaking. Create a Dockerfile in your undertaking 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 net 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 finest 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 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 will 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 identify as a substitute 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 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 here are the Docker instructions you will 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 Greatest Practices That Matter

 
After working with Docker in manufacturing, listed below are the practices that really 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

Maintain your photographs lean by cleansing up package deal 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 lined the basics, however Docker’s ecosystem is huge. Listed here are the following areas to discover. For manufacturing deployments, find out about container orchestration platforms like Kubernetes or cloud-specific companies like AWS Elastic Container Service (ECS), Google Cloud Run, or Azure Container Cases.

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

Joyful 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 occasional! At present, she’s engaged on studying and sharing her information with the developer neighborhood by authoring tutorials, how-to guides, opinion items, and extra. Bala additionally creates partaking useful resource overviews and coding tutorials.