Improves the experience in Kubernetes for Java developers

Kubernetes is an open-source project for automating deployment, scaling, and management of containers. It has rapidly become the standard to run production workloads and the community around it is just great!

But developing in Kubernetes presents some challenges. The typical development workflow looks like this: write code, build a Docker image, push it to the registry, redeploy, validate your changes, rinse and repeat. This flow is not only slow, but it also prevents us from benefitting from standard features of Java tools such as fast incremental builds, automatic hot reloads or powerful debuggers.
Okteto was created to solve this problem. On this blog post, we will show you how Okteto improves the developer experience in Kubernetes for Java developers. You will be able to take full advantage of tools like Maven, Gradle, dependency caching, popular frameworks hot reloads (Spring Boot, Quarkus, Micronaut, …) or IDE debuggers (Eclipse, IntelliJ, VS Code, …) while developing your application directly in Kubernetes.

Step 1: Deploy the Java Sample App
Get a local version of the Java Sample App by executing the following commands in your local terminal:
Gradle
$ git clone https://github.com/okteto/java-gradle-getting-started
$ cd java-gradle-getting-started
Maven
$ git clone https://github.com/okteto/java-maven-getting-started
$ cd java-maven-getting-started
The k8s.yml file contains the Kubernetes manifests to deploy the Java Sample App. Run the application by executing:
$ kubectl apply -f k8s.yml
deployment.apps "hello-world" created
service "hello-world" created
This is cool! You typed one command and your application just runs 😎.

Step 2: Install the Okteto CLI
The Okteto CLI is an open-source project that lets you develop your applications directly in Kubernetes while taking advantage of well-known tooling like Maven/Gradle, Spring Boot or IDE debuggers. We will use it to speed up our development cycle instead of using the typical development workflow based on building docker images and redeploying containers.
Install the Okteto CLI by running the following command in your local terminal:
MacOS/Linux
$ curl https://get.okteto.com -sSfL | sh
Windows
$ wget https://downloads.okteto.com/cli/okteto-Windows-x86_64 -OutFile c:\windows\system32\okteto.exe

Step 3: Start your development environment in Kubernetes
With the Java Sample Application deployed, run the following command in your local terminal:
$ okteto up
 ✓ Persistent volume provisioned
 ✓ Files synchronized
 ✓ Okteto Environment activated
   Namespace: pchico83
   Name: hello-world
   Forward: 8080 -> 8080
            8088 -> 8088okteto>
The okteto up command starts a Kubernetes development environment, which means:
The Java Sample App container is updated with the Docker image maven:latest or gradle:latest, depending on the git repo you have cloned. This image contains the required dev tools to build, test and run a Java application.

A file synchronization service is created to keep your changes up-to-date between your local filesystem and your application pods.
Inject the JAVA_OPTS environment variable to automatically run the Java application in debug mode.
Attach a volume to persist the Maven/Gradle cache in your Kubernetes development environment.
Container ports 8080 (the application) and 8088 (the debugger) are forwarded to the localhost.
Start a terminal into the remote container. Build, test and run your application as if you were in your local machine and get your application logs immediately in your terminal.more related on [java training in chennai](http://candidjava.com/training/advanced-java-training-in-chennai/).

All of this (and more) can be customized via the okteto.yml manifest file.
To run the application with Gradle, execute in the Okteto terminal:
okteto> gradle bootRun
If you are using Maven, execute:
okteto> mvn spring-boot:run
The first time you run the application, Maven/Gradle will download your dependencies and compile your application. Wait for this process to finish and test your application by running the command below in a local terminal:
$ curl localhost:8080
Hello world REST API!

Step 4: Develop directly in Kubernetes
Open src/main/java/com/okteto/helloworld/RestHelloWorld.java in your favorite local IDE and modify the response message on line 11 to be Hello world REST API from the cluster! Save your changes:
package com.okteto.helloworld;import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;@RestController
public class RestHelloWorld {
 
   @GetMapping("/")
   public String sayHello() {
       return "Hello world REST API from the cluster!";
   }
}
Your IDE will auto compile only the necessary *.class files that will be synchronized by Okteto to your application in Kubernetes. Take a look at the Okteto terminal and notice how the changes are detected by Spring Boot and automatically hot reloaded. To enable Spring Boot hot reloads you need to import the spring-boot-devtools dependency in your application.

Call your application to validate the changes:
$ curl localhost:8080
Hello world REST API from the cluster!
Cool! Your code changes were instantly applied to Kubernetes. No commit, build or push required 😎!

Step 5: Debug directly in Kubernetes
Okteto enables you to debug your applications directly from your favorite IDE. Let's take a look at how that works in Eclipse, one of the most popular IDEs for Java development.
Open the Debug configuration dialog, add a new Remote Java Application debug configuration, and point it to localhost:8088:
Click the Debug button to start a debugging session. Add a breakpoint on src/main/java/es/okteto/helloworld/RestHelloWorld.java, line 11, and call your application by running the command below from your local terminal.
$ curl localhost:8080
The execution will halt at your breakpoint. You can then inspect the request, the available variables, etc…
Conclusions
Kubernetes has the potential to be a great development platform, providing replicable, resource-efficient and production-like development environments. We have shown you how to use Okteto to create a development workflow that also lets you take advantage of features like incremental builds, debuggers or hot reloads while developing your application directly in Kubernetes.