Python and Docker: Writing and Running Python Apps in Containers

Table of Contents

  1. Introduction
  2. Prerequisites
  3. Setting Up Docker
  4. Writing a Python App
  5. Creating a Dockerfile
  6. Building the Docker Image
  7. Running the Docker Container
  8. Conclusion

Introduction

In this tutorial, we will explore how to write and run Python applications in Docker containers. Docker is a popular containerization platform that allows developers to package their applications along with their dependencies into a single deployable unit called a container. By using Docker, we can ensure that our Python app runs consistently across different environments, making it easier to deploy and manage.

By the end of this tutorial, you will have a good understanding of how to write a Python application, create a Dockerfile to containerize it, build a Docker image, and run the application in a Docker container.

Prerequisites

To follow along with this tutorial, you should have the following:

  • Basic knowledge of Python programming
  • Docker installed on your machine

Setting Up Docker

Before we begin, make sure you have Docker installed and running on your system. You can download Docker from the official Docker website. Once installed, open a terminal or command prompt to verify the installation by running the following command: bash docker version If Docker is installed correctly, you should see version information for both the client and the server.

Writing a Python App

Let’s start by writing a simple Python application that we can containerize using Docker. For this tutorial, we will create a Python script that prints “Hello, Docker!” to the console. Open your favorite text editor and create a new file called app.py. python print("Hello, Docker!") Save the file and exit the text editor. Our Python app is now ready.

Creating a Dockerfile

Next, we need to create a Dockerfile, which is a text file that specifies the base image to use, copies the necessary files into the container, and defines the commands to run when the container starts.

In your text editor, create a new file called Dockerfile (no file extension). We will use the official Python base image as the starting point for our Docker image. ```dockerfile FROM python:3.9

COPY app.py /app.py

CMD ["python", "app.py"]
``` Let's go through each line of the Dockerfile:
  • FROM python:3.9 specifies the base image to use. In this case, we are using the latest Python 3.9 image from the official Docker Hub registry.
  • COPY app.py /app.py copies our app.py file into the container, placing it in the root directory.
  • CMD ["python", "app.py"] sets the command to run when the container starts. In this case, we are running the app.py Python script using the python interpreter.

Save the Dockerfile and exit the text editor.

Building the Docker Image

With our Python app and Dockerfile in place, we can now build a Docker image. Open a terminal or command prompt and navigate to the directory where the files are located.

Run the following command to build the Docker image: bash docker build -t mypythonapp:1.0 . Let’s break down the command:

  • docker build is the command to build a Docker image.
  • -t mypythonapp:1.0 tags our image with the name mypythonapp and the version 1.0.
  • . specifies the build context, which is the current directory.

Docker will now execute the instructions in the Dockerfile and build the image. Once the build process is complete, you should see output similar to the following: ``` …

Successfully built <image-id>
Successfully tagged mypythonapp:1.0
``` ## Running the Docker Container

Now that we have built our Docker image, let’s run a container based on it. Run the following command: bash docker run mypythonapp:1.0 Docker will create a new container based on the mypythonapp:1.0 image and start it. You should see the output Hello, Docker! printed to the console.

Congratulations! You have successfully written and run a Python app in a Docker container.

Conclusion

In this tutorial, we have learned how to write and run Python applications in Docker containers. We started by setting up Docker on our system and then proceeded to write a simple Python app. We created a Dockerfile to containerize the app, built a Docker image, and finally ran a Docker container based on that image.

Using Docker to containerize our Python applications provides numerous benefits, such as portability, isolation, and reproducibility. It allows us to package our app together with its dependencies, making it easier to deploy and manage across different environments.

Feel free to explore more advanced Docker features and experiment with deploying more complex Python applications in containers. Happy coding!

Published:

Related Articles