In this article, we will try to build a ‘hello world’ web application and containerize the web application using docker. Why containerize? I am pretty sure there would be hundreds of articles explaining the why part in detail, but let me also give a few lines on the same. They allow us to build a software application that can be run independently of the computing environment. Thus allowing us to concentrate more on the software and less on the underlying infrastructure. The container can be thought like a box that has the software solution, its dependencies, and libraries, binaries, and the corresponding configuration files which can be run as a single unit. This is containerization in a nutshell, but you could browse through the web to understand the underlying essence of it in detail. In this article, we would learn to build a basic container and deploy our ‘Hello world’ python app on the container.
Before you go any further, make sure you install docker and Python3.
Let’s start building something awesome.
Start by creating a directory, sub-directories, and files similar to below structure
$ mkdir learner_project$ mkdir learner_project/app$ touch learner_project/app/app.py$ touch learner_project/app/requirements.txt$ touch Dockerfile|-- Dockerfile
| |-- app.py
| |-- requirements.txt
The folder structure I have here is a typical python flask application structure. You could have it any way you like, but I like to keep things organized as per standards. You could ignore the directories
templates for now.
I think with this you have set up a blueprint for your application and all you need now is to build the solution. Please note that we would not be writing more code in this article. The goal is to learn to containerize our application.
The contents of
app.py look the following:
from flask import Flask
app = Flask(__name__)
return 'Hello World! How are you doing?'
if __name__ == '__main__':
app.run(host='0.0.0.0', port=8008, debug=True)
The contents of the file
requirements.txt are :
That’s it and you are ready to run your python web application. When I run the application I see the following(I installed the
flask library prior to execution):
$ python app/app.py
* Serving Flask app "app" (lazy loading)
* Environment: production
WARNING: This is a development server. Do not use it in a production deployment.
Use a production WSGI server instead.
* Debug mode: on
* Running on http://0.0.0.0:8008/ (Press CTRL+C to quit)
* Restarting with stat
* Debugger is active!
* Debugger PIN: 961-117-870
What does this mean? Your web application is running and listening on
localhost:8008 . When you hit the URL in the browser you should see the following message
Hello World! How are you doing?
If you have come so far that means you can pat your back. You have built your web application. So far we were building the application on our machine and all the application modules exist in our machine only. Now, if anyone wants to run this application you would have to give all the steps that you had done so far, in order for them to successfully execute the app.
Instead when we containerize our application we would be able to just give the container image and anyone could run a container from this image with a simple command and voila the application would be running as it were on our machine.
For this, we would have to define the
Dockerfile which would be having a list of instructions to build an image from which a container could be brought up and then the application can be run on anyone's machine using this image.
MAINTAINER Srinaveen Desu
COPY ./app/requirements.txt /app/requirements.txt
RUN apk add --update \
&& pip install --upgrade pip \
&& pip install -r requirements.txt \
&& rm -rf /var/cache/apk/*
COPY ./app /app
CMD python app.py
FROM tells the image on which our application would be running and in this case, it is
python followed by version tag
MAINTAINER (optional) tells who is currently moderating this Dockerfile.
COPY tells the file that needs to be copied from your local machine to the Docker container. (source to destination)
RUN executes the commands which are responsible for setting up the required environment for our application to run and these get added into the image we would be building.
CMD is a command which is run once our container starts. A typical use case would be starting the web application server.
Now that our Dockerfile is ready, we are ready to build the image and run the container. The command is run in the directory where
Dockerfile exists. It builds the image
flask-demo-container which is versioned
/Users/desu/learner_project$ docker build --tag flask-demo-container:1.0 .Sending build context to Docker daemon 9.047MBStep 1/7 : FROM python:3.8-alpine---> 44fceb565b2aStep 2/7 : MAINTAINER Srinaveen Desu---> Using cache---> 81c543f544caStep 3/7 : COPY ./app/requirements.txt /app/requirements.txt---> Using cache---> 7446b6ed7a69Step 4/7 : WORKDIR /app---> Using cache---> 76a94dbf8407Step 5/7 : RUN apk add --update && pip install --upgrade pip && pip install -r requirements.txt && rm -rf /var/cache/apk/*---> Using cache---> bda14c8083c5Step 6/7 : COPY ./app /app---> a5f384727c69Step 7/7 : CMD python app.py---> Running in dc00695397f9Removing intermediate container dc00695397f9---> 853572c38b75Successfully built 853572c38b75Successfully tagged flask-demo-container:1.0
If you see the two successful messages you are good to go to the next step which is running the container.
$ docker run --publish 8000:8008 --name flask-demo-app flask-demo-container:1.0* Serving Flask app "app" (lazy loading)* Environment: productionWARNING: This is a development server. Do not use it in a production deployment.Use a production WSGI server instead.* Debug mode: on* Running on http://0.0.0.0:8008/ (Press CTRL+C to quit)* Restarting with stat* Debugger is active!* Debugger PIN: 185-072-509172.17.0.1 - - [01/Sep/2020 06:03:47] "GET / HTTP/1.1" 200 -
If we hit the
URL localhost:8000 you would see the
hello world message you had seen earlier.
--publish forwards traffic hit at the port
8000of the local machine to the port
8008 of the container.
--name is the unique name that you give to the container.
And the last part of the command is the image followed by the version that we want the container to be run from.
If we want to run the container in the detached mode(running the container in the background) you would have to use the following command:
$ docker run --detach -p 8004:8008 --name flask-demo-app flask-demo-container:1.1
Note1: I have changed the image version to
Note2: In case you want to stop the container (in the case of detached mode) you would have to run the following command
docker stop <container-name>
In case you want to run the container again, you would have to remove the container before issuing the run command given above.
docker rm <container-name>
That was all for this article. Hope you had some fun learning cool stuff :).
NOTE: Please don’t use the code for PRODUCTION purposes.
References: Docker Doc