Use Case

Java Optimization on Kubernetes with StormForge

Automatically tune and optimize Java applications running on Kubernetes. Cut through Java application complexity to ensure application performance while minimizing resource usage and cost at scale.

See a DemoStart a Trial

Java tuning for performance and cost-efficiency is a time-consuming and frustrating experience, even when running on traditional infrastructures. Running JVMs on Kubernetes adds new layers of complexity. Developers lack actionable insights and are often buried under mountains of parameters and data, making it impossible to effectively tune Java apps using a manual, trial-and-error approach.

Application tuning complexity.

There are over a hundred JVM parameters that may affect application performance and resource (CPU and memory) utilization. Even the most experienced Java developers don’t know what every flag means and how it impacts performance. Add to that Kubernetes-specific parameters that are set at the container level and it’s simply too much for a human being to effectively tune and optimize.

Deployment and startup challenges.

Java is known to have slow startup times, and when running on Kubernetes those startup times are directly impacted by CPU resource settings. Many organizations struggle with setting Kubernetes startup, readiness and liveliness probes in a way that minimizes wasted resources while still ensuring application availability and a high quality user experience. The success of deployment strategies like blue-green, canary, and rolling deployments are all predicated on how long it takes an application to start up.

Scaling challenges.

Many organizations use the horizontal pod autoscaler (HPA) to add and remove replicas to meet fluctuating user demand while minimizing waste. Most organizations don’t understand startup times for these new pods, and how different CPU settings impact those startup times. This is especially true with Java applications, leading organizations to either set scaling thresholds too low, resulting in waste, or too high, resulting in risk to user experience.

Screenshot of a StormForge Experiment Results window, demonstrating that they can be analyzed and visualized to fully understand system behavior.

Experiment results can be visualized and analyzed to fully understand system behavior.

StormForge provides a complete solution for tuning and optimizing Java applications using machine learning, including:

Experimentation-based Java optimization. Used in non-production environments, experimentation is used to help organizations analyze, understand, and optimize their applications for a wide range of scenarios. Experimentation-based tuning provides deep insights into Java application start-up times, performance, and resource utilization to ensure successful and efficient deployment.
Observation-based Java optimization. Used primarily in production environments, StormForge machine learning is used to analyze data from observability tools to effectively respond to variations in actual usage by ensuring the HPA is configured optimally to allow for Java start-up times, and that pods are continuously right-sized.

Scientific approach.

Use experimentation to understand whether a Java application’s performance is CPU-bound or memory-bound. This helps narrow down the parameters for further experimentation and optimization.

Machine learning-powered.

Tune key Java parameters using machine learning so that your application performance meets or exceeds SLOs while ensuring optimal resource utilization and cost-efficiency.

Ensure efficient deployments.

Understand Java application startup times and how CPU settings affect those times, so that startup, liveliness and readiness probes can be configured to ensure efficiency of application deployments.

Keep things in tune.

Continuously tune HPA target utilization and pod resource settings to respond efficiently to fluctuations in actual usage of your Java applications.

Blackbox measurements.

Avoid any potential performance overhead due to metrics measurement gathering by leveraging observability platforms already connected to the platform instead of risking contamination by connecting directly to the JVM for data.