Picture by Writer | Ideogram
# Introduction
You simply pushed your Python app to manufacturing, and out of the blue the whole lot 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 venture working domestically. They’re on Home windows, you developed on Mac, the manufacturing server runs Ubuntu, and in some way everybody has totally different Python variations and conflicting package deal installations.
We have all been there, frantically debugging environment-specific points as an alternative of constructing options. Docker solves this mess by packaging your complete software setting 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 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 transport containers, however to your code. Whenever you containerize a Python app, you are not simply packaging your code. You are packaging the complete runtime setting: the particular Python model, all of your dependencies, system libraries, setting variables, and even the working system your app expects.
The end result? Your app runs the identical manner in your laptop computer, your colleague’s Home windows machine, the staging server, and manufacturing. Each time. However how do you try this?
Effectively, while you’re containerizing Python apps with Docker, you do the next. You package deal your app into a transportable artifact referred to as an “picture”. Then, you begin “containers” — working cases of pictures — and run your purposes within the containerized setting.
# Constructing a Python Net API
As an alternative 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 will use in actual tasks, 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 Listing
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",
"setting": os.getenv("ENVIRONMENT", "improvement"),
"python_version": os.getenv("PYTHON_VERSION", "unknown")
}
Add the core todo performance:
@app.get("/todos", response_model=Listing[Todo])
def list_todos():
return todos
@app.put up("/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)
If you happen to 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’ve gotten your app, you could have a listing of necessities, and the particular setting 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 may 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 venture. Create a Dockerfile in your venture listing (no extension).
# Begin with a base Python picture:
FROM python:3.11-slim
# Set setting variables:
ENV PYTHONDONTWRITEBYTECODE=1
PYTHONUNBUFFERED=1
ENVIRONMENT=manufacturing
PYTHON_VERSION=3.11
# Arrange the working listing:
WORKDIR /app
# Set up dependencies (this order is essential 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
Whenever you run docker construct, you will see that every line in your Dockerfile is constructed as a layer. The primary construct would possibly take a bit as Docker downloads the bottom Python picture and installs your dependencies.
⚠️ Use
docker buildx constructto 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 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, pictures
docker system prune
# Some Docker Greatest Practices That Matter
After working with Docker in manufacturing, listed below are the practices that truly make a distinction.
At all times use particular model tags for base pictures:
# As an alternative 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
Hold your pictures 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/*
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 here 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 security measures, together with secrets and techniques administration, picture scanning, and rootless Docker. Find out about optimizing Docker pictures for sooner builds and smaller sizes. Arrange automated build-and-deploy pipelines utilizing steady integration/steady supply (CI/CD) methods comparable 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 embrace 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 group by authoring tutorials, how-to guides, opinion items, and extra. Bala additionally creates partaking useful resource overviews and coding tutorials.
