Containerize your web application & deploy it on Kubernetes

UpdatedMarch 5, 2023

Senior Software Engineer. I write about practical tips and epic stories about my experiences in the field of computer science and engineering!

Comments (3)

Join the discussion

Nimrod Kramer5y ago

Congrats on being featured on daily.dev! Good job there.

Apoorv Tyagi5y ago

Thank You so much Nimrod Kramer :)

Matt Moll5y ago

Nice article Apoorv! Keep them coming!

Apoorv Tyagi5y ago

Thanks Matt Moll.

I will for sure! I have quite a few ideas in my head that are soon coming on my blog 😊

Kannan5y ago

Apoorv Tyagi Thanks for the great article. Wondering what is the use of this docker run -dp 5000:5000 hello-python. Since we specify that we want to expose the port 5000 in dockerfile.

Apoorv Tyagi5y ago

"EXPOSE" instruction does not actually publish the port.(it's just a way of telling the person who runs the container about which ports are intended to be published)

To actually publish the port you need to run the container & use the -p flag with it

Even though i have mentioned 5000 in my Dockerfile, i can run my container on 5500 if i do docker run -dp 5500:5000 hello-python

Because i wanted to check if my container is running fine i used the docker run command

I hope it makes sense :)

Kannan5y ago

Apoorv Tyagi Thanks. just another small question why :5000 next to 5500 if port is 5500

Apoorv Tyagi5y ago

Kannan 5500 is the container port that we published. Publishing ports means mapping container ports to the host application(my flask app in this case) so that the ports are available to services outside of Docker container.

In order to do that the syntax is docker run -p <your container port>:<host app exposed port><imageName>

This means anyone connecting to the host(flask app) over port 5000 will be routed to my container via port 5500.

Kannan5y ago

Apoorv Tyagi Got it. Thanks for the detailed explanation.

Distributed Systems

Part 9 of 10

Bits and Pieces I learned on how to build and scale a distributed system. All the posts in the series belong to the real problems I faced during my 9-5 and the solutions we went through with.

Up next

Different ways to authenticate your APIs

Whenever we are designing secure systems that need authentication for API access, we must consider how your applications and users should authenticate themselves. In this article, we’ll be discussing three different ways to achieve this: HTTP Basic ...

More from this blog

How to Size Java Database Connection Pools in Kubernetes

Stop guessing your maximum-pool-size. Learn how to calculate limits backwards from your database

Jul 11, 202614 min read

How to Size Java Database Connection Pools in Kubernetes

What is Jib? A Complete Guide to Java Containerization Without Dockerfiles

Learn what Jib is, how it works, and when to use Jib vs Dockerfile. A guide with real-world scenarios

Mar 10, 20265 min read

What is Jib? A Complete Guide to Java Containerization Without Dockerfiles

Kafka Consumer Container Restarts in Kubernetes: A Production Case Study

A prod debugging story you’ll probably relate to

Feb 10, 20267 min read

Kafka Consumer Container Restarts in Kubernetes: A Production Case Study

How we solved cache invalidation in Kubernetes with a headless service

The $0 solution to a Distributed Cache Invalidation

Dec 29, 20254 min read

How we solved cache invalidation in Kubernetes with a headless service

Going Vernacular: Engineering Our Way to Process Multilingual Names

Introduction At our current organization, earlier this year as we were looking at the errors at one of our signup API, we observed that nearly 5% of our requests were getting failed, all due to 400 BAD REQUEST errors, and the root cause was traced ba...

Dec 4, 202310 min read

Going Vernacular: Engineering Our Way to Process Multilingual Names

The Trojan (Apoorv Tyagi)

43 posts

The Senior Engineer’s Playbook: Real-World Case Studies in Computer Science and Software Design.

Introduction

If you are new to the concept of containers and the Docker & Kubernetes platform, chances are you will find plenty of theoretical resources online but there is a huge gap when it comes to practical tutorials.

This blog post is aimed to fill that gap. In this, I will show you how you can containerize an application and get it running in Kubernetes.

What we’ll do

We will be creating a simple flask app for this tutorial & then I'll show how you can first create a docker image of your application using Dockerfile and later deploy it on Kubernetes (available in docker desktop's built in Kubernetes environment)

I am also assuming you are at least comfortable with some of the basic commands & terminologies of docker and Kubernetes

Here's how we will proceed

We will create our application
Containerize our app by creating an image using Dockerfile
Finally deploying everything on kubernetes

Creating an application

A containerized development environment is easy to manage and share with other developers as it can be easily deployed without any change to their standard environment.

First, let's create a simple web app using flask & name it app.py👇

# make sure you have flask installed in your environment
from flask import Flask 

app = Flask(__name__)
@app.route('/',methods = ['GET'])  
def func():
    return 'Hello World'

if __name__ == "__main__":
    app.run(host='0.0.0.0')

In this, we have created one GET method

To test this, simply run python app.py in your console & type http://localhost:5000/(port 5000 is the default port for the development server) in your browser and you'll see the output as the following

Create a Dockerfile

Now that your app is working fine, the first step in containerizing the application is to create a Dockerfile.

But wait, what is a Dockerfile? 🤔

Dockerfile is a set of instructions Docker will use to build the image. To create one, Open any text editor of your choice & write down the following code in it. Also, make sure to name this file exactly as Dockerfile without any extension

FROM python:3.7
RUN mkdir /code
WORKDIR /code
ADD . /code
RUN pip install -r requirements.txt
EXPOSE 5000
CMD ["python","/code/app.py"]

In this Docker will :

Get the official Python Base Image for version 3.7 from Docker Hub.
In the image, create a directory named code & set it as the working directory.
Copy the local directory’s contents to that new folder into the image.
Run the pip installer to pull the requirements into the image.
Inform Docker the container listens on port 5000(default port).
Configure the starting command to use when the container starts.

For the 4th point, you need to create a requirements.txt file which will contain all the required libraries your application will need to run. In this case, we will only need flask.

Create an image

To create an image using this Dockerfile run the following command in your local directory where your application is located

docker build -f Dockerfile -t hello-python:latest .

You will see something like this going on in your terminal -

Now to check if the image is created properly run :

docker image ls

In this, you can see on the very top that our image is created successfully by the name of hello-python. To verify this you can also try running the image using the following command docker run -dp 5000:5000 hello-python

Now go to http://localhost:5000 & you can see the output like this👇

YAY!!!🥳 Our docker image is running perfectly.

Deploying on Kubernetes

We are finally ready to get the application running in Kubernetes. We just need to create a service and a deployment in our k8s.

Before we move forward make sure you have kubectl installed in your machine

If everything is configured then it's time to move on & create a yaml file with the following contents in it :

apiVersion: v1
kind: Service
metadata:
  name: hello-world-python
spec:
  selector:
    app: hello-world-python
  ports:
  - protocol: "TCP"
    port: 6000
    targetPort: 5000
  type: LoadBalancer

---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: hello-world-python
spec:
  selector:
    matchLabels:
      app: hello-world-python
  replicas: 4
  template:
    metadata:
      labels:
        app: hello-world-python
    spec:
      containers:
      - name: hello-world-python
        image: hello-python
        imagePullPolicy: Never
        ports:
        - containerPort: 5000

What the YAML file does is it tells Kubernetes about what we want to run. For example with this YAML file above, It is telling Kubernetes the following:

You want a load-balanced service exposing port 6000
You want four instances of the hello-python container running

In this Kubernetes YAML file, we have two objects, separated by the ---: one is the service & another one is the deployment

While Kubernetes YAML can appear long and complicated at first, it almost always follows the same pattern:

The apiVersion, which indicates the Kubernetes API that parses this object The kind indicating what sort of object this is Some metadata applying things like names to your objects The spec specifying all the parameters and configurations of your object.

Use kubectl to send the YAML file to Kubernetes by running the following command:

kubectl apply -f deployment.yaml

After this you will see all your pods running when you type kubectl get pods like this :

Similarly, you can check your deployments & services by running kubectl get deployments and kubectl get services respectively.

Now navigate to http://localhost:6000 and you should see the "Hello World" message

That’s it! The application is now running in Kubernetes!

Conclusion

In this tutorial, we have successfully deployed our application to a Kubernetes environment. We haven’t done much with Kubernetes yet, but now that you have a basic understanding of k8s, you can begin adding other components to your app and taking advantage of all the features and power of Kubernetes.

In addition to deploying to Kubernetes, we have also described our application as a Kubernetes YAML file. This simple text file contains everything we need to create our application in a running state.

We didn't talk about the theoretical concepts in detail so in case if you get stuck somewhere or didn't understand any particular piece, reply in the comments or @ me on Twitter any time.

Command Palette

Comments (3)

Distributed Systems

Different ways to authenticate your APIs

More from this blog

Introduction

What we’ll do

Creating an application

Create a Dockerfile

Create an image

Deploying on Kubernetes

Conclusion

Other articles you might like😊