How to Deploy Python Applications with Docker

Edited 4 weeks ago by ExtremeHow Editorial Team

PythonDockerDeploymentContainersWindowsMacLinuxDevOpsVirtualizationApplicationsCloudSetup

In the world of software development, deploying Python applications can often be a complex and challenging process. Fortunately, Docker has revolutionized the way we develop, ship, and run applications using container-based virtualization. In this guide, we will go into detail about how to deploy Python applications with Docker. We will explain the steps in simple terms, provide example code, and help you fully understand the concept, which is ideal for anyone new to Docker or looking to strengthen their understanding. Follow along, and by the end of this tutorial, you will have a solid foundation for deploying your Python applications using Docker.

Understanding Docker

Docker is an open-source platform that allows developers to automate the deployment of applications inside lightweight, portable containers. These containers can run anywhere, whether it's your personal computer, a cloud server, or any other environment that supports Docker. The primary benefit of using Docker to deploy Python applications is consistency. By packaging your application and its dependencies into a single unit, you eliminate the "it works on my machine" problem and ensure it will perform the same everywhere.

Components of Docker

Before deploying your application, let's understand some of the key components of Docker:

1. Dockerfile: This is a text file that contains all the commands to assemble the image. It is like a blueprint for Docker, detailing all the steps required by Docker to run your application smoothly.
2. Image: It is a portable, immutable file that contains the application and its dependencies. It is the output of the Dockerfile that contains all the information to build a container.
3. Container: This is a runtime instance of an image. A container contains everything needed to run an application: code, runtime, system tools, and libraries.
4. DockerHub: A cloud-based registry service for sharing Docker images. It lets you store and distribute container images. You can think of it as GitHub for Docker images.

Setting up Docker

To start using Docker to deploy Python applications, you first need to set up Docker on your machine. Here are the general steps:

• Go to the official Docker website and download Docker Desktop based on your operating system.
• Follow the instructions to install Docker.
• Once installed, run Docker Desktop to start the Docker engine.
• Confirm the installation by opening a terminal or command prompt and typing the following command:

docker --version

The output should display the installed version of Docker, indicating that Docker is set up successfully.

Building a Simple Python Application

Let's walk through the process of creating a simple Python application that we will deploy using Docker. Our application will be a simple Python script that prints "Hello, World!". Though it is simple, it will serve the purpose of understanding the deployment process.

Create a new directory for your project and create a file named app.py within it:

print("Hello, World!")

Save the file: This script, app.py, simply outputs "Hello, World!" to the console.

Creating a Dockerfile

Next, we need to create a Dockerfile in the same directory as our Python script. This Dockerfile will contain all the instructions needed for Docker to containerize our Python application.

1. Create a new file in your project directory and name it Dockerfile (without any extension).
2. Copy the following content into your Dockerfile:

FROM python:3.8-slim
# Set the working directory
WORKDIR /app
# Copy the current directory contents into the container at /app
COPY . /app
# Run app.py when the container launches
CMD ["python", "app.py"]

Let's break down this Dockerfile:

• FROM: This initiates the build process. We specify a base image of Python version 3.8 (a smaller, optimized version).
• WORKDIR: This sets the working directory inside the container to /app. This works the same as navigating to a directory.
• COPY: This copies the contents of the current directory (where the Dockerfile is) on the host to the working directory inside the container.
• CMD: This specifies the command to run when the container starts. In our case, it runs our Python script.

Building the docker image

Now that we have a Dockerfile, it's time to create a Docker image. The image will be an executable package that contains everything needed to run our application.

Open your terminal or command prompt, go to the directory containing your project, and build the Docker image using the following command:

docker build -t hello-world-app .

What this command does:

• docker build: Starts the build process.
• -t hello-world-app: Tags the image with the name “hello-world-app” for easy reference.
• .: pointer indicates the current directory as the build context.

Once the build process is complete, Docker will create an image named “hello-world-app”.

Running a Docker container

Once the image is ready, we can now run our Python application inside the container. Run the following command in your terminal or command prompt:

docker run hello-world-app

This command tells Docker to run a container based on the "hello-world-app" image we created. If everything is set up correctly, you should see the output:

Hello, World!

This simple message confirms that the Python application has been successfully executed inside the Docker container.

Sharing and publishing Docker images

Part of the power of Docker is its ability to be seamlessly shared across different environments. You may want to share your Docker image with others or deploy it on a cloud platform. DockerHub is a public cloud service that allows you to store and share your images.

1. Make sure you have a DockerHub account. You can create an account for free by visiting the DockerHub website and signing up.

2. Log in to your DockerHub account from the terminal:

   docker login

   You will be asked to enter your DockerHub username and password.

3. Tag your image to push to DockerHub. DockerHub requires your DockerHub username to be added next to images. Use the following command to tag your image, replacing [username] with your DockerHub username:

   docker tag hello-world-app [username]/hello-world-app

4. Push the tagged image to DockerHub:

   docker push [username]/hello-world-app

   This uploads your image to DockerHub, making it available for others to build on or deploy on different platforms.

Cleaning

After exploring Docker and deploying your Python application, it is a good habit to clean up unnecessary Docker resources such as images and containers that take up space. Here are some basic commands:

• Remove stopped containers:

docker container prune

• Remove unused images:

docker image prune

• View all containers (optional):

docker ps -a

• Remove a specific container:

docker rm container_id

• Delete a specific image:

docker rmi image_id

Replace container_id and image_id with your specific values.

Conclusion

Congratulations! You have now learned how to deploy Python applications using Docker. Understanding how Docker images and containers work provides a great toolset for any software developer. With this knowledge, you can ensure that your applications are scalable, manageable, and can run consistently in any environment. Keep exploring Docker's capabilities and enjoy containerizing!

  Share This Article

If you find anything wrong with the article content, you can request an update