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.