Forem: ...

Case Study: Building a Scalable CRUD Application with Quarkus

... — Sun, 23 Feb 2025 09:33:49 +0000

1. Overview

This case study explores the development of a Person Management System using Quarkus, a Kubernetes-native Java framework optimized for cloud environments. The application demonstrates CRUD operations (Create, Read, Update, Delete) with a MySQL database, leveraging Quarkus' efficiency, developer-friendly tooling, and native compilation capabilities.

2. Project Objectives

Build a performant REST API for managing Person entities.
Utilize Quarkus' live coding features for rapid development.
Demonstrate integration with Hibernate ORM/Panache for simplified database interactions.
Package the application as a lightweight JAR and native executable.

3. Technical Architecture

Architecture Diagram

Key Components:

MySQL Database: Stores Person records.
Hibernate ORM/Panache: Manages persistence layer with active record pattern.
RESTEasy: Implements JAX-RS endpoints.
SmallRye OpenAPI: Auto-generates OpenAPI documentation.

4. Implementation Highlights

4.1 Data Model

@Entity  
@Table(name = "Person")  
public class Person {  
    @Id  
    @GeneratedValue(strategy = GenerationType.IDENTITY)  
    private Long id;  
    private String name;  
    // Getters/Setters  
}

Uses Hibernate annotations for ORM mapping with MySQL auto-increment IDs.

4.2 Repository Layer

@ApplicationScoped  
public class PersonRepository implements PanacheRepository<Person> {  
    Person findByName(String name) {  
        return find("name", name).firstResult();  
    }  
}

Extends PanacheRepository for out-of-the-box CRUD methods while adding custom queries.

4.3 REST Service

@Path("/persons")  
@ApplicationScoped  
public class PersonService {  
    @Inject PersonRepository personRepository;  

    @GET  
    public Response getAllPersons() {  
        return Response.ok(personRepository.listAll()).build();  
    }  

    @POST  
    @Transactional  
    public Response savePerson(Person person) {  
        personRepository.persist(person);  
        return Response.ok(person.getName() + " saved").build();  
    }  
    // PUT, DELETE methods omitted for brevity  
}

Key Features:

Transaction management via @Transactional
JAX-RS annotations for endpoint definition
JSON serialization/deserialization handled automatically

4.4 Database Configuration

application.properties:

quarkus.datasource.db-kind=mysql  
quarkus.datasource.jdbc.url=jdbc:mysql://localhost:3306/mydb  
quarkus.hibernate-orm.database.generation=update

Configures MySQL connection and automatic schema updates.

5. Development Workflow

5.1 Live Coding

./mvnw clean compile quarkus:dev

Code changes reflected instantly without restart
Access Dev UI at http://localhost:8080/q/dev

5.2 Testing Endpoints

# Create Person  
curl -X POST -H "Content-Type: application/json" \  
  -d '{"name":"John Doe"}' http://localhost:8080/persons  

# Retrieve All  
curl http://localhost:8080/persons

5.3 Packaging

# Standard JAR  
./mvnw package  

# Native Executable (GraalVM)  
./mvnw package -Dnative

Result:

Uber-JAR size: ~15MB
Native executable startup time: ~0.01s

6. Challenges & Solutions

Challenge	Quarkus Solution
Database schema management	`quarkus.hibernate-orm.database.generation=update`
Boilerplate CRUD code	`PanacheRepository` base class
Native compilation issues	Containerized builds via `-Dquarkus.native.container-build=true`

7. Results & Metrics

API Response Times (10k requests):
- JVM Mode: Avg 12ms
- Native Mode: Avg 8ms
Memory Usage:
- JVM Heap: ~120MB
- Native: ~45MB RSS

8. Conclusion

This project demonstrates Quarkus' strengths in building modern Java applications:

Developer Productivity: Live reload, Dev UI, and simplified Hibernate configuration.
Performance: Subsecond startup times and low memory footprint in native mode.
Cloud Readiness: Container-friendly packaging and native Kubernetes integration.

Future Enhancements:

Add frontend with Quarkus Qute templating
Implement reactive endpoints with Mutiny

Quarkus Documentation: quarkus.io/guides

This case study demonstrates how Quarkus enables developers to build cloud-native applications that combine traditional Java strengths with modern runtime efficiencies.

Optimize Docker Performance: Strategies for Enhancing Image Creation and Runtime Container Management

... — Sun, 26 May 2024 05:23:11 +0000

Docker has become a crucial tool for creating, deploying, and managing containerized applications. However, as applications grow in complexity, so do their Docker images and runtime environments. Efficiently managing these Docker images and containers is crucial for maintaining performance, reducing disk usage, and ensuring smooth operations. Let us look at some strategies for optimizing Docker image creation and runtime container management. Additionally, let us cover best practices. By following these strategies and techniques, you can achieve a more efficient and manageable Docker setup, ultimately leading to improved application performance and resource utilization.

To optimize Docker image creation, you can use tools and techniques such as Docker Slim, Zstandard (Zstd) compression, and Docker Squash. These approaches help reduce image size and improve performance.

1. Choose a Smaller Base Image

Use lightweight base images such as alpine whenever possible.

2. Docker Slim

Docker Slim reduces the size of Docker images by stripping away unnecessary files and dependencies, leading to smaller, more secure images. Click here to know more about DockerSlim
Installation:
curl -sL https://raw.githubusercontent.com/slimtoolkit/slim/master/scripts/install-slim.sh | sudo -E bash -

Usage:
slim build --tag=myimage.slim myimage:latest

3. Zstandard (Zstd) Compression

Zstd offers high compression ratios and fast decompression, making it suitable for compressing Docker images.
Usage:

Compress Docker Image
docker save myimage:latest | zstd -o myimage.tar.zst
Load Compressed Docker Image
zstd -d myimage.tar.zst -o myimage.tar docker load < myimage.tar

If you encounter difficulties with Zstd compression for your image compression, consider using pigz instead.

4. Docker Squash

Docker Squash reduces the number of layers in a Docker image, which can simplify the image structure and reduce its size.
Installation:
pip install docker-squash

Usage:
docker-squash -t myimage:squashed myimage:latest

For optimizing docker containers, combine strategies for managing container runtime disk usage, cleaning up unused Docker objects, and optimizing image creation and performance.

1. Persistent Storage Volumes

Bind Mounts:
Bind mounts allow you to mount a directory from the host machine into the container. This is useful for persistent data that needs to exist outside the container's lifecycle.
docker run -v /host/path:/container/path myimage

Named Volumes:
Named volumes are managed by Docker and can be used to persist data. These volumes are not tied to any specific directory on the host machine.
docker volume create myvolume docker run -v myvolume:/container/path myimage

2. Clean Up After Operations

Log Rotation:
Log rotation helps manage log files by limiting their size and the number of log files retained, preventing logs from consuming excessive disk space.
docker run --log-opt max-size=10m --log-opt max-file=3 myimage

Temporary File Cleanup:
Remove temporary files generated during container operations to prevent them from consuming disk space. Use a cleanup script or application logic to delete temporary files after use.
# In a Dockerfile RUN apt-get update && apt-get install -y mypackage && rm -rf /var/lib/apt/lists/*

Regular Cleanup with Cron:
Schedule regular cleanup tasks to remove unnecessary files and manage disk usage effectively. Use cron jobs or similar tools to automate periodic cleanup.
# In a containerized application crontab -l | { cat; echo "0 * * * * rm -rf /path/to/temp/files/*"; } | crontab -

3. Optimize Application Behavior

In-Memory Processing:
Use in-memory processing to minimize disk I/O operations, which can help reduce disk usage and improve performance. Process data in memory instead of writing to disk when feasible.
# Example in Python data = process_data_in_memory()

Efficient Data Handling:
Optimize how your application reads and writes data to avoid redundant operations and reduce disk usage. Ensure efficient data handling by writing data only when necessary.
with open('file.txt', 'w') as file: file.write(data)

Use Temporary Storage:
For temporary data that doesn't need to be persisted, use temporary filesystems like tmpfs to store data in memory. Mount a tmpfs volume for temporary data storage.
docker run --mount type=tmpfs,destination=/path/to/tmpfs myimage

4. Prune Unused Docker Objects

To manage disk space and maintain a clean Docker environment, you can prune unused Docker objects such as images, containers, volumes, and networks. Docker provides commands to prune each of these object types, helping you free up disk space and keep your Docker environment tidy.
Prune Images:
docker image prune -a -f

Prune Containers:
docker container prune -f

Prune Volumes:
docker volume prune -f

Prune Networks:
docker network prune -f

Prune All Unused Objects:
docker system prune -a -f --volumes

5. Automate Pruning with a Script

Pruning Script:

#!/bin/bash

# Prune unused images
docker image prune -a -f

# Prune stopped containers
docker container prune -f

# Prune unused volumes
docker volume prune -f

# Prune unused networks
docker network prune -f

# Optionally, prune all unused objects
# docker system prune -a -f --volumes

Scheduling with Cron:
crontab -e

Add the following line to run the script daily at midnight:
0 0 * * * /path/to/your/script.sh

Example Dockerfile Incorporating Best Practices

# Dockerfile
FROM ubuntu:20.04

# Install necessary packages
RUN apt-get update && apt-get install -y python3 && rm -rf /var/lib/apt/lists/*

# Copy application code
COPY . /app
WORKDIR /app

# Set up a volume for persistent data
VOLUME /app/data

# Use tmpfs for temporary files
RUN mkdir -p /tmp/data
VOLUME /tmp/data

# Cleanup script for temporary files
RUN echo "0 * * * * root rm -rf /tmp/data/*" >> /etc/crontab

# Run the application
CMD ["python3", "app.py"]

**Docker Run Command**
docker run -d --name myapp \
  -v appdata:/app/data \
  --mount type=tmpfs,destination=/tmp/data \
  --log-opt max-size=10m --log-opt max-file=3 \
  myimage

Conclusion

By following these strategies and best practices, you can optimize your Docker environment for better performance, efficient disk usage, and improved application behavior. Regular maintenance through pruning, coupled with optimized image creation and runtime management, will lead to a more efficient Docker setup.

References

"Create Single Image Layers with Docker Squash"
Geralexgr, Medium

"Reduce the Size of Container Images with Docker Slim"
Karan Singh, Red Hat Developer

"Reducing Docker Image Size from 1.4GB to 15MB: Angular App"
Spei, Medium

"Docker Alpine Images: Explain"
Reddit Discussion

"Push image faster by using pigz to compress"
Moby GitHub Repository Issue

"How To Remove Docker Images, Containers, and Volumes"
Melissa Anderson and Anish Singh Walia, DigitalOcean Community

"Docker Log Rotation"
Favour Daniel,Signoz Blog

"Add cron to the docker image for recurring transactions #2170"
firefly-iii GitHub Repository Issue

"Cron Job to Delete Files in /tmp Directory"
HPE Community