The Right Base Container Images: A Solid Foundation for Cloud-Native Java Apps

December 7, 2023December 6, 2023 Alex Belokrylov app modernization, application development, containers, Java, OpenJDK

by Alex Belokrylov

Cloud-based technologies have moved the IT industry into a new environment with new demands for development.

Initially, code and software instruments were not designed to operate in the cloud. With evolving digital transformation, apps and software tools that were originally built for on-premises server environments had to be adapted to the virtual cloud space to keep up with rapidly changing market demands.

Adapting software apps to cloud-native environments is especially relevant for the OpenJDK community, as Java applications were monolithic for decades. Now, Java is moving to the cloud via microservices and containers. To make your Java-based app truly cloud-native, you need to exercise care when selecting software components for its new microservices architecture. One such component is a container, and this small but magnificent tool has a major impact on modern Java development.

How Containers Became Mainstream

Cloud technologies made applications faster and more accessible for users, but they simultaneously increased applications’ complexity. The hype around cloud and cloud-native technologies continues, driven by strategic and financial considerations, including, most importantly, increased cloud budgets and security concerns.

Container technology, which was relatively new a few years back, is everywhere today, and it will continue to advance as the market dictates. Adapting the container appropriate for your particular use case can be key to successful development with competitive operational advantages. Containers are not only essential for infrastructure but also are excellent tools to reduce the cost of cloud-based applications.

A few years ago, we began looking into containers as one of the components for converting Java to a cloud-native architecture. Currently, almost every OpenJDK vendor has one in their product range, and containerized applications are the most common in the cloud architecture. According to the New Relic State of the Java Ecosystem 2023 report, containerized applications have become mainstream, with up to 70% of Java applications being containerized.

Containers have achieved mainstream adoption for a number of reasons. Container technology allows for increased speed, scaling, diminished energy use and lower cost consumption. These are precisely the goals FinOps and DevOps were adopted to achieve.

Containers brought with them the freedom of isolation and ease of transfer to a new environment. Previously, different processes were required to install the environment, runtime, app server and self-hosted application. With containers, the process is unified. You build a pyramid by adding container layers and the container management system determines the deployment process. This modern approach allows you to easily move your Java application between different environments such as testing and production or public and hybrid clouds.

This functionality of containers facilitates many processes in development and saves money. You can quickly move the app from the pilot testing environment to production, for example, without wasting additional time and resources.

The power of containers lies in their portability, differentiating containers from traditional software components, which could also be transferred to a new environment but with complications.

Containers are often compared to virtual machines when organizations choose the technology on which to run an application. But it’s not an exact comparison. Virtual machines virtualize the underlying software, and containers virtualize the operating system, which means each container can only hold one application and its libraries. Containers are similar to virtual machines in their function but are more lightweight. Therefore, depending on your goal, a virtual machine or container could be appropriate for your architecture. It should be noted that container choices are vast, including very small distroless containers for a limited number of operations and small containers that are still fully operational.

Advantages of Containers

Containers are a key part of the cloud-native landscape. They can help modernize Java applications for the cloud and leverage cloud elasticity and automation in full.

With containerization, you achieve multiple benefits:

• Cost reduction

• Scalability — replacing VMs with containers eliminates the need to scale VMs

• Instant replication

• Full portability

• OS independence

• Faster deployment and “ready to compute” status

Additional Software Components

To increase the positive effects of microservices architecture on your Java application, it is important to:

Choose a container that matches your goals. For example, distroless containers are useful in some cases and, in other cases, richer images fit better. The same is true for JRE and JDK images with Java. Microcontainers with strong security, small size and great tech support would be a much better option to satisfy all business needs.
Check if the container is accompanied by the runtime adapted to the cloud. Some OpenJDK vendors provide lightweight runtime options.
Check if there are any further technical advancements from the same vendor, for example, if these containers are paired with CRaC technology.

The more advanced supporting tools a container has, the greater cost and resource consumption reduction you’ll see. In some cases, migration of an app to a container and runtime can bring up to 30-40 % cost reduction. As such, it is always worth investing your time and resources into research and high-level expert support. The results will be especially evident when you scale your business.