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.