Before starting to build the app, let's first install the pre-requisites that are required for building the docker containers,

1. Install Docker on your machine

For Linux (Ubuntu/Debian Based distros):

sudo apt install docker.io

For MacOSX: you can follow this link
For Windows: you can follow this link

For Windows (Enable WSL2 backend for optimized performance)

Finally, verify that Docker is installed correctly

sudo docker run hello-world

2. Create your project

Create a new directory and two files main.py and Dockerfile.

main.py -- contains python code for web server.
Dockerfile -- this file contains the structure of container.
requirements.txt-- this is a dependency file for python web server(flask).

Kindly add this code to your main.py to initiate web server,

from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello_world():
 return 'Hello World'


if __name__ == '__main__':
    app.run(debug=True, host='0.0.0.0', port=5000)

add the below dependency to requirements.txt file,

Flask==2.1.2

3. Edit the Docker file

The first step to take when you create a Docker file is to access the DockerHub website. This site contains many pre-designed images to save your time (for example: all images for linux or code languages).

In our case, we will type ‘Python’ in the search bar. The first result is the official image created to execute Python. Perfect, we’ll use it!

# Start by pulling the python image
FROM python:3.8-alpine

# Copy every content from the local file to the image
COPY . /app

# switch working directory
WORKDIR /app

# install the dependencies and packages in the requirements file
RUN pip install -r /app/requirements.txt

# run the python code
CMD ["python", "main.py" ]

Let’s go over the instructions in this Dockerfile

FROM python:3.8-alpine: Since Docker allows us to inherit existing images, we install a Python image and install it in our Docker image. Alpine is a lightweight Linux distro that will serve as the OS on which we install our image

COPY ./requirements.txt /app/requirements.txt: Here, we copy the requirements file and its content (the generated packages and dependencies) into the app folder of the image

WORKDIR /app: We proceed to set the working directory as /app, which will be the root directory of our application in the container RUN pip install -r requirements.txt: This command installs all the dependencies defined in the requirements.txt file into our application within the container

COPY . /app: This copies every other file and its respective contents into the app folder that is the root directory of our application within the container

ENTRYPOINT [ "python" ]: This is the command that runs the application in the container

CMD [ "main.py" ]: Finally, this appends the list of parameters to the EntryPoint parameter to perform the command that runs the application. This is similar to how you would run the Python app on your terminal using the python main.py command.

4. Build the Docker image

Let’s proceed to build the image with the command below:

docker image build -t flask_docker .

5. Run the container

After successfully building the image, the next step is to run an instance of the image. Here is how to perform this:

docker run -p 5000:5000 -d --name new_app flask_docker

This command deploys the container with the python flask server running on port 5000, Here is the output of our application when we send a request to localhost:5000 on our browser,

Track the container status

The below command displays the list of all running active containers, check if your deployed container is in running status!

docker ps -a

6. Useful commands for Docker

List your images

docker images

Delete a specific image

docker image rm [image name]

List all existing containers (running and not running)

docker ps -a

Stop a specific container

docker stop [container name]

Delete a specific container

docker rm [container name]

Display logs of a container

docker logs [container name]

Note: If you want to learn more about Dockerfiles, check out Best practices for writing Dockerfiles.

7. Conclusion

In this article, we built a simple Flask app and containerized it with Docker. You can refer to this post every time you need a simple and concrete example on how to create your first Docker application. If you have any questions or feedback, feel free to ask.