Run Python in Docker: Hosting a Python Script on Docker

Filed Under: Python Advanced
Hosting Python Script On A Docker Container

Hello readers! In this article, we will be Understanding the process of Hosting a Python script on a Docker Container in detail. So, let us begin!

What is a Container?

A Container is a package of all the system and software requirements that are needed to run an application on the cloud. It comprises the run-time execution files, system settings, code, and libraries.

Thus, with containers, we can modify the specifications as containers are writable and then host the applications easily on them.

Hosting a Python script on Docker

Having understood about containers, it is now the time to implement a script through containers. By this, we will ensure the container takes care of all the requirements and hosting.

Before deploying the script, let us understand the flow of hosting an application on a container in Docker.

Recommended Read: How to install Docker on Ubuntu?

  1. At first, we need to create a Dockerfile. A Dockerfile is a blueprint that is necessary to create images in Docker. It contains all the necessary commands which we would usually execute through the command line to create an image for the container.
  2. Having created a Dockerfile, we would now require to build an image on top of the Dockerfile. A Docker image can be considered as a template that helps create a container in docker. It packs up the applications and sets the server environment, thus making it easy for us to use the environment for hosting the applications over containers in a convenient manner.
  3. Now, we can run the image to see the output of the python script over. As soon as the image runs, a container with a random name gets created.

Now, let us start with the implementation!! We would be using the below Python script to host it on the docker container.

lst = list()
lst = ['Python', 'Machine Learning', 'R Language', 'Bootstrap']
for x in lst:

In the above script, we have created a list and then iterated through a for loop to print the elements of the Python list.

1. Create a Dockerfile


FROM python:3
CMD [ "python", "./" ]

There are certain directives offered by Dockerfile as shown below–

  • FROM – This directive sets the base image for the subsequent instructions to work on. In this example, we have set python version 3 as the base image. Now, the Dockerfile would fetch this base image from the Docker Hub which is actually a repository of open-source images.
  • ADD – The ADD instruction copies new files, directories, or remote file URLs from <src> and adds them to the filesystem of the image at the path <destination>. In our case, the src =, and the destination is /
  • CMD – This directive runs the services alongside the base image in a customized manner.

2. Building an image from the Dockerfile

After building the Dockerfile, we now need to build the image on top of the Dockerfile using the below command–

docker build -t image-name:tag .

We can provide any customized image name to it and the tag helps it segregate from other images on the hub.


docker build -t python-img:5.0 .


[+] Building 5.4s (7/7) FINISHED
 => [internal] load build definition from Dockerfile                                                             0.1s 
 => => transferring dockerfile: 31B                                                                              0.0s 
 => [internal] load .dockerignore                                                                                0.1s 
 => => transferring context: 2B                                                                                  0.0s 
 => [internal] load metadata for                                                      5.0s 
 => [internal] load build context                                                                                0.1s 
 => => transferring context: 31B                                                                                 0.0s 
 => [1/2] FROM  0.0s 
 => CACHED [2/2] ADD /                                                                                 0.0s 
 => exporting to image                                                                                           0.1s 
 => => exporting layers                                                                                          0.0s 
 => => writing image sha256:8b2da808b361bc5112e2afa087b9eb4e305304bcc53c18925d04fe8003f92975                     0.0s 
 => => naming to  

We need to remember that docker images are read only structures and can run independently. On the other side, a container is built on top of an image and it needs an image to run itself.

3. Run the docker image

Let us now run our created image to see the python script’s output from the container on the GIT BASH console.

docker run python-img:5.0


Machine learning
R language

We can also see the reflection of the image running on the Docker Community Edition Console as shown below–

Docker Image
Docker Image

As mentioned in the previous section, a container with a random name gets created for the called image as seen below:

Docker Container
Docker Container

We can even create containers with customized names and run the script through the container using the below command:

docker run -it --name container-name image:tag


docker run -it --name sample python-img:5.0


Machine learning
R language
Docker Customized Container
Docker Customized Container

As seen above, we see two containers created over the same image that we had created earlier.


By this, we have come to the end of this topic. Feel free to comment below, in case you come across any question.

For more such posts related to Python, stay tuned and till then, Happy Learning!! 馃檪


Leave a Reply

Your email address will not be published. Required fields are marked *

Generic selectors
Exact matches only
Search in title
Search in content
Search in posts
Search in pages