Deploy Microservices to Minikube

This section focuses on deploying microservices locally using Kubernetes with Minikube. It allows developers to simulate a real production-like Kubernetes environment directly on their local machine.

? With Minikube, you can test deployments, services, and scaling behavior without needing a cloud-based Kubernetes cluster.

What is Minikube

Minikube is a lightweight Kubernetes distribution that allows you to run a local Kubernetes cluster on your own machine. It is mainly used for development, testing, and learning Kubernetes concepts without needing a cloud setup.

Key Features

Runs a single-node Kubernetes cluster locally on your system
Ideal for learning and experimenting with Kubernetes safely
Supports core components like Pods, Services, and Deployments
Helps test applications without cloud infrastructure
Easy setup and quick startup for development workflows

Example: Starting Minikube

Once Minikube is installed, you can start a local Kubernetes cluster using a simple command:

minikube start

? This command initializes a local Kubernetes cluster on your machine.

Example: Checking Cluster Status

You can verify that your cluster is running using:

kubectl get nodes

Output Example:

NAME       STATUS   ROLES           AGE
minikube   Ready    control-plane   1m

? In simple words: Minikube creates a ready-to-use Kubernetes environment on your local system so you can deploy and test applications easily.

Setting Up Minikube

To start working with Kubernetes locally, you need to install the required tools first. These tools allow you to create and manage a local Kubernetes cluster on your system.

Install Required Tools

Minikube
kubectl (Kubernetes Command Line Interface)

Start Minikube Cluster

After installation, you can start your local Kubernetes cluster using the following command:

minikube start

? This command initializes and starts a local Kubernetes cluster on your machine, making it ready for deploying and testing applications.

Fix in Your Original Content

You wrote:

minikubestart

Correct command is:

minikube start

Preparing Microservices (Docker Images)

Before deploying microservices to Kubernetes, each service must be containerized using Docker to ensure consistent behavior across different environments.

Example Microservices

user-service
order-service

Steps to Prepare Docker Images

Build Docker images for each microservice
Tag images with version (e.g., v1.0, latest)
Load images into Minikube (if needed for local setup)

Example: Build Docker Images

docker build -t user-service:1.0 .
docker build -t order-service:1.0 .

Load Images into Minikube (Optional)

minikube image load user-service:1.0
minikube image load order-service:1.0

? This step converts microservices into Docker images so they can run consistently inside Kubernetes.

Writing Kubernetes Manifests

Kubernetes uses YAML configuration files (called manifests) to define and manage application resources inside the cluster.

These files describe how your application should be deployed, run, and managed in Kubernetes.

What Kubernetes Manifests Define

Deployments (application pods and replicas)
Services (network exposure and communication)
Scaling rules (number of replicas)
Container configuration (image, ports, environment variables)

? In simple terms, Kubernetes manifests act as a blueprint for running your application inside a cluster.

Example Kubernetes Manifest (Deployment)

apiVersion: apps/v1
kind: Deployment
metadata:
  name: user-service
spec:
  replicas: 2
  selector:
    matchLabels:
      app: user-service
  template:
    metadata:
      labels:
        app: user-service
    spec:
      containers:
        - name: user-service
          image: user-service:1.0
          ports:
            - containerPort: 8080

Example Kubernetes Manifest (Service)

apiVersion: v1
kind: Service
metadata:
  name: user-service
spec:
  type: NodePort
  selector:
    app: user-service
  ports:
    - port: 80
      targetPort: 8080
      nodePort: 30080

Deployment YAML

A Deployment YAML defines how an application should run inside a Kubernetes cluster. It ensures that your application is deployed in a controlled, scalable, and reliable way.

What a Deployment Includes

Creation of Pods (running containers)
ReplicaSets (for scaling and self-healing)
Container image definition
Restart policies for failed containers

? In simple words: Deployment ensures your application is always running in the desired state.

Example:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: user-service
spec:
  replicas: 2
  selector:
    matchLabels:
      app: user-service
  template:
    metadata:
      labels:
        app: user-service
    spec:
      containers:
        - name: user-service
          image: user-service:1.0
          ports:
            - containerPort: 8080

Explanation:

replicas: 2 → Runs 2 copies of the application
image → Docker image used for deployment
containerPort → Port exposed inside the container
labels → Helps Kubernetes identify and manage Pods

Service YAML

A Service YAML in Kubernetes is used to expose your application so it can be accessed either inside the cluster or from outside the cluster.

It acts as a network bridge between users and running Pods.

Why Service is Important

Provides stable network access to Pods
Handles load balancing automatically
Ensures communication between microservices
Exposes applications internally or externally

Types of Kubernetes Services

ClusterIP

Default service type
Used for internal communication only within the cluster

NodePort

Exposes application to external traffic via a port on the node
Can be accessed from browser using node IP

Example:

apiVersion: v1
kind: Service
metadata:
  name: user-service
spec:
  type: NodePort
  selector:
    app: user-service
  ports:
    - port: 80
      targetPort: 8080
      nodePort: 30080

Explanation:

type: NodePort → Exposes service externally
selector → Connects service to matching Pods
port: 80 → Service port inside Kubernetes
targetPort: 8080 → Container application port
nodePort: 30080 → External access port in browser

Deploying Multiple Services

In a microservices architecture, applications are broken into multiple independent services. Each service is deployed separately in Kubernetes.

Key Concepts

Each microservice runs as an independent application
Every service has its own Deployment YAML and Service YAML
Each service can be scaled independently based on demand
Failures in one service do not affect others

? This makes the system flexible, modular, and easy to manage.

Why Multiple Services Matter

Better scalability for each component
Easier debugging and maintenance
Independent deployment lifecycle
Improved system reliability

Service Communication

In Kubernetes, microservices communicate using service names instead of IP addresses.

This is possible because Kubernetes provides built-in service discovery.

Example Communication

<http://user-service:8080>

Benefits of Service Communication

No need to use hardcoded IP addresses
Automatic service discovery inside cluster
Easy scaling without changing configurations
Simplified maintenance and updates

Accessing Applications

After deploying your services in Kubernetes using Minikube, you can access your applications in different ways depending on your service type.

Option 1: Using Minikube Service Command

Minikube provides a simple command to open your service directly in the browser.

minikube service user-service

Option 2: Using NodePort URL

If your service is exposed using NodePort, you can access it using the Minikube IP and assigned port.

http://<minikube-ip>:30080

To get Minikube IP:

minikube ip

How It Works

Kubernetes exposes the service using NodePort
Minikube assigns a local IP address
The application becomes accessible through browser

Conclusion

Deploying microservices on Minikube is a practical way to simulate a real Kubernetes environment on your local machine.

It allows developers to safely build, test, and manage applications before moving to production.

Better understanding of Kubernetes architecture
Easy testing of individual microservices
Hands-on practice with real deployment workflows
Faster debugging before production release

? Minikube bridges the gap between local development and real-world Kubernetes deployment.