spring docker K8s

Spring, Docker, and Kubernetes: A Guide to Modern Application Deployment

In today's world of cloud-native applications, deploying and scaling applications efficiently has become a critical task. Spring, Docker, and Kubernetes are three powerful tools that, when combined, can simplify the process of building, packaging, and deploying applications. In this article, we will explore how to leverage these technologies to deploy a simple Spring Boot application.

Background

Spring Framework

Spring is a widely used Java framework for building enterprise applications. It provides a comprehensive programming and configuration model for Java developers. Spring Boot, an extension of the Spring Framework, further simplifies the development process by providing a convention-over-configuration approach.

Docker

Docker is a containerization platform that allows you to package applications and their dependencies into containers. Containers provide an isolated and portable environment, ensuring consistent behavior across different computing environments.

Kubernetes

Kubernetes is a container orchestration platform that automates the deployment, scaling, and management of containerized applications. It provides a declarative approach to manage applications, abstracting away the underlying infrastructure details.

Building a Spring Boot Application

Let's start by creating a simple Spring Boot application. You can use your preferred IDE or the Spring Initializr ( to generate a basic Spring Boot project.

@SpringBootApplication
public class MyAppApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyAppApplication.class, args);
    }
    
    @RestController
    public class HelloController {
        @GetMapping("/hello")
        public String hello() {
            return "Hello, Docker and Kubernetes!";
        }
    }
}

In this example, we have created a REST endpoint /hello that returns a simple greeting message.

Containerizing the Application with Docker

To containerize our Spring Boot application, we need to create a Docker image. Docker images are built using Dockerfiles, which specify the base image, dependencies, and instructions to build the image.

Create a file named Dockerfile in the root directory of your project with the following content:

FROM openjdk:11
COPY target/myapp.jar /app.jar
EXPOSE 8080
CMD ["java", "-jar", "/app.jar"]

This Dockerfile uses the official OpenJDK 11 image as the base image, copies the compiled JAR file into the image, exposes port 8080, and specifies the command to run the application.

Now, let's build the Docker image by running the following command from the project root directory:

docker build -t myapp:1.0 .

This command builds an image with the tag myapp:1.0 using the Dockerfile in the current directory.

To run the application in a Docker container, execute the following command:

docker run -p 8080:8080 myapp:1.0

Now, if you access http://localhost:8080/hello, you should see the greeting message.

Deploying with Kubernetes

Next, let's deploy our containerized Spring Boot application to Kubernetes.

Creating a Deployment

Create a file named deployment.yaml with the following content:

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

This YAML file defines a Deployment object named myapp-deployment with three replicas. It specifies the Docker image to use, the container port to expose, and other configurations.

To create the deployment, run the following command:

kubectl apply -f deployment.yaml

Creating a Service

Create a file named service.yaml with the following content:

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

This YAML file defines a Service object named myapp-service. It selects the pods with the label app: myapp, exposes port 80, and forwards traffic to port 8080 of the selected pods. The type: LoadBalancer ensures an external IP address is assigned to the service.

To create the service, run the following command:

kubectl apply -f service.yaml

Now, you can access your application using the external IP address provided by your Kubernetes cluster.

Conclusion

In this article, we explored how to deploy a Spring Boot application using Docker and Kubernetes. We containerized the application with Docker and created a Deployment and Service in Kubernetes to manage and expose the application. This approach allows for efficient scaling, management, and deployment of Spring Boot applications in a cloud-native environment.

By integrating Spring, Docker, and Kubernetes, developers can streamline the deployment process, enabling faster development cycles and more efficient resource utilization.