Deploying flask app to Kubernetes using Minikube

Introduction

Kubernetes manages the deployment, scaling, and operation of containerized applications across a cluster of machines. Kubernetes relies on tools such as container runtimes like Docker, to run the containers.

Before deploying the application with Kubernetes, you need to containerize the application using docker. This article shows how to deploy a Flask application on Ubuntu 22.04 using Minikube; a Kubernetes tool for local deployment for testing and free offering. Alternatively, you can deploy your container apps using Cloud providers such as GCP(Google Cloud), Azure(Microsoft) or AWS(Amazon).

Prerequisites

1.Docker installed on your device..NOTE: Make sure your docker version is below 25; to prevent errors associated with compatibility. We will be using Docker version 24.0.7.)

2.Minikube installed on your Device.
3.A Github repository to save your project files.
4.Flask installed in your device.
5.A Dockerfile.
6.Docker-compose yaml file.
7.Deployment and Service yaml files.
8.A requirement.txt file for flask dependencies.

Step 1:Creating a Dockerfile with the following:

In the file structure of the Dockerfile, we copy the requirements.txt before the files because of easier caching when modifications are done,and you can have an easier build with Docker.

(Ensure you add Flask and werkzeug with their consecutive versions in the requirements.txt file.)

# Use an official Python runtime as a parent image
FROM python:3.10.12

# Install python3-venv
RUN apt-get update && \
    apt-get install -y python3-venv
# Set the working directory to the name of the application
WORKDIR /app

# Copy the requirements file into the container at the application 
COPY requirements.txt /app/

# Create a virtual environment in /opt/env
RUN python3 -m venv /opt/env

# Install any needed packages specified in requirements.txt
RUN /opt/env/bin/pip install --no-cache-dir -r requirements.txt

# Copy the current directory contents into the container at the application
COPY . /app/

# Set environment variables
ENV PATH="/app/venv/bin:$PATH"

# Make port 5000 available to the world outside this container
EXPOSE 5000

# Run flask application when the container launches
CMD ["/opt/env/bin/python", "-m","flask", "run","--host=0.0.0.0"]

Step 2:Creating a docker-compose yaml file with the following:

version: '3'

services:
  web:
    build: .
    ports:
      - "5000:5000"
    environment:
      - DATABASE_URL=sqlite:////data/mydatabase.db  # Set the desired database file path
    volumes:
      - ./:/data # Set the desired file path

  sqlite3:
    image: nouchka/sqlite3:latest
    stdin_open: true
    tty: true
    volumes:
      - ./:/data # Set the desired file path

Step 3: Run Docker Compose Commands.

docker-compose build
docker-compose up

Step 4: Load the Docker Image to Minikube.

Minikube is best suited for local development and testing, but it doesn't provide the same features and scalability as a full-scale production Kubernetes cluster.
Once installed, make sure to load the image name that you created with docker using this command
minikube image load your-image-name:tag.We used this for the app:minikube image load flask_web:latest. Runminikube image listto check if the image exists.

Step 5: Create a Kubernetes Deployments file.

Note: Make sure to add the image pull policy line as IfNotPresentto mitigate pull errors from images you have.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: your-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: your-app
  template:
    metadata:
      labels:
        app: your-app
    spec:
      containers:
      - name: your-container
        image: your-image-name:tag
        ports:
        - containerPort: 80
        imagePullPolicy: IfNotPresent

Step 6: Apply the deployment file to Minikube.

kubectl apply -f deployment.yaml


Step 7: Create a service file that exposes the flask application.

apiVersion: v1
kind: Service
metadata:
  name: your-service
spec:
  selector:
    app: your-app
  ports:
  - protocol: TCP
    port: 80
    targetPort: 80
  type: LoadBalancer

Step 8: Apply the service in minikube.

kubectl apply -f service.yaml

Step 9: Access the service.

To access the service, run the following command:
minikube service your-service If successful, it will launch in your browser.

Step 10: Stopping and deleting the Minikube cluster.

Once done, make sure you stop and delete the minikube cluster using the following commands:
minikube stop
minikube delete

Conclusion

In conclusion, we were able to deploy a container application in Kubernetes using Minikube as a testing tool which offered the best local testing environment. Kubernetes is the best tool for container orchestration, deployment, and scaling at the high end, while Docker complements Kubernetes by containerizing its applications.