Codersee
Kotlin on the backend
Codersee
Kotlin on the backend
In this tutorial, we'll see how to set up and deploy the sample Spring Boot application to Google Kubernetes Engine (GKE)
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:
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).
To follow the tutorial you need the following prerequisites:
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.
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"]
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.
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.
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.
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.
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.
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.
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
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
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.
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.