NodePort: The Basic Approach

In the landscape of Kubernetes, ensuring that your application is accessible and capable of handling incoming traffic efficiently is crucial. Among the various strategies available for exposing services, the NodePort service type stands as a fundamental yet powerful option, especially for development environments. This article delves into configuring Minikube to use NodePort for load balancing, alongside a practical guide to setting it up with a Python application.

Understanding NodePort

A NodePort service in Kubernetes exposes a specific port on all nodes (machines) in the cluster to the outside world. This service type is particularly useful for development and testing purposes, as it allows you to access your application on a fixed port across every node. When traffic hits the node on the specified NodePort, Kubernetes routes it to the appropriate pods behind the service, effectively load-balancing the traffic.

Setting Up Minikube with NodePort

Before diving into the configuration, ensure that Minikube is installed and running on your system. Minikube is a tool that allows you to run Kubernetes locally, providing a platform to test Kubernetes applications.

Step 1: Deploy a Python Flask Application

Let’s start by creating a simple Python Flask application. Flask is a lightweight WSGI web application framework in Python, perfect for building simple web services.

Create a file named app.py with the following content:

from flask import Flask
app = Flask(__name__)

@app.route('/')
def hello_world():
    return 'Hello, World from Flask!'

if __name__ == '__main__':
    app.run(debug=True, host='0.0.0.0', port=8080)

Step 2: Dockerize the Application

To run the application in Minikube, you’ll need to containerize it. Create a Dockerfile in the same directory as your app.py:

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

# Set the working directory in the container
WORKDIR /app

# Copy the current directory contents into the container
COPY . .

# Install any needed packages specified in requirements.txt
RUN pip install flask

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

# Define environment variable
ENV NAME World

# Run app.py when the container launches
CMD ["python", "app.py"]

Ensure you have a requirements.txt file in the same directory, with Flask listed:

flask

Step 3: Build and Deploy the Application in Minikube

Switch to using Minikube’s Docker daemon:

eval $(minikube docker-env)

Build your Docker image:

docker build -t python-flask-app .

Step 4: Create a NodePort Service for Your Application

Create a Kubernetes deployment and service file, python-app-service.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: python-flask-app
spec:
  replicas: 2 # Number of replicas
  selector:
    matchLabels:
      app: python-flask-app
  template:
    metadata:
      labels:
        app: python-flask-app
    spec:
      containers:
      - name: python-flask-app
        image: python-flask-app
        ports:
        - containerPort: 8080
---
apiVersion: v1
kind: Service
metadata:
  name: python-flask-app-service
spec:
  type: NodePort
  ports:
    - port: 8080
      targetPort: 8080
      nodePort: 30007 # Specify a port or let Kubernetes assign one
  selector:
    app: python-flask-app

Deploy your application and service to Minikube:

kubectl apply -f python-app-service.yaml

Step 5: Access Your Python Flask Application

Retrieve the IP address of your Minikube node:

minikube ip

Your Python Flask application is now accessible at http://<minikube-ip>:30007.

Outcome

Using the NodePort service type in Kubernetes is an effective way to expose your applications for external access, especially in development and testing scenarios. By following the steps outlined above, you can deploy a Python Flask application in Minikube, making it accessible on a specific port across all nodes in the cluster. This approach not only simplifies access to your application but also lays the groundwork for understanding more complex load-balancing strategies in Kubernetes.

Continue to the next page for Minikube Service: Direct Access