Spring Boot and Kubernetes

Kubernetes is an open-source platform designed to automate deploying, scaling, and operating application containers. This guide covers the key concepts and steps for using Kubernetes with Spring Boot, including setting up a Kubernetes cluster, creating Docker images, writing Kubernetes configuration files, deploying Spring Boot applications, and managing Kubernetes resources.

Key Concepts of Spring Boot and Kubernetes

• Kubernetes: An open-source platform for automating deployment, scaling, and operations of application containers.
• Pod: The smallest deployable unit in Kubernetes, which can contain one or more containers.
• Service: An abstraction that defines a logical set of pods and a policy by which to access them.
• Deployment: A controller that provides declarative updates to applications.
• ConfigMap: A Kubernetes object used to store non-confidential data in key-value pairs.
• Secret: A Kubernetes object used to store sensitive data such as passwords, OAuth tokens, and ssh keys.

Setting Up a Kubernetes Cluster

Follow these steps to set up a Kubernetes cluster:

• Install Minikube (a local Kubernetes cluster) by following the instructions on the [Minikube website](https://minikube.sigs.k8s.io/docs/start/).
• Start Minikube:

$ minikube start

Creating Docker Images

Create a Docker image for your Spring Boot application. Ensure you have a Dockerfile in your project root directory:

Example: Dockerfile

# Use an official OpenJDK runtime as a parent image
FROM openjdk:11-jre-slim

# Set the working directory in the container
WORKDIR /app

# Copy the JAR file into the container
COPY target/myapp.jar /app/myapp.jar

# Expose the port the app runs on
EXPOSE 8080

# Run the JAR file
ENTRYPOINT ["java", "-jar", "myapp.jar"]

Build the Docker Image

$ docker build -t myapp:latest .

Writing Kubernetes Configuration Files

Create Kubernetes configuration files to define the deployment and service for your Spring Boot application:

Example: deployment.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp-deployment
spec:
  replicas: 2
  selector:
    matchLabels:
      app: myapp
  template:
    metadata:
      labels:
        app: myapp
    spec:
      containers:
      - name: myapp
        image: myapp:latest
        ports:
        - containerPort: 8080

Example: service.yaml

apiVersion: v1
kind: Service
metadata:
  name: myapp-service
spec:
  type: NodePort
  selector:
    app: myapp
  ports:
    - protocol: TCP
      port: 8080
      targetPort: 8080
      nodePort: 30007

Deploying Spring Boot Applications

Deploy your Spring Boot application to Kubernetes using the configuration files:

$ kubectl apply -f deployment.yaml
$ kubectl apply -f service.yaml

Managing Kubernetes Resources

Use kubectl commands to manage Kubernetes resources:

• Get the status of pods:

$ kubectl get pods

• Get the status of services:

$ kubectl get services

• Get the logs of a pod:

$ kubectl logs <pod-name>

• Delete a deployment:

$ kubectl delete deployment myapp-deployment

Example: Using ConfigMap and Secret

Create a ConfigMap and Secret to store configuration data:

Example: configmap.yaml

apiVersion: v1
kind: ConfigMap
metadata:
  name: myapp-config
data:
  SPRING_DATASOURCE_URL: jdbc:mysql://localhost:3306/mydb
  SPRING_DATASOURCE_USERNAME: user
  SPRING_DATASOURCE_PASSWORD: password

Example: secret.yaml

apiVersion: v1
kind: Secret
metadata:
  name: myapp-secret
type: Opaque
data:
  SPRING_DATASOURCE_PASSWORD: cGFzc3dvcmQ= # base64 encoded value of 'password'

Key Points

Conclusion

Kubernetes and Spring Boot provide a powerful combination for deploying, scaling, and managing applications. By understanding and using the capabilities of Kubernetes with Spring Boot, developers can create resilient, scalable, and maintainable applications efficiently. Happy coding!