WebSphere and Open Liberty: Ideal for cloud-native Java applications

Liberty is a fast, modular, cloud-native Java runtime. IBM WebSphere Liberty was created in 2012 in response to increasing demand for a developer-friendly, lightweight, agile Java runtime. In 2017, IBM released the source code of WebSphere Liberty as the Open Liberty project, from which both WebSphere Liberty and Open Liberty are now built.

For new cloud-native applications, Open Liberty likely provides what you need and has the option of commercial support from IBM. WebSphere Liberty delivers everything in Open Liberty plus additional features that make it easier to modernize existing enterprise applications and manage large-scale clusters in virtual machines. You can run WebSphere Liberty, Open Liberty, or a combination of both in your environments.

Liberty greatly simplifies the development and deployment of applications when compared with traditional application server runtimes. Liberty is simple to configure, and you can create right-sized deployments, from under 34 MB all the way up to the inclusion of full Jakarta EE/Java EE support. Liberty's zero-migration architecture removes version-to-version migration challenges, auto-tuning delivers optimal performance without costly tuning cycles, and a regular release cadence enables continuous delivery, and much more.

In addition to these characteristics, Liberty also offers first-class container support, Kubernetes optimizations, and the use of cloud-native APIs, such as MicroProfile and Jakarta EE. All of these characteristics make Liberty the perfect choice for new, cloud-native, micro-service-based applications. Because Liberty also supports older APIs, if you need them, Liberty is also ideal for running your existing workloads as you start your modernization journey, no matter how far you want to go.

So, let's look in a bit more detail at what differentiates Liberty from other runtimes, specifically exploring the top six reasons why Liberty is an ideal choice for cloud-native Java microservices and applications.

1. Monoliths, macroservices, or microservices
2. Breadth of API support
3. Developer tools for rapid iteration
4. Easily stay current and eliminate technical debt with zero migration
5. Lower costs with improved application performance
6. Lower costs with efficient cloud resource utilization

Reason 1. Monoliths, macroservices, or microservices

Organizations can have differing architectural needs depending on a variety of factors: the size and structure of an organization and each team, the frequency of updates required, and flexibility and agility needs. If you select a runtime that caters to a breadth of architectural support, you can avoid the frustration of having to change runtimes depending on a Java application’s architectural requirements, which might change over time anyway.

Liberty offers this broad architectural support. Liberty is a cloud-native runtime that is modular in nature and has proven capable of running a wide variety of mission-critical applications all of which implement different architectural styles, including: large-scale enterprise monoliths in VMs to small microservices on containers, whether they are on-premises or in your cloud of choice, in Kubernetes, or in Red Hat OpenShift.

Real customer examples of the importance of this benefit of Liberty includes PowerM’s use of Liberty to help enhance mission-critical government services for the Moroccan government and Primeur’s use of Liberty to support applications with differing architectural styles.

Reason 2. Breadth of API support

Supporting a breadth of standard APIs ensures flexibility and portability for your applications and helps to avoid the frustrations often caused by vendor lock-in.

Liberty enables a broad set of APIs that developers can take advantage of, including:

• Industry standards (for example, MicroProfile and Jakarta EE)
• Open source frameworks (for example, Spring Boot)
• Older APIs, which make it easier to run older applications unchanged (for example, Java EE 6, 7, and 8)

In fact, many of the architects and engineers that work on Liberty are running and leading these open source standards, projects, and communities, putting Liberty at the forefront of these innovative activities.

While Liberty supports this broad range of APIs, Liberty’s modular nature means that you only need to include the APIs your application needs, so that you can have right-size images that are as lightweight as possible, ready for deployment to the cloud.

This broad spectrum of API support enables Liberty to minimize modernization efforts. For any application, with Liberty you can either use your existing investment and produce a modern, modular, hybrid cloud application, or you can build a new cloud-native replacement application from scratch.

Suva, a leading provider of health care coverage in Switzerland, provides a great example of the benefits of Liberty’s API and OSS standards support.

Reason 3. Developer tools for rapid iteration

A first-class developer experience enables developers to be more productive. The new Liberty Tools are intuitive and powerful developer tools that integrate with the most popular integrated development environments (IDEs) for Java: Eclipse IDE, Visual Studio Code, and IntelliJ IDEA. With Liberty Tools, developers get editing and code assistance to help them efficiently develop, test, and debug cloud-native applications that use the MicroProfile and Jakarta EE open standards.

The Liberty Tools also enable use of Liberty’s dev mode directly from these IDEs, offering automated hot reload in running servers. Liberty’s dev mode enable developers to run and test code and configuration changes, in a local container or on a local server, quickly and easily, with test reports available within the IDE. This removes the need for a full rebuild and redeploy after each code or configuration change, greatly reducing the time that developers take to develop and test updates. Integration with the most popular build tools – Maven and Gradle – and the container support means that developers can develop and test in an environment that's as similar as can be to production.

The following video offers an in-depth view for developers into what the Liberty Tools offers and how to use it with the integrated development environment (IDE), Visual Studio Code:

Video will open in new tab or window.

Reason 4. Easily stay current and eliminate technical debt with zero migration

Moving to the latest version of technology that an application depends on, for enhanced security or to take advantage of new functionality, can often require significant changes to application code or configuration. These kinds of moves have historically filled teams with dread, having to be planned months in advance and taking months if not years to complete — that’s a lot of investment just to stay current.

With Liberty, “zero migration” architecture makes it refreshingly easy to move up to the latest Liberty version in just minutes (or seconds) and without having to change the application code or config. Coupling zero migration with Liberty Continuous Delivery means that developers can update as quickly as every 4 weeks and know that they have the latest security fixes and enhancements.

Our client case study with IBM Business Partner, RedBridge, showcases the importance and significant advantages that our zero migration architecture enabled for a large European bank.

The following video highlights why zero migration is beneficial in a practical manner through a demo application that is being updated with over 900 fixes without any code or configuration changes!

Reason 5. Lower costs with improved application performance

Cloud and serverless architecture styles have created a need for rapid dynamic scaling of applications in response to fluctuating workload demands. When workload demand is low, applications need to scale down to reduce operational costs, which is known as "scale-to-zero." Then, as demand increases again, more instances of the application and runtime need to be provisioned; this scaling up must happen quickly so that end users don’t experience a lag in response times. Therefore, the startup time of your runtime can play a significant part in application performance and optimizing costs.

The JVM has for many years been optimized for high throughput of applications, focusing on doing much of the work when a JVM instance starts, rather than focusing on responding to a first request as quickly as possible. However, rapid dynamic scaling requires subsecond startup times. Liberty’s InstantOn feature, based on Linux’s checkpoint/restore technology, enables your applications to start in milliseconds, without compromising on throughput, memory, development-production parity, or Java language features (quite unlike GraalVM native compilation).

The following graph shows that applications typically start up to 10 times faster with InstantOn so that applications can rapidly scale up but then also scale to zero when the application is not in use. To find out more about Liberty InstantOn, see this article, “Rapid Startup of Your Cloud-Native Java Applications without Compromise.”

Your application’s throughput is a critical application performance metric to consider and optimize. The association between throughput and costs is simple: being able to put more work through a runtime means you can deploy fewer instances to satisfy demand. You pay less on infrastructure and less on license costs, which are typically based on virtual CPU usage.

As you can see in the following graph, Liberty also has significant throughput benefits when compared to other runtimes. The following graph shows throughput measurements against the Acme Air Microservices benchmark. Liberty has the overall best performance across the runtimes tested.

Reason 6. Lower costs with efficient cloud resource utilization

When you run applications in the cloud, the size of the application on disk, the amount of memory it uses, and its CPU usage together determine the cloud costs to your business. With microservices architectures, you are now often running tens or hundreds of microservices, with an instance of the runtime per service, so it’s important that these microservices are as efficient as possible. Even if you don't deploy microservices, other architectures, such as monoliths, benefit from a low-cost small-footprint runtime too.

Liberty is small and modular; simply add to the Liberty kernel only the capabilities, or features, you need for the service.

The following table shows the size on disk and memory for three different application types that are running with Open Liberty 23.0.0.5 (Java17):

There is a clear correlation between memory footprint and the cost of cloud services. For example, the Azure Kubernetes Service pricing effectively doubles as you double the memory requirements of the nodes. Liberty’s low memory footprint is highlighted in the following comparison graph.

Liberty also benefits from additional cloud optimizations when used in conjunction with IBM Semeru Runtimes. IBM Semeru Runtimes provides free production-ready open source binaries that are built with the OpenJDK class libraries and the Eclipse OpenJ9 JVM, including Semeru Cloud Compiler (which incorporates JITServer). Semeru Cloud Compiler enables reduced peak memory usage by approximately 50% and faster acceleration to reach peak throughput, which results in reduced costs and better performance.

Bonus reason: Easy and flexible deployment to your cloud of choice

To enable flexibility and portability of application deployments, Liberty can be deployed to all leading clouds (whether that be private, public, or hybrid), including Azure, Red Hat OpenShift, AWS, and IBM Cloud.

As well as this variety of deployment locations available, Liberty also enables a range of options for deployment approaches, including the use of virtual machines, lightweight containers, Kubernetes deployments through the Open Liberty Operator, cloud-native buildpacks, and platform-specific approaches like Red Hat OpenShift’s Source-to-Image (S2I) toolkit.

Summary and next steps

The move to cloud and cloud-native delivery leads to new challenges for development and operations teams. These challenges include:

• The need for cloud-native APIs
• The need for runtimes with high throughput and low resource usage
• The need for first-class container and Kubernetes integration
• The need to be able to remain secure by upgrading simply and frequently

This article has highlighted six capabilities of Liberty that address these new challenges, showcasing how Liberty is an ideal choice for both migrated enterprise Java workloads and new cloud-native workloads. If you’d like to try Liberty for yourself, check out our hands-on guide, “Getting started with Open Liberty.”