Spring Boot Microservices with Kubernetes

Modern software development has evolved from monolithic architecture to microservices due to the flexibility, scalability, and the ability to develop, deploy, and manage each service independently.

However, scaling up the microservice architecture has dramatically increased it's complexity. Each microservice requires independent deployment, monitoring, scaling, and management. With hundreds or even thousands of services running in production, manual management becomes inefficient and error-prone.

Microservices need dynamic scaling based on traffic demands, proper fault isolation, and continuous monitoring to ensure high availability.

Modern container orchestration systems like Kubernetes were introduced to address these challenges, These systems automate the deployment, scaling, load balancing, and self-healing of containerized applications, significantly reducing operational overhead and enabling teams to manage microservices efficiently in distributed environments.

Kubernetes

Kubernetes is an open-source platform that automates deploying, scaling, and managing containerized applications. It handles tasks like load balancing, scaling, and self-healing, making it easier to manage large-scale microservices. Kubernetes simplifies infrastructure management and ensures high performance and reliability in distributed environments.

A Kubernetes Cluster

A Kubernetes cluster consists of two main components: the Control Plane and Worker Nodes.

Control Plane:

This is the brain of the cluster, responsible for managing the overall system. Key components include:

• API Server: Exposes the Kubernetes API for communication.
• Scheduler: Decides which node will run a new container.
• Controller Manager: Ensures the desired state of the system (e.g., replicas, scaling).
• etcd: A key-value store for cluster data and configurations.
• Cloud Controller Manager: The cloud-controller-manager runs controllers specific to the cloud provider.

Worker Nodes:

Worker nodes are where the actual applications run. These nodes host the following key components:

Pods: The primary deployment unit that runs one or more containers. Pods are scheduled on worker nodes based on resource availability and constraints set by the control plane.

Kubelet: An agent that communicates with the control plane, ensuring specified containers in pods are running and healthy. It receives instructions from the API server and reports node status back.

Kube-proxy: Manages network communication and load balancing for services, routing traffic to the correct pods according to service definitions.

Container Runtime: Responsible for executing containers within pods (e.g., Docker, containerd). It pulls images and manages the lifecycle of containers.

Pods and It's Environment

What's Inside a Pod:

• Containers: The actual application(s) or processes that run inside the pod.
• Volumes: Storage mounted inside the pod, accessible to all containers within the pod that Can be persistent (via PVCs) or ephemeral (temporary storage).
• ConfigMaps: Configuration data that the pod's containers can use for dynamic configuration(when mounted as files or exposed as environment variables).
• Secrets: Sensitive data like passwords or API keys injected into containers.
• Network Namespace: All containers in the pod share the same network stack, meaning they share the same IP address and can communicate with each other through localhost.

What's Outside a Pod:

• Deployments: Manage pod lifecycles by defining desired states for replicas. They automate creation, scaling, and updating of pods to maintain specified replica counts.
• Services: Provide stable network endpoints for accessing pods, enabling load balancing and service discovery while routing traffic to appropriate pods.
• Persistent Volume Claims (PVCs): Requests for storage by pods, specifying size and access modes. PVCs bind to available PVs, facilitating seamless access to persistent storage.
• Secrets and ConfigMaps (when stored in the Kubernetes Cluster): These resources are stored outside the pod in Kubernetes but are injected into the pod either as environment variables or mounted as files.

Deploying Spring Microservices

First, The Spring Boot Microservices need to containerized and when containerizing the internal services should be pointed at the Service names that are going to be in the Kubernetes cluster. For more information read my blog Containerizing Spring Boot Microservices.

Customer Service (Spring Boot)

Example Kubernetes Deployment File

apiVersion: apps/v1
kind: Deployment
metadata:
  name: customer
spec:
  replicas: 1
  template:
    metadata:
      name: customer
      labels:
        app: customer
    spec:
      containers:
       - name: customer
         image: radiocat2000/customerservicekb:latest
         imagePullPolicy: Always
         ports:
           - containerPort: 8050
         env:
           - name: SPRING_PROFILES_ACTIVE
             value: kubernetes
      restartPolicy: Always
  selector:
    matchLabels:
      app: customer        

• Deployment: Creates and manages a single replica of the customer container.
• Image: The container uses the radiocat2000/customerservicekb:latest image.
• Environment Variable: Sets the SPRING_PROFILES_ACTIVE variable to kubernetes.
• Port: Exposes container port 8050.
• Restart Policy: Ensures the container is always restarted if it fails.
• Selector: Matches the app: customer label to associate Pods with this Deployment.

Example Kubernetes Service File

apiVersion: v1
kind: Service
metadata:
  name: customer
spec:
  selector:
    app: customer
  ports:
    - port: 80
      targetPort: 8050        

• Service Name: The service is named customer.
• Selector: Matches Pods with the label app: customer (defined in the Deployment).
• Port 80: Exposes the service externally on port 80.
• TargetPort 8050: Forwards traffic from port 80 to port 8050 on the target Pods.

Refer my github repository for detailed implementation.

Conclusion

In conclusion, Kubernetes simplifies the management of containerized microservices by automating deployment, scaling, and maintenance, ensuring high availability and performance. By leveraging Kubernetes, Spring Boot microservices like the Customer Service can be deployed efficiently, with robust fault tolerance and dynamic scaling to meet modern application demands. For detailed implementation, refer to the linked resources.