This tutorial will teach you how to build and deploy a Flask application to a Kubernetes Cluster.
Kubernetes is a computer orchestration tool that assists in the deployment of container applications. Kubernetes is a powerful tool that automates the management, deployment, and scaling of containerized applications in a Kubernetes cluster.
A Kubernetes cluster contains a set of worker nodes that run the deployed containerized applications. The worker nodes have pods that create multiple instances of the same application. The Kubernetes cluster automatically manages the resources required to run the applications and perform auto-scaling. A Kubernetes cluster can run on cloud-based providers such as Amazon Elastic Kubernetes Service, Azure Kubernetes Service and Google Kubernetes Engine. It can also run locally on a Minikube Kubernetes Cluster.
Before deploying any application to a Kubernetes cluster, you first containerize the application using Docker. Docker bundles all the dependencies and source code the application requires to run.
In this tutorial, you will start by creating a simple "Hello world" Flask application and then run it locally. You will then use Docker to containerize the Flask application and also run the Docker container. Finally, you will deploy the dockerized Flask to the Minikube Kubernetes Cluster. Let's get started with our project!
Prerequisites
This tutorial assumes you have some basic Docker knowledge and have the following set up on your machine:
- VS Code text editor.
- Docker Desktop installed onto your machine
Creating the Flask application
Flask is an open-source Python micro framework for building web applications. You will use the Flask framework to create a simple "Hello world" application. To install Flask, let's run the following command in your terminal:
pip install flask
The command above will install the Flask framework and all the dependencies required to run the application. After successfully installing the framework, create a working directory named flask-application
and open it in VS Code. In the working directory, create a file named app.py
and paste in the following code:
from flask import Flask
app = Flask(__name__)
@app.route("/")
def hello_world():
return "<p>This is a Hello World application</p>"
if __name__ == '__main__':
app.run(debug=True)
The code above has a hello_world
function which will return This is a Hello World application
. To run this simple Flask application, execute the following command in your terminal:
python app.py
The command will run the Flask application in the web browser, as shown in the image below:
You have successfully run the application locally. Lets's now use Docker to containerize the application.
Containerising the Flask application with Docker
You create a Dockerfile which the Docker Engine will use to containerize the Flask application. The Dockerfile has several commands that build the Docker image for the application. The Docker image will have all the source code, tools, and dependencies the application requires to run.
You also need to create a requirements file that will specify all the dependencies and tools required to run the Flask application. To start, in the working directory, create a new file and name it requirements.txt
and add the following:
flask
The Flask application only requires the flask
framework to run. Next, in the working directory, create a new file named Dockerfile
and paste in the following code:
# You will use python:3.10-alpine as the base image for building the Flask container
FROM python:3.10-alpine
# It specifies the working directory where the Docker container will run
WORKDIR /app
# Copying all the application files to the working directory
COPY . .
# Install all the dependencies required to run the Flask application
RUN pip install -r requirements.txt
# Expose the Docker container for the application to run on port 5000
EXPOSE 5000
# The command required to run the Dockerised application
CMD ["python", "/app/app.py"]
To build a Docker image using the above Dockerfile
, run the following command in your terminal:
docker build -t bravinwasike/flask-kubernetes .
The command will build a Docker image named bravinwasike/flask-kubernetes
and produce the following output:
Pushing the Docker image to Docker Hub
After creating the Docker image, ensure you push the Docker image into your Docker Hub repository using the following commands:
- Log in to the Docker hub from your terminal
docker login
- Pushing the Docker image to Docker Hub
docker push bravinwasike/flask-kubernetes
Running a Docker Container
To run a Docker container using the created Docker image, use the following command:
docker run -p 5000:5000 bravinwasike/flask-kubernetes:latest
The command will run the Docker container and expose our application on port 5000. We can also view our containerized application on a web browser shown below:
The next step is to deploy the containerized Flask application to the Minikube Kubernetes Cluster.
Getting started with the Minikube Kubernetes Cluster
Minikube is a tool that runs a single-node Kubernetes cluster on your local machine. To run Minikube, all you need is Docker Desktop set up on your computer. Docker Desktop comes with Minikube already configured. Minikube runs on Windows, Linux, and macOS. Minikube is best suited for running simple applications and testing purposes.
To check the installed Minikube version, run the following command:
minikube version
To run Minikube using the Docker driver, use the following command:
minikube start --driver=docker
The code above produces the following output:
The output shows the Minikube Kubernetes Cluster has started running. The next step is to deploy the containerized Flask application to the created Minikube Kubernetes Cluster.
Deploying to the Minikube Kubernetes Cluster
You will deploy the containerized Flask application to the created Minikube Kubernetes Cluster using the Kubernetes CLI. Kubernetes CLI known as kubectl
is a command line interface tool that allows you to deploy applications to a Kubernetes Cluster. It also allows you to manage and interact with all the resources for the Kubernetes cluster.
To install the Kubernetes CLI, use the following choco command:
choco install kubernetes-cli
To check the version of the installed Kubernetes CLI, execute the following command in your terminal:
kubectl version --client
The next step is to create a deployment.yaml
file which kubectl
will use to deploy the application to the Minikube Kubernetes cluster.
Creating the deployment.yaml
file
The deployment file will specify the number of instances/replicas of the containerized application. It will also show the resources required to run the application pods. In the working directory, create a new file named deployment.yaml
and paste the following code snippet:
apiVersion: apps/v1
kind: Deployment
metadata:
name: flask-app-deployment
spec:
replicas: 3
selector:
matchLabels:
app: test-app
template:
metadata:
labels:
app: test-app
spec:
containers:
- name: test-app
image: bravinwasike/flask-kubernetes:latest
resources:
limits:
memory: "128Mi"
cpu: "500m"
ports:
- containerPort: 5000
---
apiVersion: v1
kind: Service
metadata:
name: flask-app-service
spec:
selector:
app: flask-app-deployment
ports:
- port: 6000
targetPort: 5000
type: LoadBalancer
The code snippet above has two parts: Deployment and Service
- Deployment
This part describes the intended number of multiple instances/replicas or pods for the deployed application. In our case, we will have
3
pods. If one pod fails the other ones will take over. It ensures zero downtime and the application's reliability.
You will also use the bravinwasike/flask-kubernetes
docker image we had earlier pushed to Docker Hub to create our application's container. In this part, we specify the resources (CPU and memory) that each pod will need to run. It also shows the port (5000) our container is running. Our Deployment
is named flask-app-deployment
.
- Service
It acts as a load balancer that distributes the application traffic. It will distribute the number of API calls to the app instances/pods equally. The service also exposes our deployed application outside the Minikube Kubernetes Cluster using an external IP address. It makes it possible to access the application on the web browser. Our service is named
flask-app-service
To deploy the application to the Minikube Kubernetes cluster, execute the following kubectl
command in your terminal:
kubectl apply -f deployment.yaml
The command above will use the deployment.yaml
to automatically create containers and deploy them to the Minikube Kubernetes cluster. It will create 3
application instances/pods, and each pod will use the specified resources. To see the deployment, use the following code:
kubectl get deployment
The output shows our flask-app-deployment
.
To see the service, use the following code:
kubectl get service
The output shows our flask-app-service
is running.
Getting the pods
To see the pods, use the following code:
kubectl get pods
The output shows the three running pods.
The Minikube deployment dashboard
To view the Minikube deployment dashboard, use the following command:
minikube dashboard
The code displays the following in your web browser:
The output shows the running Deployments, Services, and Pods in the Minikube Kubernetes Cluster.
Accessing the containerized application
You will expose the flask-app-service
to access the application outside the Minikube Kubernetes Cluster. You will use an external IP address and access the application on the web browser. To expose the service, use the following minikube
command:
minikube service flask-app-service
You can now access our containerized Flask application using the following external IP address: http://127.0.0.1:13678 Minikube Kubernetes Cluster generates.
Click on the URL to access the application on the web browser. The application output:
You have successfully deployed the Flask application to the Minikube Kubernetes Cluster and accessed the application as a Kubernetes Cluster service.
Conclusion
In this tutorial, you have learned how to deploy a Flask application to a Kubernetes Cluster. You started by creating a simple "Hello world" Flask application and ran it locally. You then used Docker to containerize the Flask application and also ran the Docker container.
You created a Minikube Kubernetes Cluster and ran Kubernetes locally on our machine. Finally, you deployed the dockerized Flask to the Minikube Kubernetes Cluster. The complete code for this tutorial is found here in Git Hub.
If you like this tutorial let's connect on Twitter. Thanks for Reading and Happy Learning!
Top comments (0)