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
Jan 13, 2026
Hibernate: Ditch or Double Down? When ORM Isn't Enough

Every Java team debates Hibernate at some point: productivity champion or performance liability? Both are right. This video shows you when to rely on Hibernate's ORM magic and when to drop down to SQL. We walk through production scenarios: domain models with many-to-many relations where Hibernate excels, analytical reports with window functions where JDBC dominates, and hybrid architectures that use both in the same Spring Boot codebase. You'll see real code examples: the N+1 query trap that kills performance, complex window functions and anti-joins that Hibernate can't handle, equals/hashCode pitfalls with lazy loading, and practical two-level caching strategies. We also explore how Hibernate works under the hood—translating HQL to database-specific SQL dialects, managing sessions and transactions through JDBC, implementing JPA specifications. The strategic insight: modern applications need both ORM convenience for transactional business logic and SQL precision for data-intensive analytics. Use Hibernate for CRUD and relationship management. Use SQL where ORM abstractions leak or performance demands direct control.

Watch Now
Videos
card image
Dec 30, 2025
Java in 2025: LTS Release, AI on JVM, Framework Modernization

Java in 2025 isn't about headline features, it's about how production systems changed under the hood. While release notes focus on individual JEPs, the real story is how the platform, frameworks, and tooling evolved to improve stability, performance, and long-term maintainability. In this video, we look at Java from a production perspective. What does Java 25 LTS mean for teams planning to upgrade? How are memory efficiency, startup time, and observability getting better? Why do changes like Scoped Values and AOT optimizations matter beyond benchmarks? We also cover the broader ecosystem: Spring Boot 4 and Framework 7, AI on the JVM with Spring AI and LangChain4j, Kotlin's growing role in backend systems, and tooling updates that make upgrades easier. Finally, we touch on container hardening and why runtime and supply-chain decisions matter just as much as language features.

Watch Now

Further watching

Videos
card image
Jan 29, 2026
JDBC Connection Pools in Microservices. Why They Break Down (and What to Do Instead)

In this livestream, Catherine is joined by Rogerio Robetti, the founder of Open J Proxy, to discuss why traditional JDBC connection pools break down when teams migrate to microservices, and what is a more efficient and reliable approach to organizing database access with microservice architecture.

Watch Now
Videos
card image
Jan 27, 2026
Sizing JDBC Connection Pools for Real Production Load

Many production outages start with connection pool exhaustion. Your app waits seconds for connections while queries take milliseconds; yet, most teams run default settings that collapse under load. This video shows how to configure connection pools that survive real production traffic: sizing based on database limits and thread counts, setting timeouts that prevent cascading failures, and implementing an open source database proxy Open J Proxy for centralized connection management with virtual connection handles, client-side load balancing, and slow query segregation. For senior Java developers, DevOps engineers, and architects who need database performance that holds under pressure.

Watch Now
Videos
card image
Jan 20, 2026
JDBC vs ORM vs jOOQ: Choose the Right Java Database Tool

Still unsure what is the difference between JPA, Hibernate, JDBC, or jOOQ and when to use which? This video clarifies the entire Java database access stack with real, production-oriented examples. We start at the foundation, which is JDBC, a low-level API every other tool eventually relies on for database communication. Then, we go through the ORM concept, JPA as a specification of ORM, Hibernate as the implementation and extension of JPA, and Blaze Persistence as a powerful upgrade to JPA Criteria API. From there, we take a different path with jOOQ: a database-first, SQL-centric approach that provides type-safe queries and catches many SQL errors at compile time instead of runtime. You’ll see when raw JDBC makes sense for small, focused services, when Hibernate fits CRUD-heavy domains, and when jOOQ excels at complex reporting and analytics. We discuss real performance pitfalls such as N+1 queries and lazy loading, and show practical combination strategies like “JPA for CRUD, jOOQ for reports.” The goal is to equip you with clarity so that you can make informed architectural decisions based on domain complexity, query patterns, and long-term maintainability.

Watch Now