Boost The Performance and Security of Your Spring Boot App with Alpaquita Containers

Catherine Edelveis
Catherine Edelveis

Transcript

Imagine running your Spring Boot app in a container that boosts both performance and security.

With Alpaquita Containers you don't have to compromise. They are small, fast and designed with security in mind. Just update the ‘FROM’ line in your Dockerfile, and you are ready to go.

Hi, I'm Cat, developer advocate at BellSoft. Let's talk about why you should switch to Alpaquita Containers. And here are five reasons for doing that.

Reason 1. Performance optimizations

By switching to Alpaquita Containers, your Spring Boot app can use up to 30% less RAM and disk space. How? Alpaquita Containers are based on Liberica JDK Lite, a flavor of Liberica JDK.

It was built specifically for cloud deployments. And by the way, Liberica JDK is recommended by Spring. Alpaquita Containers also come with a lightweight Linux distribution called Alpaquita.

This is the only Linux optimized for Java. And it supports both musl and glibc libraries.

Reason 2. Security

Alpaquita Containers were built with security in mind. The Alpaquita Linux security is hardened

with Secure Boot support, minimal extra packages in userspace, special userspace compilation options and other security features. Additionally, Alpaquita Containers are continuously updated to patch known vulnerabilities.It means that every time you rebuild your container image,

you can be sure that Alpaquita Containers are based on the latest JDK and Linux version with fixes for known CVEs. And the best part? You don't have to manually update the container.

Simply use the ‘latest’ tag, and the newest, most secure image will be pulled automatically for you.

Reason 3. 100% Open-source

Alpaquita Containers are 100% open source and free for commercial and personal use.

BellSoft also provides technical support with SLAs for enterprises with strict security requirements.

Reason 4. Available as buildpacks

Alpaquita Containers are available as buildpacks. If you prefer buildpacks to Dockerfiles,

Alpaquita's buildpacks help you build smaller images without additional configuration.

It's easy, just specify the builder in your Maven or Gradle plugin, and build small container images with just one line of code.

Reason 5. Further performance optimization

If you are looking to reduce startup and warm-up times, cut cloud costs and improve scalability, Alpaquita Containers support tools for that, such as AppCDS, GraaLVM native image, and the Coordinated Restore at Checkpoint (CRaC) project. I have written dedicated blog posts about these solutions on Bellsoft's blog. Check it out and subscribe for tips on performance, security and all things Java. And that was quick overview of why you should switch to Alpaquita Containers when containerizing Spring Boot applications. Migration is super easy. Just update the ‘FROM’ line in your Dockerfile, and that's it. Try Alpaquita Containers today. The links are in the description box below. That was me, Cat from BellSoft. We provide the most complete Java experience. See you next time!

Summary

Alpaquita Containers offer a secure, high-performance solution for running Spring Boot applications in the cloud. These lightweight containers, built on Liberica JDK Lite and Alpaquita Linux, optimize memory and disk usage, reducing resource consumption by up to 30%. Designed with security in mind, they provide automatic updates to patch vulnerabilities and ensure the latest fixes. Fully open-source and available as buildpacks, Alpaquita Containers support advanced tools like AppCDS and GraalVM for further performance enhancements, making them easy to adopt by simply updating the ‘FROM’ line in your Dockerfile.

About Catherine

Java developer passionate about Spring Boot. Writer. Developer Advocate at BellSoft

Social Media

Tags

BellSoft productsDevelopmentDeployment
Videos
card image
Apr 2, 2026
Java Memory Options You Need in Production

JVM memory tuning can be tricky. Teams increase -Xmx and assume the problem is solved. Then the app still hits OOM. Because maximum heap size is not the only thing that affects memory footprint. The JVM uses RAM for much more than heap: metaspace, thread stacks, JIT/code cache, direct buffers, and native allocations. That’s why your process can run out of memory while heap still looks “fine”. In this video, we break down how JVM memory actually works and how to control it with a minimal, production-safe set of flags. We cover heap sizing (-Xms, -Xmx), dynamic resizing, direct memory (-XX:MaxDirectMemorySize), and total RAM limits (-XX:MaxRAMPercentage) — especially in containerized environments like Docker and Kubernetes. We also explain GC choices such as G1, ZGC, and Shenandoah, when defaults are enough, and why GC logging (-Xlog:gc*) is mandatory before tuning. Finally, we show how to diagnose failures with heap dumps and OOM hooks. This is not about adding more flags. It’s about understanding what actually consumes memory — and making decisions you can justify in production.

Watch Now
Videos
card image
Mar 26, 2026
Java Developer Roadmap 2026: From Basics to Production

Most Java roadmaps teach tools. This one teaches order — the only thing that actually gets you to production. You don’t need to learn everything. You need to learn the right things, in the right sequence. In this video, we break down a practical Java developer roadmap for 2026 — from syntax and OOP to Spring, databases, testing, and deployment. Structured into 8 levels, it shows how real engineers grow from fundamentals to production-ready systems. We cover what to learn and what to ignore: core Java, collections, streams, build tools, Git, SQL and JDBC before Hibernate, the Spring ecosystem, testing with JUnit, and deployment with Docker and CI/CD. You’ll also understand why most developers get stuck — jumping into frameworks too early, skipping SQL, or treating tools as knowledge. This roadmap gives you a clear path into real-world Java development — with priorities, trade-offs, and production context.

Watch Now

Further watching

Videos
card image
Apr 30, 2026
Java Flight Recorder Tutorial: How to Profile Java Applications

High CPU, GC spikes, or slow startup are common production issues, but logs and metrics don’t always reveal what the JVM is actually doing. Java Flight Recorder (JFR) provides a precise, low-overhead view of JVM behavior, safe for use even in production environments. In this video, you’ll learn how to use JFR to identify real bottlenecks such as CPU hotspots, memory allocation pressure, thread contention, and I/O stalls. We walk through the full workflow, including starting recordings with JVM flags, controlling them via jcmd, running JFR inside Docker containers, and attaching to live systems using ephemeral containers. Then we analyze a real Spring Boot recording in JDK Mission Control, breaking down GC behavior, allocation patterns, thread states, and method-level hotspots. If you want to move from symptoms to root cause with more confidence, this approach will help. Full article with commands and examples: [https://bell-sw.com/blog/how-to-profile-java-applications-with-jfr-beginner-s-guide/](https://bell-sw.com/blog/how-to-profile-java-applications-with-jfr-beginner-s-guide/)

Watch Now
Videos
card image
Apr 22, 2026
Dynamic SQL Queries with Spring Data JPA in 6 Minutes

If your repository layer has multiple queries for different filter combinations, your data access logic is already getting harder to maintain. In this video, we implement dynamic SQL queries in Spring Data JPA using Specifications — a composable approach that helps avoid query duplication and keeps your filtering logic clean. We build a flexible filtering system with optional parameters (category, language, format, price) and show how Specification.unrestricted() skips empty filters, while Specification.allOf(...) combines them into a single query. We also address a common issue: string-based field access. It’s fragile and can break at runtime when your model changes. Using the JPA Static Metamodel, we move to compile-time safety. The result is a cleaner, more maintainable way to implement dynamic filtering in Spring-based applications.

Watch Now
Videos
card image
Apr 8, 2026
Best Oracle Java Alternatives in 2026 Comparison of OpenJDK Distributions

A comparison of major OpenJDK distributions (Temurin, Liberica, Zulu, Corretto, Semeru, etc.), covering who maintains them, how updates are delivered, and what lifecycle guarantees they provide. We also explain why upstream OpenJDK isn’t production-ready and how your vendor choice impacts real-world systems. Useful for Spring Boot, containers, and Kubernetes to avoid hidden risks and choose the right runtime.

Watch Now