Last week, we’ve learned how to deploy the Spring Boot application to Google Kubernetes Engine and connect it to the CloudSQL instance of MySQL database.

This time, I want to show you a more universal approach- deploying the Kotlin Spring Boot App with MySQL directly on Kubernetes. This approach requires a little more setup, but thanks to that, we gain more independence- we can easily migrate our environment between Kubernetes managed services providers (or to self-hosted k8s).

2. Prerequisites

To follow the tutorial you need the following prerequisites:

• kubectl (Kubernetes CLI to manage a cluster)
• minikube (local Kubernetes, making it easy to learn and develop for Kubernetes)
• docker (containerization tool)

3. Create Spring Boot Application

In this tutorial, I’d like to begin with developing our Spring Boot app first (but it’s also OK to start with the Kubernetes part).

3.1. Imports

As the first step, let’s add the following dependencies:

    implementation("org.springframework.boot:spring-boot-starter-web")
    implementation("org.springframework.boot:spring-boot-starter-data-jpa")
    runtimeOnly("mysql:mysql-connector-java")

Please remember, that you can see the full build.gradle configuration here.

3.2. Configure Application Properties

After we’ve successfully added the import, let’s head to the application.yaml file and configure it as follows:

spring:
  datasource:
    url: jdbc:mysql://mysql-svc:3306/${DB_NAME}?useSSL=false
    username: ${DB_USERNAME}
    password: ${DB_PASSWORD}
  jpa:
    hibernate:
      ddl-auto: update
    databasePlatform: "org.hibernate.dialect.MySQL5InnoDBDialect"

As you might have noticed, we are setting the MySQL connection details here. Please remember, that the host (mysql-svc) has to match the MySQL Kubernetes service name (we will set it up later). The ddl-auto property set to update will automatically export the schema DDL to the database when the SessionFactory is created (to put it simply, it will create the database schema based on our Spring Boot entities).

3.2. Create Model

As the next step, let’s add two classes to our project. User class, which will be the user entity we will persist in our MySQL database:

@Entity
class User(
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    val id: Long = 0,

    @Column
    val name: String
)

As you can see, it is a simple class containing two fields- autogenerated id and a name.

Nextly, let’s add UserRequest, which will be bound to the bodies of the web requests later:

class UserRequest(
    val name: String
)

3.4. Create Repository

After that, we can create the UserRepository interface, which will be used to perform the operations on the database:

interface UserRepository : CrudRepository<User, Long>

3.4. Create Service

As the next step, let’s implement the UserService class as follows:

@Service
class UserService(
    private val userRepository: UserRepository
) {

    fun saveUser(request: UserRequest): User =
        userRepository.save(
            User(
                name = request.name
            )
        )

    fun findAllUsers(): MutableIterable<User> =
        userRepository.findAll()
}

These two functions will be responsible for creating and getting the list of all users.

3.5. Implement Controllers

Finally, we can set up our controllers responsible for handling the incoming requests. Let’s start by adding the ApiStatusController:

@RestController
@RequestMapping("/api/status")
class ApiStatusController {
    @GetMapping
    fun getStatus(): ResponseEntity = ResponseEntity.ok("OK")
}

The GET /api/status endpoint will be used later to configure our K8s Pod’s readiness and liveness probes.

As the last step, let’s create the UserController class:

@RestController
@RequestMapping("/api/user")
class UserController(
    private val userService: UserService
) {
    @PostMapping
    fun createUser(@RequestBody request: UserRequest): ResponseEntity {
        val user = userService.saveUser(request)

        return ResponseEntity.ok(user)
    }

    @GetMapping
    fun findAllUsers(): ResponseEntity<MutableIterable> {
        val users = userService.findAllUsers()

        return ResponseEntity.ok(users)
    }
}

These two functions will be responsible for responding to the POST and GET requests to the /api/user endpoint. As you can see, we are using here the UserRequest class, we’ve implemented earlier as the createUser method parameter.

3.6. Build the JAR

Let’s build the jar with the Gradle wrapper:

./gradlew clean build -x test

Please notice “-x test” flag here. Testing goes beyond the main topic of this tutorial, so I’ve decided to go with this workaround for now.

3.7. Create Dockerfile

Nextly, let’s create the Dockerfile:

FROM openjdk
WORKDIR /work
COPY ./build/libs/k8s-mysql-0.0.1-SNAPSHOT.jar app.jar
ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","/work/app.jar"]

4. Deploy to Kubernetes

In this part, we are going to prepare the Kubernetes environment for our Spring Boot application. To keep this article as pragmatic as possible, we won’t spend too much time on the details here. If you would like to get a better understanding of these topics, please, let me know about it and I will prepare more materials about it.

4.1. Create Secrets

As the first step, let’s create the secrets.yaml file and put the configuration for our secrets here:

apiVersion: v1
kind: Secret
data:
  root-password: <BASE64-ENCODED-PASSWORD>
  database-name: <BASE64-ENCODED-DB-NAME>
  user-username: <BASE64-ENCODED-DB-USERNAME>
  user-password: <BASE64-ENCODED-DB-PASSWORD>
metadata:
  name: mysql-secret

In simple words, secrets let us store and manage sensitive information in a secure manner.
Please also notice that all of the values should be encoded as base 64. You can do that for instance on this website.

4.2. Create Persistent Volume

As the next step, let’s create the deployment-mysql.yaml file:

apiVersion: v1
kind: PersistentVolume
metadata:
  name: mysql-pv
  labels:
    type: local
spec:
  storageClassName: standard
  capacity:
    storage: 250Mi
  accessModes:
    - ReadWriteOnce
  hostPath:
    path: "/mnt/data"
  persistentVolumeReclaimPolicy: Retain
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: mysql-pvc
  labels:
    app: spring-boot-mysql
spec:
  storageClassName: standard
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 250Mi

A PersistentVolume (PV) is a piece of the storage in the cluster, while the PersistentVolumeClaim (PVC) is the request for storage.

4.3. Create MySQL Deployment

Deployments allow us to provide updates for our Pods and ReplicaSets in a declarative manner. To configure the MySQL database let’s add the following config to our deployment-mysql.yaml file:

---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: mysql-deployment
  labels:
    app: spring-boot-mysql
spec:
  selector:
    matchLabels:
      app: spring-boot-mysql
      tier: mysql
  strategy:
    type: Recreate
  template:
    metadata:
      labels:
        app: spring-boot-mysql
        tier: mysql
    spec:
      containers:
        - image: mysql:5.7
          name: mysql
          env:
            - name: MYSQL_ROOT_PASSWORD
              valueFrom:
                secretKeyRef:
                  name: mysql-secret
                  key: root-password
            - name: MYSQL_DATABASE
              valueFrom:
                secretKeyRef:
                  name: mysql-secret
                  key: database-name
            - name: MYSQL_USER
              valueFrom:
                secretKeyRef:
                  name: mysql-secret
                  key: user-username
            - name: MYSQL_PASSWORD
              valueFrom:
                secretKeyRef:
                  name: mysql-secret
                  key: user-password
          ports:
            - containerPort: 3306
              name: mysql
          volumeMounts:
            - name: mysql-persistent-storage
              mountPath: /var/lib/mysql
      volumes:
        - name: mysql-persistent-storage
          persistentVolumeClaim:
            claimName: mysql-pvc

As you can see above, we are passing our 4 secrets to the MySQL container as the environment variables- these values will be used for our connection.

4.4. Create MySQL Service

Finally, we need to expose the database for our Spring Boot application. Let’s do that by creating the service-mysql.yaml file and putting the following confirugation:

apiVersion: v1
kind: Service
metadata:
  name: mysql-svc
  labels:
    app: spring-boot-mysql
spec:
  ports:
    - port: 3306
  selector:
    app: spring-boot-mysql
    tier: mysql
  clusterIP: None

Please notice, that the name property of the metadata has to match the value from the application.yaml file of the Spring Boot project.

4.5. Create Spring Boot Deployment

After the MySQL part is correctly set up, we can configure the resources for our application. Let’s start by creating the deployment-spring.yaml file:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: spring-boot-deployment
  labels:
    app: spring-boot-mysql
spec:
  replicas: 2
  selector:
    matchLabels:
      app: spring-boot-mysql
  template:
    metadata:
      labels:
        app: spring-boot-mysql
    spec:
      containers:
        - image: spring-boot:0.0.1
          name: spring-boot-container
          imagePullPolicy: Never 
          ports:
            - containerPort: 8080
          readinessProbe:
            httpGet:
              port: 8080
              path: /api/status
            initialDelaySeconds: 10
            failureThreshold: 5
          livenessProbe:
            httpGet:
              port: 8080
              path: /api/status
            initialDelaySeconds: 10
            failureThreshold: 5
          env:
            - name: DB_NAME
              valueFrom:
                secretKeyRef:
                  name: mysql-secret
                  key: database-name
            - name: DB_USERNAME
              valueFrom:
                secretKeyRef:
                  name: mysql-secret
                  key: user-username
            - name: DB_PASSWORD
              valueFrom:
                secretKeyRef:
                  name: mysql-secret
                  key: user-password

Please notice one important thing here- in the next steps, I will show you how to use the local Spring Boot Docker image of our application. That’s why we’ve set the imagePullPolicy property to Never.

4.6. Create Spring Boot Service

The last thing, we need to configure for our backend is a Service. Let’s create then the service-spring.yaml file:

apiVersion: v1
kind: Service
metadata:
  name: spring-boot-svc
spec:
  ports:
    - port: 8080
      targetPort: 8080
      protocol: TCP
      name: http
  selector:
    app: spring-boot-mysql
  type: LoadBalancer

4.7. Apply and Verify Resources

Finally, we can deploy our configurations to the Kubernetes cluster. As the first step, let’s start a local Kubernetes cluster with minikube:

minikube start --vm-driver=virtualbox

As I’ve mentioned in step 4.5, in this tutorial, we will use the local docker image without pushing to any remote image repository.

To do that, let’s reuse the Docker daemon from Minikube:

eval $(minikube docker-env)

Please keep in mind, that this is a Unix command. If you are using Windows OS, please check out this StackOverflow topic.

Nextly, let’s build our docker image:

docker build -t spring-boot:0.0.1 .

Please remember, that the tag has to match the value from our Spring Boot deployment.

As the last step, let’s apply our configurations:

kubectl apply -f k8s/secrets.yaml
kubectl apply -f k8s/deployment-mysql.yaml 
kubectl apply -f k8s/service-mysql.yaml
kubectl apply -f k8s/deployment-spring.yaml
kubectl apply -f k8s/service-spring.yaml

To verify if everything is ready, we can use the following commands:

kubectl get svc
kubectl get deployments
kubectl get pods
kubectl get secrets

5. Verify the Application

To verify, if the application is working correctly, we will have to get the IP address of the running cluster and the port of the Spring Boot Service.

We can obtain the IP address in two ways: either by minikube or using kubectl command:

minikube ip
//result
192.168.39.87


kubectl cluster-info
//result
Kubernetes master is running at https://192.168.39.87:8443

To get the port of the application, let’s invoke the following command:

kubectl get svc spring-boot-svc 

//Example response
NAME              TYPE           CLUSTER-IP       EXTERNAL-IP   PORT(S)          AGE
spring-boot-svc   LoadBalancer   10.107.222.166        8080:30264/TCP   33s

As you can see above, the desired port of the application will be 30264. Please keep in mind, that this value will be different each time we will create the Service.

Finally, let’s create the user using the curl command:

curl -X POST -H "Content-Type: application/json" \
  --data '{"name":"Piotr"}' \
  192.168.39.87:30264/api/user

//response
{"id":1,"name":"Piotr"}

As the last step, let’s get the list of all users:

curl 192.168.39.87:30264/api/user

//Response:
[{"id":1,"name":"Piotr"}]

6. Summary

And that would be all for this article. In this step by step guide, we’ve learned how to deploy the Spring Boot and MySQL application on Kubernetes.

I am really aware that this topic is quite complex and requires an understanding of several concepts. The main goal for this tutorial was to walk you through the whole process without diving too much into the details. If you find anything in this article confusing or have any additional questions/suggestions, I will be more than happy if you would let me know about it (you can do that by our fan page, group, or a contact form).

To see the whole project, please visit this GitHub repository.

The post Deploy Kotlin Spring Boot App with MySQL on Kubernetes appeared first on Codersee blog- Kotlin on the backend.

If you’ve been learning programming for some time you probably heard about Kubernetes (also known as Kube or K8s). In simple words, Kubernetes is a system for automating loads of processes, like deployment, scaling, and management of containerized applications.

There is no doubt that the K8s can improve our productivity and make our application more stable. However, maintaining the whole system might become more difficult and time-consuming. Fortunately, we can find lots of cloud providers offering Kubernetes as a managed service, like:

• Google Kubernetes Engine (GKE),
• Azure Kubernetes Service (AKS),
• Amazon Elastic Container Service for Kubernetes (Amazon EKS)

Choosing a provider-managed solution transfers the responsibility for managing and provisioning the master node to the cloud provider allowing us to focus more on the development itself.

In this tutorial, we’ll see how to set up and deploy the sample Spring Boot application to Google Kubernetes Engine (GKE).

2. Prerequisites

To follow the tutorial you need the following prerequisites:

• kubectl (Kubernetes CLI to manage a cluster)
• gcloud (CLI tool to create and manage Google Cloud resources)
• Google Cloud Account (free $ 300 trial)

3. Create TestController Class With Test Endpoint

Let’s start with implementing the example TestController with getHelloMessage function:

@RestController
@RequestMapping("/api/hello")
class TestController {

    @GetMapping
    fun getHelloMessage() : ResponseEntity<String> = ResponseEntity.ok("Hello world!")
}

This is a very straightforward function responding to GET requests to /api/hello and returning “Hello world!” String as the response.

4. Create Dockerfile

As the next step, let’s prepare the Dockerfile we will use to build the Docker image later:

FROM openjdk
VOLUME /tmp
RUN mkdir /work
COPY . /work
WORKDIR /work
RUN /work/gradlew build
RUN mv /work/build/libs/*.jar /work/app.jar
ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","/work/app.jar"]

5. Build Docker Image

Secondly, let’s build a Docker image using already prepared Dockerfile:

docker build -t spring-boot-example .

When the command finishes its execution we will be informed that the image has been built and tagged successfully. We can also type docker images in the terminal to list all top-level images:

docker images

## command output
REPOSITORY                                          TAG                 IMAGE ID            CREATED              SIZE
spring-boot-example                                 latest              52eaa2a8ef8c        About a minute ago   1.12GB
openjdk                                             latest              0cd6de5fdbee        About a minute ago   511MB

As can be seen, the spring-boot-example image has been created and the OpenJDK image has been pulled as well.

6. Push Docker Image to Container Registry

As the next step, we will push the created image to the Google Container Registry. Before we will be able to do it, let’s make sure that we’ve got the container registry already configured and choose a correct hostname, which specifies the location where we will store the image.

Let’s start with tagging the local image with the registry name with the docker tag command:

docker tag spring-boot-example gcr.io/[PROJECT-ID]/spring-boot-example:0.0.1

Then, let’s push our image to the container registry:

docker push gcr.io/[PROJECT-ID]/spring-boot-example:0.0.1

Finally, when the command finishes its execution we can validate, whether the image has been uploaded successfully by listing Google Container Registry images:

gcloud container images list

## command output
NAME
gcr.io/[PROJECT-ID]/spring-boot-example

Please notice, that [PROJECT-ID] will be different depending on our project’s id.

7. Create a Cluster

Finally, we can create a new Kubernetes cluster within Google Kubernetes Engine. In this tutorial, we will use the cloud console (we could also do that using gcloud CLI). Let’s navigate to the panel and start by clicking the “Create cluster” button. Secondly, let’s configure cluster basics, like name and location type:

Then, let’s navigate to the node pools’ default-pool tab and set the number of nodes to 1 (this number will be bigger in the real scenarios, but for the educational purposes we do not need more):

As the last step, let’s click the Nodes tab, choose our machine type and boot disk size and click the “Create” button at the bottom of the site:

Please notice, that it may take some time before the changes will take place.

8. Create Kubernetes Deployment and Service

In order to run our application in the K8s environment, we will prepare two configuration files- one for the Deployment and one for the Service. In a nutshell, a Deployment is an object representing an application running on our cluster and a Service allows us to expose an application as a network service.

8.1. Create Deployment

Firstly, let’s create the deployment.yaml file containing the following configuration:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: spring-boot-example
  labels:
    app: spring-boot-example
spec:
  replicas: 1
  selector:
    matchLabels:
      app: spring-boot-example
  template:
    metadata:
      labels:
        app: spring-boot-example
    spec:
      containers:
        - image: gcr.io/[PROJECT-ID]/spring-boot-example:0.0.1
          name: spring-boot-example-container
          imagePullPolicy: Always
          ports:
            - containerPort: 8080
          readinessProbe:
            httpGet:
              port: 8080
              path: /api/status
            initialDelaySeconds: 5
            failureThreshold: 5
          livenessProbe:
            httpGet:
              port: 8080
              path: /api/status
            initialDelaySeconds: 5
            failureThreshold: 5

Please remember to replace [PROJECT-ID] with the correct value.

8.2. Create Service

Similarly, let’s create the service.yaml file containing service’s configuration:

apiVersion: v1
kind: Service
metadata:
  name: spring-boot-example-svc
spec:
  ports:
    - port: 80
      targetPort: 8080
      protocol: TCP
      name: http
  selector:
    app: spring-boot-example
  type: LoadBalancer

And that’s all the configuration that we need to prepare in order to set up our Pods and Service.

10. Apply Deployment and Service

10.1. Configure Kubectl Context

As one of the last steps we need to fetch the credentials of the running cluster and configure our kubectl context:

gcloud container clusters get-credentials [CLUSTER-NAME] --zone [CLUSTER-ZONE] --project [PROJECT-ID]

## command output
Fetching cluster endpoint and auth data.
kubeconfig entry generated for example-cluster.

Finally, let’s apply our configurations using the apply command:

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

11. Verification

11.1. Verify K8s Pods and Service

In order to check, whether the Pods have been created successfully let’s run kubectl get pods command:

kubectl get pods

## command output
NAME                                   READY   STATUS    RESTARTS   AGE
spring-boot-example-697976c749-klc64   1/1     Running   0          50s

As can be seen, all pods are ready and the status is Running, so we can check whether the service has been created and the external IP address has been assigned:

kubectl get svc

## command output
NAME                      TYPE           CLUSTER-IP   EXTERNAL-IP   PORT(S)        AGE
kubernetes                ClusterIP      10.0.0.1     <none>        443/TCP        10m
spring-boot-example-svc   LoadBalancer   10.0.4.57    34.69.49.59   80:31509/TCP   2m56s

11.2. Verify Test Endpoint

Finally, let’s check our test endpoint:

curl 34.69.49.59/api/hello

And we see that we Hello world! text is returned as the response, meaning that our application has been deployed successfully and exposed to the world.

12. Conclusion

In this article, we’ve learned how to deploy the Spring Boot application to Google Kubernetes Engine (GKE). We’ve covered how to containerize our application, build the image, push it to Google Container Registry, and finally deploy it to GKE.

For the source code, please visit our project on GitHub.

If you are reading this paragraph, I want to know that I am more than happy that you decided to spend your time learning with Codersee and I hope that this article helped you to learn something new. If you have any ideas or comments that you would like to share with us, please let us know in the comments below, by our Facebook page or group, or by using our contact form.

The post Deploy Spring Boot application to GKE appeared first on Codersee blog- Kotlin on the backend.