{"id":1991,"date":"2021-11-30T12:00:00","date_gmt":"2021-11-30T11:00:00","guid":{"rendered":"https:\/\/kindsonthegenius.com\/blog\/kubernetes-beginner-tutorial-deploy-spring-boot-to-kubernetes-cluster\/"},"modified":"2026-07-05T03:26:13","modified_gmt":"2026-07-05T01:26:13","slug":"kubernetes-beginner-tutorial-deploy-spring-boot-to-kubernetes-cluster","status":"publish","type":"post","link":"https:\/\/kindsonthegenius.com\/blog\/kubernetes-beginner-tutorial-deploy-spring-boot-to-kubernetes-cluster\/","title":{"rendered":"Kubernetes Beginner Tutorial \u2013 Deploy Spring Boot to Kubernetes Cluster"},"content":{"rendered":"

In this tutorial, we would learn how to deploy a Spring Boot application to a local Kubernetes cluster. This would be the first of series of tutorials on DevOps with Docker and Kubernetes for beginners. At the end of the series, you should be able to deploy web applications along with their databases to Docker and Kubernetes cluster.<\/p>\n

In this very part, we would setup Kubernetes cluster locally (Minikube), create a simple SpringBoot application and deploy to the Kubernetes cluster<\/p>\n

We cover the following<\/p>\n

    \n
  1. Have Docker Installed and Tested<\/a><\/li>\n
  2. Setup Minikube<\/a><\/li>\n
  3. Create and Build a Spring Boot Application<\/a><\/li>\n
  4. Create a Docker Image<\/a><\/li>\n
  5. Optional – Push the Image to Docker Hub<\/a><\/li>\n
  6. Create Deployment and Deploy to Kubernetes Cluster<\/a><\/li>\n
  7. Test the Deployment<\/a><\/li>\n<\/ol>\n

     <\/p>\n

    Follow the steps below:<\/p>\n

    Step 1 – Have Docker installed<\/strong><\/p>\n

    You need to ensure that Docker is installed and running. Use this command:
    \n<\/p>\n

    docker version\r\n<\/pre>\n
    You may want to get used to docker and Spring Boot using\u00a0 this short practical tutorial:<\/p>\n
    Introduction to Dockerfile with Spring Boot \u2013 How to Dockerize SpringBoot App<\/a><\/p>\n
    SpringBoot Docker – Video Tutorial<\/a><\/p>\n
     <\/p>\n
    Step 2 – Setup Minikube<\/strong><\/p>\n
    Minikube is a way to run Kubernetes cluster locally on your machine. Also check that you have Minikube.<\/p>\n
    Use the command<\/p>\n
    <\/p>\n
    minikube version\r\n<\/pre>\n
    Once you are sure Minkube is installed, go ahead to start it using the command:
    \n<\/p>\n
    minikube start\r\n<\/pre>\n
    Just to let you know, kubectl<\/strong> is a command line tool for managing Minikube.<\/p>\n
     <\/p>\n
    Step 3 – Create and build a SpringBoot Application<\/strong><\/p>\n
    In this demo, we just create a simple SpringBoot REST API that return a string. But this works for bigger applications as well (without database because we would be talking about database deployment later). I call this application kubedemo<\/strong><\/p>\n
    Use the command below to create your jar file
    \n<\/p>\n
    mvn clean install -DskipTests\r\n<\/pre>\n
    You can now check that the target folder of your application contains your jar file.<\/p>\n
     <\/p>\n
    Step 4 – Create a Docker image of your application<\/strong><\/p>\n
    To do this you should have a docker file in the root directory of your application. The complete procedure to dockerize your Spring Boot Application is given here. <\/a>The easiest way to create a docker image of your application is to use Buildpacks. The command is simply:
    \n<\/p>\n
    mvn spring-boot:build-image\r\n<\/pre>\n
    This command would create a local image of your application using the jar file you created in step 3.<\/p>\n
    You can verify that the image is created using the command below:<\/p>\n
    <\/p>\n
    docker images\r\n<\/pre>\n
    This command would list all the docker images available in your local repository. You should see the new image you just built!<\/p>\n
     <\/p>\n
    Step 5 – Push to Docker Hub (Optional)<\/strong><\/p>\n
    You can actually leave your image locally. But it’s fine you know how to push your image to Docker hub online. In this way, you can get them from anywhere or even share with friends.<\/p>\n
    You need two commands:<\/p>\n
    First, tag the image:<\/p>\n
    <\/p>\n
    docker tag kubedemo:0.0.1-SNAPSHOT kindsonthegenius\/kubedemo\r\n<\/pre>\n
     <\/p>\n
    Second, push to Docker hub:<\/p>\n
    docker push kindsonthegenius\/kubedemo\r\n<\/pre>\n
     <\/p>\n
    Step 6 – Deploy to Kubernetes Cluster<\/strong><\/p>\n
    As you know, a cluster is a collection of two or more machines called nodes. Same is true of Kubernetes. A Kubernetes cluster is made up of a number of nodes. However, the nodes in a Kubernetes cluster consists of ‘sub-nodes<\/strong>‘ called pods<\/strong>. So when we setup Minikube, we did create a cluster with a single node but could have several pods.<\/p>\n
    To be able to deploy our image to Kubernetes, we need to do three things:<\/p>\n
    1. Create a deployment<\/em><\/p>\n
    A deployment is a yml file that specifies how your application would run in the Kubernetes cluster.\u00a0 You can have this yaml file created automatically for you using the command:
    \n<\/p>\n
    kubectl create deployment kubedemo --image=kindsonthegenius\/kubedemo --dry-run -o=yaml\r\n<\/pre>\n
     <\/p>\n
    2. Create a Service<\/em><\/p>\n
    A service defines how connections can be make from outside the cluster into your application running inside the Kubernetes cluster. To have a service created for you, use the command:
    \n<\/p>\n
    kubectl create service clusterip kubedemo --tcp=8080:8080 --dry-run -o=yaml\r\n<\/pre>\n
    In this case, we specify that our application would be running on port 8080 both inside and outside the container. ClusterIp indicates that we can connect to the application using the cluster’s ip address. The command below gives you the details of the cluster including the IPs.
    \n<\/p>\n
    kubectl get all\r\n<\/pre>\n
     <\/p>\n
    3. Apply the deployment<\/em><\/p>\n
    This means you actually deploy the application to the cluster and the pods(containers are started). Use the command:<\/p>\n
    kubectl apply -f deployment.yaml\r\n<\/pre>\n
     <\/p>\n
    Step 7 – Test Your Deployment<\/strong><\/p>\n
    Now we need to check that everything is working! First you may want to check that the pods are up. This can be done using the command
    \n<\/p>\n
    kubectl get pods\r\n<\/pre>\n
     <\/p>\n
    Then you can use the command below to get the list of services<\/p>\n
    <\/p>\n
    kubectl get services\r\n<\/pre>\n
    Finally, use the command below to fire up your application:<\/p>\n
    <\/p>\n
    minikube service <service-name>\r\n<\/pre>\n
    This command opens up your browser and you can then go ahead to visit the endpoint \/home<\/p>\n
     <\/p>\n","protected":false},"excerpt":{"rendered":"
    In this tutorial, we would learn how to deploy a Spring Boot application to a local Kubernetes cluster. This would be the first of series … <\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"pagelayer_contact_templates":[],"_pagelayer_content":"","footnotes":""},"categories":[414],"tags":[],"class_list":["post-1991","post","type-post","status-publish","format-standard","hentry","category-programming"],"_links":{"self":[{"href":"https:\/\/kindsonthegenius.com\/blog\/wp-json\/wp\/v2\/posts\/1991","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/kindsonthegenius.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/kindsonthegenius.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/kindsonthegenius.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/kindsonthegenius.com\/blog\/wp-json\/wp\/v2\/comments?post=1991"}],"version-history":[{"count":1,"href":"https:\/\/kindsonthegenius.com\/blog\/wp-json\/wp\/v2\/posts\/1991\/revisions"}],"predecessor-version":[{"id":2159,"href":"https:\/\/kindsonthegenius.com\/blog\/wp-json\/wp\/v2\/posts\/1991\/revisions\/2159"}],"wp:attachment":[{"href":"https:\/\/kindsonthegenius.com\/blog\/wp-json\/wp\/v2\/media?parent=1991"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/kindsonthegenius.com\/blog\/wp-json\/wp\/v2\/categories?post=1991"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/kindsonthegenius.com\/blog\/wp-json\/wp\/v2\/tags?post=1991"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}