Getting Started with Docker for Python Developers

by Marvellous Kalu

.

Updated Sat Dec 09 2023

Getting Started with Docker for Python Developers

Imagine building an app from scratch that works perfectly on your machine and sharing it with a colleague only to get this message: “Oops! It doesn't run on my machine”. One look at that message, and you head over to access the app on your machine to access it properly, and it runs perfectly on your machine.

This kind of issue is the solution docker provides to the software development space. Docker helps developers build, distribute, and run applications effortlessly across diverse environments, eliminating the need for several complex configurations or management of the development environment.

For Python developers, docker enables them to package their applications along with their dependencies, necessary libraries, and runtime and ensures they run consistently across various environments from development to production. This fosters seamless collaboration and simplifies deployment and the overall development workflow.

In recent years, Docker has gained increasing popularity in the software space. The containerization approach provided by Docker and its compatibility with various programming languages has made it the second most-loved development platform by developers, according to a survey by StackOverflow in 2019.

Understanding Docker Fundamentals: 

Docker is an open-source tool that allows developers to package their applications and their corresponding dependencies into isolated containers that can be distributed and run seamlessly across diverse environments.

Docker provides the following advantages for Python developers:

  • Portability and consistency: Docker containers ensure applications behave the same way everywhere - from a developer’s laptop to a production server

  • Isolation: Containers reduce conflicts that may arise between different applications as they enfold applications and their dependencies and provide isolation from the underlying infrastructure.

  • Resource Efficiency: Compared to virtual machines, Docker is resource efficient as it shares the host OS kernel and thus makes containers lightweight.

  • Scalability: Docker enforces the scalability of applications as multiple containers can run at once.

  • Ease of Deployment: Docker simplifies the deployment process by enclosing the entire application stack into a container that can run on any machine.

  • Lastly, Docker streamlines collaboration, facilitates version control and enhances the overall development workflow.

name

custom

title

The Definitive Guide To Docker

description

In this docker tutorial, you will learn docker from scratch to an advanced level, starting from the concept of containerization to Docker Compose in Docker.

url

https://masteringbackend.com/posts/docker-tutorial

Docker Basics for Python Developers (Components of Python):

You need to understand the various components of Docker to enable you to get the big picture and effectively use it.

The components of Docker include:

Docker Image

A Docker image is a static, read-only package containing the essential instructions to create and run a Docker container. It is the foundation for creating  Docker containers and also aids in creating a consistent and reproducible environment for applications across several machines and stages of the software development cycle.

Docker Container

A Docker Container is a runtime instance of a Docker image. It wraps an application into an invisible box with every dependency needed to run that application, ensuring consistency and portability across several environments. Docker Container can be modified by adding or removing files and storing runtime data.

The major difference between the Image and the container is that the image is the static plan that sets the environment, and the container is the dynamic and running instance based on that plan that can be run and modified as needed.

Docker Registry

The Docker Registry is a system that serves as a centralized repository where developers can store(push), share, and pull Docker images. It is essential as it ensures developers can easily access and use the software applications created by others. 

Some popular Docker registries include Docker Hub, Google Container Registry, and Amazon Elastic Container Registry, among many others.

Docker Compose

The Docker Compose is a tool that assists you in defining and managing multi-container Docker applications. It simplifies running a project with multiple containers by allowing you to specify all the services, networks, and volumes needed for your application in a single YAML file.

Docker Client and Server

Docker runs using a client-server architecture. Docker client is the command-line tool or the graphical user interface that allows users to send commands to the Docker server (daemon) and manage Docker resources. The Docker server, or the Docker daemon, is a background process that manages Docker containers on a system. It is responsible for listening to Doker API requests and building, running, and managing containers.

Dockerizing a Simple Python Application: Step-by-Step Guide

This section will build a simple Python number guessing, write a Dockerfile, build a Docker image, and run and interact with the Docker container.

Creating a Python Application:

We will create a simple number-guessing game. This game will prompt the user to guess a randomly generated number within a range of 1 - 20 and provide hints after each guess. 

Three attempts are linked to the user, and the game ends after the user has exhausted their attempts. The user gets informed if their guesses were correct or not. Let’s build this game.

  1. Create a new file and name it “game.py”.

  2. In the game.py file, import the random module that helps us generate a random number.

import random
  1. Define a function that will encapsulate the entire game. 

    def number_guessing_game():
  1. In the number_guessing_game function, you are to generate a number as the secret number using the randint function from the random module. Next, set the number of guesses allowed and store it in a variable. Lastly, print a welcome message that will be displayed immediately after the user logs in and print the instructions for the game.

    # Generate a random number between 1 and 10 (you can change the range if needed)
        secret_number = random.randint(1, 20)
       
        # Set the number of allowed guesses
        max_attempts = 3
       
        print("Welcome to the Number Guessing Game!")
        print(f"Try to guess the secret number between 1 and 20. You have {max_attempts} attempts.")
  2. Create a for loop that iterates over the range of attempts (from 1 to max_attempts).

  3. Within the for loop, prompt the user to input their guess and convert it to an integer. Construct a if-else block to perform the following actions: Verify if the user's guess matches the secret number. Print a congratulatory message and conclude the loop using the break statement if it does. If the user's guess is incorrect, offer hints regarding whether the guess is too low or too high.

Additionally, if the user has exhausted the maximum number of attempts without guessing correctly, print a message unveiling the correct number and terminate the loop.

for attempt in range(1, max_attempts + 1):
        # Get the user's guess
        guess = int(input("Enter your guess: "))
       
        # Check if the guess is correct
        if guess  secret_number:
            print(f"Congratulations! You guessed the correct number ({secret_number})!")
            break
        elif guess < secret_number:
            print("Too low. Try again.")
        else:
            print("Too high. Try again.")
       
        # Check if it's the last attempt
        if attempt  max_attempts:
            print(f"Sorry, you've run out of attempts. The correct number was {secret_number}. Better luck next time.")
            break
  1. Call the number_guessing_game function.

    number_guessing_game()

When the game is played, we get this result.

Writing the Dockerfile

To write the Dockerfile for your project, create a Dockerfile in the same folder as your game.py.

Open the Dockerfile and enter the command below.

FROM python:3.11

ADD game.py .

CMD [ "python", "./game.py" ]

The Dockerfile specifies the base image of your Docker image python:3.11 using the instruction` FROM`. In this case, it is designated python 3.11 as the base. The instruction ADD copies the game.py file from the local directory into the container's root directory (`.`). 

Lastly, the instruction CMD [ "python", "./game.py" ] specifies the command to run upon container startup. This tutorial initiates the Python interpreter with the argument ./game.py, effectively launching the number-guessing game when the container is started. 

In the Dockerfile, the left side of each line represents an instruction, and the right side represents its corresponding argument.

Building a Docker Image

After writing your Dockerfile, the next step is building the image. To build the Docker image, use the below

docker build -t number-guessing-game .

Here is a breakdown of this command:

  • docker build is a command used to build the Docker image.

  • -t number-guessing-game is a command that assigns the name number-guessing-game to the Docker image.

  • (`.`) specifies the path to the Dockerfile's directory. That is our current directory (`.`).

Running and Interacting with the Docker Container

To run the container, use the command below

docker run -t number-guessing-game

This runs the container and gives the output below.

One limitation is that we cannot interact with the application, which does not allow us to explore the game since we can’t enter any input. To resolve this issue, we need to use the interaction command.

Interacting with the Container

To interact with the container, use the command below

docker run -t -i number-guessing-game

This command runs the container and aids us in interacting with it effectively.

9 Docker Commands Every Python Developer Should Know

The following are some commands every Python developer should know to use Docker effectively.

Docker version

This command displays the version of the docker you have installed on your machine.

docker --version

Docker search

This command runs a search for the image-name of your choice.

docker search (input image name here)

For example, the command docker search python returns the result below.

Docker pull

This command downloads a Docker image from the registry.

docker pull (input image name here)

Docker Info

This command provides exhaustive details about the Docker system.

Docker images

This command lists all the images stored on your machine.

Docker ps and Docker ps -a

docker ps
docker ps -a

Docker ps is a command used to view the list of all running containers, while Docker ps-a is a command used to view all containers, including those that have stopped.

Docker log

This command helps retrieve the logs a running or a stopped container generates. It is very effective in debugging and monitoring the behavior of containerized applications.

docker logs container-id

Docker history

This command retrieves an image's history.

docker history (input image-name here)

Docker stop, and Docker kill

While both commands stop running containers, they behave differently. Docker stop stops a running container gracefully by following due procedure. On the other hand, docker kill terminates the container immediately.

docker stop (input container-id here)
docker kill (input container-id here)

7 Best Practices for Dockerizing Python Applications

To effectively dockerize your Python applications, here are seven best practices you should arm yourself with:

  1. Regularly Update Base Images

are the foundation of a container, often including essential dependencies and information about the operating system. Therefore, it is crucial to update base images as regular updates ensure your container benefits from the latest security, hence a stable docker environment.

  1. Minimize Image Layers

Docker images have multiple layers, each representing specific instructions or changes in the docker file. Minimizing the image layers can enhance build times, reduce image sizes, and improve security.

  1. Use Alpine Linux

Alpine Linux is a lightweight distribution commonly used as a base image for Docker containers. It can be used to reduce image sizes, which reduces attacks on the image compared to larger images.

  1. Use .dockerignore file.

The .dockerignore file is used to specify files and directories that should be excluded from the docker build context when building a docker image. Excluding files reduces the data sent to the Docker server, resulting in more efficiency and faster build times.

  1. Lock Dependency Versions

When writing your Dockerfile, ensure your app uses a specific dependency version. This prevents unintended issues arising from using the latest version, and it aids in creating a predictable and reproducible building environment.

  1. Use Package Manager

Package managers, such as pip for Python and npm for node.js, to simplify managing and installing application dependencies and third-party libraries.

  1. Separate Application and System Dependencies

System dependencies refer to all the components required for the container’s underlying system to function, while application dependencies are specific to the containerized application. Isolating system dependencies from application dependencies reduces the risk of conflict and enhances the overall reliability and consistency of the container.

Conclusion

Docker is a tool that has impacted the software development field in no small way, and as such, every Python developer needs to understand how it works.

In this article, we defined what docker is, stated its advantages, discussed how to set up the Docker environment for different operating systems, analyzed the components of Docker, illustrated how to dockerize a simple Python application, highlighted several Docker commands, and lastly explained best practices for Dockerizing Python applications.

Further Reading

If you would love to learn more about Docker, the links below can guide you.

Docker Documentation

Docker Tutorial for Beginners

What is Docker Compose?

Docker Commands

Best Practices for Docker

Best Practices for Dockerfile Security

Backend Tips, Every week

Backend Tips, Every week