Deploying Spring Boot microservices on Kubernetes is like creating a finely tuned orchestra of containerized applications. It marries the strengths of Spring Boot for building sturdy microservices and Kubernetes for managing these services at scale.

First things first, let’s touch on Kubernetes. Kubernetes is a powerhouse in the realm of container orchestration. It’s open-source, handles deployment, scaling, and management of apps in containers, and groups these containers into logical units called pods. The cherry on top? Kubernetes is cloud-agnostic, so it plays well with AWS, GCP, Azure, and even on-premises environments.

Before you dive in, you need the right tools. Docker Desktop is a must-have for building and running Docker images. You can snag it from the official Docker docs. Next, you’ll need a Kubernetes cluster. If you’re just starting, tools like Minikube or Kind can set up a local cluster for you, running on Docker. Alternatively, cloud giants like Google Cloud Platform, Amazon Web Services, or Microsoft Azure can roll one out. Make sure kubectl commands are a go from your shell to interact effortlessly with your Kubernetes cluster.

Now, let’s roll up our sleeves and build that Spring Boot application. Start by hitting up Spring Initializr to generate a starter project. Grab the dependencies you need, like Web and Actuator. If you’re crafting a REST API, Web is your buddy.

Next, code your Spring Boot application. For instance, if your task is managing student records, it might look something like this:

@RestController
@RequestMapping("/students")
public class StudentController {

    @Autowired
    private StudentService studentService;

    @PostMapping
    public Student createStudent(@RequestBody Student student) {
        return studentService.createStudent(student);
    }

    @GetMapping
    public List<Student> getAllStudents() {
        return studentService.getAllStudents();
    }
}

With your application coded, the next step is to containerize it. Create a Dockerfile at your project’s root. Here’s a sample for a Spring Boot app:

FROM openjdk:8-jdk-alpine
ARG JAR_FILE=target/myapp.jar
COPY ${JAR_FILE} app.jar
ENTRYPOINT ["java","-jar","/app.jar"]

Now, let’s build that Docker image:

docker build -t myapp .

Got a Docker registry? Push the image there:

docker tag myapp:latest <your-registry>/myapp:latest
docker push <your-registry>/myapp:latest

We’re about to deploy to Kubernetes. Create a deployment.yaml file:

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: <your-registry>/myapp:latest
        ports:
        - containerPort: 8080

Deploy this configuration with:

kubectl apply -f deployment.yaml

Voila! Your pods and services should be up and running. Check them with:

kubectl get pods
kubectl get services

To make your application accessible, you’ll need a service. Let’s create service.yaml:

apiVersion: v1
kind: Service
metadata:
  name: myapp-service
spec:
  selector:
    app: myapp
  ports:
  - name: http
    port: 8080
    targetPort: 8080
  type: LoadBalancer

Apply the service config with:

kubectl apply -f service.yaml

Now your app should be reachable via a load-balanced IP address.

Kubernetes also has health checks and readiness probes to keep your app in top shape. Add these to your deployment.yaml:

spec:
  template:
    spec:
      containers:
      - name: myapp
        image: <your-registry>/myapp:latest
        ports:
        - containerPort: 8080
        livenessProbe:
          httpGet:
            path: /actuator/health
            port: 8080
          initialDelaySeconds: 15
          periodSeconds: 15
        readinessProbe:
          httpGet:
            path: /actuator/health
            port: 8080
          initialDelaySeconds: 5
          periodSeconds: 10

Configuring your applications without hardcoding is smart. With Spring Cloud Kubernetes, you can use ConfigMaps and Secrets. Let’s say you have a configmap.yaml:

apiVersion: v1
kind: ConfigMap
metadata:
  name: myapp-config
data:
  application.properties: |
    server.port=8080
    spring.datasource.url=jdbc:mysql://localhost:3306/mydb
    spring.datasource.username=myuser
    spring.datasource.password=mypassword

Apply it with:

kubectl apply -f configmap.yaml

And inject these properties in your Spring Boot app with @Value:

@Value("${server.port}")
private int serverPort;

@Value("${spring.datasource.url}")
private String dataSourceUrl;

@Value("${spring.datasource.username}")
private String dataSourceUsername;

@Value("${spring.datasource.password}")
private String dataSourcePassword;

When dealing with multiple microservices, managing service discovery and inter-service communication is essential. Spring Cloud Kubernetes helps with this using the DiscoveryClient. Enable it with @DiscoveryClient:

@SpringBootApplication
@EnableDiscoveryClient
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}

Keeping an eye on your application is crucial. Tools like Prometheus and Grafana come in handy here. Spring Boot Actuator hooks you up with health and metrics endpoints that Prometheus can scrape.

Add Actuator to your dependencies:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

Then, configure Prometheus:

scrape_configs:
  - job_name: 'myapp'
    metrics_path: '/actuator/prometheus'
    static_configs:
      - targets: ['myapp-service:8080']

In summary, deploying Spring Boot microservices on Kubernetes blends the best of both worlds. You get the robustness of Spring Boot and the orchestration power of Kubernetes, making for a scalable, maintainable, and resilient architecture. Use practices like externalized configuration, health checks, and service discovery to keep everything running smoothly in a production environment.