Tech Topic

Spring on Kubernetes

OpenShift is the best way to develop and run Kubernetes-native Spring and Spring Boot applications.

Get hands-on with Spring on OpenShift

What is Spring? 

The Spring Framework is one of the most popular Java Frameworks for building applications based on a distributed microservices architecture. Spring’s programming and configuration model for Java-based applications focuses on the “plumbing” so that developers can focus on application-level business logic, without unnecessary ties to specific deployment environments. Spring Boot then enables easy packaging and configuration of the application into a self-contained executable application which can be easily deployed as a container to Kubernetes.

Kubernetes-native Spring

Spring, like many traditional Java frameworks, does not inherently “know” that it is running in a container on a platform like Kubernetes. The Spring Framework includes many components that make building and deploying distributed applications easier, such as Spring Boot, Spring Cloud, Spring Web, and a host of other components to do service discovery, load balancing, request routing, and more. With Kubernetes, many of these concerns can be delegated to the underlying container platform to produce an application that integrates more efficiently with the platform it’s running on. Building Spring apps using these optimized code paths is key to unlocking the power of Spring + Kubernetes.


Kubernetes support for Spring developers 

Spring apps can rely on Kubernetes and capabilities deployed to it to provide the needed cloud services that enable efficient development on Kubernetes. This includes services like message queues, databases, persistence storage, and caching, among others.

Service registry

Microservice architectures often imply dynamic scaling of individual services, in a private, hybrid or public cloud where the number and address of hosts cannot always be predicted or statically configured in advance. In Kubernetes, service replication and scaling is a core feature. This means that the client does not need to keep a cache and account for the failure of the service registry itself. For example, Netflix Ribbon (often used with Spring apps) can be declaratively configured to use Kubernetes instead of a service registry, without any code changes.

Load balancing

For client calls to stateless services in Spring apps, high availability (HA) translates to a need to look up the service from a service registry, and load balance among available instances. Kubernetes provides a single service address where calls will be load balanced and redirected to an appropriate instance. Within a Kubernetes cluster, the service name resolves to this cluster IP address and can be used to reach the load balancer. For calls from outside and when going through the router is not desirable, an external IP address can be configured for the service.

Fault tolerance

The highly distributed nature of microservices implies a higher risk of failure of a remote call, as the number of such remote calls increases. Historically, the burden of implementing fault tolerance patterns like a circuit breaker has fallen to the developer. However, projects like Istio that implement a service mesh can alleviate this burden and provide much greater operational control over Spring services running in the cluster.

Externalized configuration

Externalized configuration management solutions can provide an elegant alternative to the typical combination of configuration files, command line arguments, and environment variables that are used to make applications more portable and less rigid in response to outside changes. Kubernetes ConfigMaps can be used to store fine-grained information like individual properties, or coarse-grained information like entire configuration files or JSON blobs. They provide mechanisms to inject containers with configuration data, keeping configuration separate from but accessible to Spring apps using annotations like @ConfigProperty.

Distributed tracing and application metrics

For all its advantages, a microservice architecture can be difficult to analyze and troubleshoot. Each business request spawns multiple calls to, and between, individual services at various layers. Distributed tracing ties all individual service calls together, and associates them with a business request through a unique generated ID. Going further, metrics enable Spring apps to expose application-level data to enable fine-grained examination of the state of an application. Tracing tools like Jaeger, combined with a metrics stack with Prometheus and Grafana provide a solid foundation for monitoring and troubleshooting Spring apps on Kubernetes. 


Optimizing Spring for Kubernetes

As Spring applications evolve into collections of decentralized services, managing communications and security between those services becomes more difficult. Red Hat OpenShift combined with Red Hat Runtimes provides Spring developers with the tooling, frameworks and native Kubernetes integrations necessary to build and manage Spring applications at scale on the industry's leading container and Kubernetes hybrid cloud platform.

Benefits of Red Hat OpenShift for Spring developers

Provides a natural “Spring Boot on Kubernetes” developer experience for both existing and net-new Spring apps

  • Support for building cloud native applications with Spring and Spring Boot
  • Integrates Kubernetes features that replace traditional standalone backing services
    • Externalized Configuration: Kubernetes ConfigMap and integration with Spring Cloud Kubernetes
    • Service Discovery: Kubernetes Services
    • Load Balancing: Kubernetes Replication Controller
    • Auto-Restart: Kubernetes Health Probes and integration with Spring Actutator
    • Metrics: Prometheus, Grafana, and integration with Spring Cloud Sleuth
    • Distributed Tracing with Istio & Jaeger Tracing
  • Developer tooling through Red Hat OpenShift and Red Hat CodeReady developer tooling to quickly scaffold new Spring projects, gain access to familiar Spring APIs in your favorite IDE, and deploy to Red Hat OpenShift

Use familiar Spring APIs and gain the benefits of the underlying Kubernetes platform and services in Red Hat OpenShift and Red Hat Middleware

Use Spring knowledge to develop next-generation apps using the latest in technology

  • Serverless Spring apps with Camel-K and Kafka
  • Use familiar Spring APIs to build container-native Java apps with Quarkus
  • Native Kubernetes Business Processes with Kogito
  • Use Kubernetes Operators to provide a natural way to create and link Spring apps together using native Kubernetes APIs via Halkyon

More resources

Learning scenario

Get Hands-on learning for developing Spring and Spring Boot apps on Kubernetes and OpenShift

Reference architecture

Understand how to architect distributed Spring apps on OpenShift

Open source

Learn more about Red Hat’s open approach to building and supporting Cloud Native Spring via the SnowDrop project