Kubernetes with Spring Tutorial

Introduction to Kubernetes

Kubernetes (k8s) is an open-source system for automatic management, scaling, and deployment of containerized applications.

With the rise of microservices, we required a tool to deploy these independent applications. Containers like docker were the perfect fit for it. They provided a working environment for delivering microservices.

As the Microservices increased, so increases the number of containers. It becomes difficult to manage these containers with scripts. This problem has led to the creation of the container orchestration tool. Kubernetes is the answer to such a need.

Component of Kubernetes

Nodes

Kubernetes is a solution for containerized applications. One of the containers could be a docker but there are many other container solutions available. In order to manage these containers, we require an abstraction layer that talks with different vendors seamlessly.

The pod can be considered as a working unit for Kubernetes. A pod can have one or more containers.

Service

Each node on Kubernetes is assigned an IP. While pods in nodes can talk with each other using IP, nodes are ephemeral. They can die at any moment. Whenever a node dies, Kubernetes will create another one in its place to keep the desired state. **The new pod will have a new IP assigned. This will create a problem while the pods interact via IP.

To solve this Kubernetes creates a service assigned to pods and they will interact using service rather than IP. Service will remain the same even if the ip attached changes.

Control Plane

As we know Kubernetes is all about container management, to manage it we require some components. These components which help to manage the containers effectively, if grouped together will be known as the control plane.

Let’s look at the components that make the control plane.

API Gateway

As the name suggests it provides the gateway to interact with all nodes and its port to the outside world. Any communication to the pods from outside the cluster can happen via the API gateway.

Scheduler

To manage the desired state whenever a pod dies, we require a mechanism that can check the state on the cluster and can schedule the new pods if required. This is the work of the scheduler running from the control plane.

Control Manager

All of the components in the control plane is managed by controller processes. There are different controllers like Node, Jobs, Endpoints, Service, and Token controllers. All of them combined together are known as Control Manager.

etcd

To manage effectively we require some sort of memory. etcd acts as a database for all of the config maps and secrets.

Deployment

To deploy anything on Kubernetes, we create a deployment object which is a YAML file. It has all of the information related to container images, its location, and the metadata corresponding to pods

Service

Service is another YAML file that holds the configuration of protocols that is required for nodes to communicate and serve.

ConfigMap

Applications deployed via pods require many configurations, if we keep them inside pod we will have to build images for every change

Secrets

Many of the configurations are secrets, like database passwords, we can’t reveal them. We can save them as secrets rather than plain text. Kubernetes doesn’t control the encryption mechanism but these secrets are kept as encrypted text in etcd database.

Deploying Sample Spring Boot App to Kubernetes

Deploying Sample Spring Boot App to Kubernetes

Now with the understanding of Kubernetes basic building blocks, let us try our hand in creating an application and deploying it on Kubernetes. To start we will go to https://start.sprting.io and create a simple application which one endpoint. We will only select reactive web as a dependency.

We will create a with a get endpoint, The endpoint will take a String via query String and will welcome the user.

@RestController
public class SpringK8SDemoController {

    @GetMapping("/welcome")
    public Mono<String> welcome (@RequestParam("name") String param){
        return  Mono.just("Welcome "+ param);
    }
}

Before we create the containerize the docker file, let’s the final jar file at pom.xml k8s-demo

<build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
        **<finalName>k8s-demo</finalName>**
    </build>

Now we need to containerize the application. We will use a docker container. Let us add a file named Dockerfile. We will add it to the root directory of the project.

FROM openjdk:17-jdk-alpine
EXPOSE 8080
ARG JAR_FILE=target/k8s-demo.jar
COPY ${JAR_FILE} app.jar
ENTRYPOINT ["java","-jar","/app.jar"]

The file is self-explanatory, it adds OpenJDK 17 to the container and uses 8080 port for exposing. It just copies the file to the target directory and names it app.jar. In the end, it starts with command as an entry point that’s java -jar app.jar.

Let’s build the docker image and run it to verify.

mvn clean install
cd target
docker build -t codingsaint/k8s-demo
docker run -p 9090:8080 k8s-demo

The app should run and if you send HTTP request http://localhost:9090/welcome?name=Pallav , it should respond as welcome Pallav

Spring Boot Deployment using Deployment Object

In Kubernetes, we deploy using a configuration file in YAML format. The standard file of configuration is called deployment. Let’s create a deployment file as below and we will discuss its content.

Let’s create a deployment.yaml file at the root of the spring boot project.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: k8s-demo

spec:
  selector:
    matchLabels:
      app: k8s-demo
  replicas: 3
  template:
    metadata:
      labels:
        app: k8s-demo
    spec:
      containers:
        - name: k8s-demo
          image: k8s-demo:0.0.1-SNAPSHOT
          imagePullPolicy: IfNotPresent
          ports:
            - containerPort: 8080

In the above file, we are creating an object of kind deployment, named k8s-demo using metadata.name. At the spec level, we are defining that the app k8s-demo should have 3 replica

At spec.selector.spec.container we are defining the container properties. With imagePullPolicy as IfNotPresent it will look at local docker images first then at the remote.

Service Object

As we discussed the communication of pods, We need services that are attached to the pods. Service Object in Kubernetes can be created using YAML file. Let’s review the content of the service file. We are creating this file at root directory , let’s name it k8s-demo-svc.yaml

apiVersion: v1
kind: Service
metadata:
  name: k8s-demo-svc
spec:
  selector:
    app: k8s-demo
  ports:
    - protocol: TCP
      port: 8080
      targetPort: 8080
  type: NodePort

If you see spec , it clearly says to select (selector) the app k8s-demo. It also tells that the protocol is TCP.

Deploying to Kubernetes Cluster

Start Minikube

minikube start

You should be getting an output like below

PS C:\Users\07pal\development\tutorial\k8s\k8s-demo> minikube start
😄  minikube v1.25.1 on Microsoft Windows 11 Home Single Language 10.0.22000 Build 22000
✨  Using the docker driver based on existing profile
👍  Starting control plane node minikube in cluster minikube
🚜  Pulling base image ...
🔄  Restarting existing docker container for "minikube" ...
🐳  Preparing Kubernetes v1.23.1 on Docker 20.10.12 ...
    ▪ kubelet.housekeeping-interval=5m
    ▪ Generating certificates and keys ...
    ▪ Booting up control plane ...
    ▪ Configuring RBAC rules ...
🔎  Verifying Kubernetes components...
    ▪ Using image gcr.io/k8s-minikube/storage-provisioner:v5
🌟  Enabled addons: storage-provisioner, default-storageclass
🏄  Done! kubectl is now configured to use "minikube" cluster and "default" namespace by default

Build docker image

Before we deploy it to cluster we need Kubernetes and Docker images’ to be in sync . If you are on windows use below command

minikube docker-env | Invoke-Expression

If you are on Mac , use following

eval $(minikube docker-env)

Now we will build the docker image from the Dockerfile we created

docker build -t k8s-demo:0.0.1-SNAPSHOT .

This will create a Docker Image and we will deploy using our deployment object. The output of above command should be like

[+] Building 3.4s (8/8) FINISHED
 => [internal] load build definition from Dockerfile                                                               0.0s
 => => transferring dockerfile: 32B                                                                                0.0s
 => [internal] load .dockerignore                                                                                  0.0s
 => => transferring context: 2B                                                                                    0.0s
 => [internal] load metadata for docker.io/library/openjdk:17-jdk-alpine                                           3.3s
 => [auth] library/openjdk:pull token for registry-1.docker.io                                                     0.0s
 => [internal] load build context                                                                                  0.0s
 => => transferring context: 69B                                                                                   0.0s
 => [1/2] FROM docker.io/library/openjdk:17-jdk-alpine@sha256:4b6abae565492dbe9e7a894137c966a7485154238902f2f25e9  0.0s
 => CACHED [2/2] COPY target/k8s-demo.jar app.jar                                                                  0.0s
 => exporting to image                                                                                             0.0s
 => => exporting layers                                                                                            0.0s
 => => writing image sha256:714ae55f7105935be0267470795b5dc890d17c1773b194d5bfda9a45fa2d8b8c                       0.0s
 => => naming to docker.io/library/k8s-demo:0.0.1-SNAPSHOT                                                         0.0s

You can verify the images at local docker repo using command

docker images

It should give output like

REPOSITORY                    TAG              IMAGE ID       CREATED         SIZE
**k8s-demo                      0.0.1-SNAPSHOT   714ae55f7105   5 days ago      346MB**
gcr.io/k8s-minikube/kicbase   v0.0.29          64d09634c60d   5 weeks ago     1.14GB
mysql                         latest           ecac195d15af   3 months ago    516MB
mongo                         latest           fefd78e9381a   3 months ago    699MB
jaegertracing/all-in-one      latest           9844aed41d42   4 months ago    59MB
docker101tutorial             latest           c492a391575a   4 months ago    28.3MB
postgres                      12               91d892a67245   4 months ago    314MB
consul                        latest           b74a0a01afc4   5 months ago    116MB
alpine/git                    latest           b8f176fa3f0d   8 months ago    25.1MB
testcontainers/ryuk           0.3.1            ee7515743e6f   13 months ago   12MB
postgres                      11.5-alpine      da01ecfbabe1   2 years ago     71.8MB
openjdk                       8-jdk-alpine     a3562aa0b991   2 years ago     105MB

Deploy on Kubernetes

Let’s deploy it on Kubernetes using the deployment object that we created .

kubectl apply -f .\deployment.yaml

The above command will put out image from docker to kubernetes cluster and deploy as it is stated in deployment.yaml. The output should be looking something like

PS C:\Users\07pal\development\tutorial\k8s\k8s-demo> kubectl apply -f .\deployment.yaml
**deployment.apps/k8s-demo created**

We can verify our pods are up and running using

kubectl get pods

You will see pods name as output

PS C:\Users\07pal\development\tutorial\k8s\k8s-demo> kubectl get pods
NAME                        READY   STATUS    RESTARTS   AGE
k8s-demo-675766fff7-92kxk   1/1     Running   0          102s
k8s-demo-675766fff7-grsdm   1/1     Running   0          102s
k8s-demo-675766fff7-z6z4s   1/1     Running   0          102s

If you want to check logs of individual pod , you can use kubectl logs as

kubectl logs  k8s-demo-675766fff7-92kxk

We can see the spring boot app running at cluster. The below output can be taken as proof

.   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::                (v2.6.3)

2022-01-29 08:23:38.136  INFO 1 --- [           main] c.c.k8sdemo.K8sDemoApplication           : Starting K8sDemoApplication v0.0.1-SNAPSHOT using Java 17-ea on k8s-demo-675766fff7-92kxk with PID 1 (/app.jar started by root in /)
2022-01-29 08:23:38.138  INFO 1 --- [           main] c.c.k8sdemo.K8sDemoApplication           : No active profile set, falling back to default profiles: default
2022-01-29 08:23:42.756  INFO 1 --- [           main] o.s.b.web.embedded.netty.NettyWebServer  : Netty started on port 8080
2022-01-29 08:23:42.824  INFO 1 --- [           main] c.c.k8sdemo.K8sDemoApplication           : Started K8sDemoApplication in 6.006 seconds (JVM running for 7.407)

Creating Service

It’s running at a cluster we will not be able to access it directly so let us create a service . We will use the service file we created above to create the service

kubectl apply -f .\k8s-demo-svc.yaml

You can verify your service via kubectl get svc or kubectl get service

kubectl get svc
NAME           TYPE        CLUSTER-IP     EXTERNAL-IP   PORT(S)          AGE
k8s-demo-svc   NodePort    10.99.108.29   <none>        8080:31019/TCP   2m15s
kubernetes     ClusterIP   10.96.0.1      <none>        443/TCP          22m

Since we are on windows and even Kubernetes is running inside docker ,we need proxy to access pod , otherwise on linux we could have used cluster IP and the port 31019 (as shown above, for your case it will be different) .

Let’s hit the pod using below command. It will open your browser with proxy

minikube service k8s-demo-svc

It will also give following output

PS C:\Users\07pal\development\tutorial\k8s\k8s-demo> minikube service k8s-demo-svc
|-----------|--------------|-------------|---------------------------|
| NAMESPACE |     NAME     | TARGET PORT |            URL            |
|-----------|--------------|-------------|---------------------------|
| default   | k8s-demo-svc |        8080 | http://192.168.49.2:31019 |
|-----------|--------------|-------------|---------------------------|
🏃  Starting tunnel for service k8s-demo-svc.
|-----------|--------------|-------------|------------------------|
| NAMESPACE |     NAME     | TARGET PORT |          URL           |
|-----------|--------------|-------------|------------------------|
| default   | k8s-demo-svc |             | **http://127.0.0.1:52260** |
|-----------|--------------|-------------|------------------------|
🎉  Opening service default/k8s-demo-svc in default browser...
❗  Because you are using a Docker driver on windows, the terminal needs to be open to run it.

Here http://127.0.0.1:52260 is the URL where you can access your deployed pods. so you can check it via http://127.0.0.1:52260/welcome?message=Pallav

It will be giving you proper output.