Add Docker best practices system prompt for Java 25

- Created comprehensive XML system prompt (130-java-docker-best-practices.xml)
- Covers Docker best practices specific to Java 25 applications
- Includes multi-stage builds, JVM optimization, security, and monitoring
- Generated corresponding markdown file
- Updated SystemPromptsInventory to include new prompt
- Updated all project Java versions to Java 25
- Updated Dockerfiles to use Eclipse Temurin Java 25 images

Author: cursoragent

130-java-docker-best-practices.md

@@ -0,0 +1,271 @@
+Docker Best Practices for Java 25 Applications
+    
+        Comprehensive guidelines for containerizing Java 25 applications using Docker, focusing on performance optimization, security enhancements, and efficient resource utilization.
+    
+    
+    
+        
+            Use Appropriate Base Images
+            
+                Select the most suitable base image for your Java 25 application, considering size, security, and compatibility requirements.
+            
+            
+                Use `eclipse-temurin:25-jre-alpine` for minimal production images
+                Use `eclipse-temurin:25-jdk-alpine` only when JDK tools are required at runtime
+                Prefer Alpine Linux variants for smaller image sizes
+                Use specific version tags instead of `latest` for reproducible builds
+            
+            
+### Example : 
+
+Title: 
+Description: 
+
+        
+
+        
+            Implement Multi-Stage Builds
+            
+                Separate the build environment from the runtime environment to create lean, secure final images by excluding unnecessary build tools and dependencies.
+            
+            
+                Use a build stage with JDK for compilation
+                Use a runtime stage with JRE for execution
+                Copy only necessary artifacts between stages
+                Minimize the number of layers in the final image
+            
+            
+### Example : 
+
+Title: 
+Description: 
+
+        
+
+        
+            Optimize JVM Configuration for Containers
+            
+                Configure the JVM to work efficiently within container resource constraints, taking advantage of Java 25's container awareness features.
+            
+            
+                Use `-XX:+UseContainerSupport` to enable container awareness (enabled by default in Java 25)
+                Set appropriate heap size using `-Xms` and `-Xmx` based on container memory limits
+                Use `-XX:+UseG1GC` for better performance in containerized environments
+                Enable JVM ergonomics with `-XX:+UnlockExperimentalVMOptions` for Java 25 features
+                Use `-XX:+ExitOnOutOfMemoryError` to ensure container restart on OOM
+            
+            
+### Example : 
+
+Title: 
+Description: 
+
+        
+
+        
+            Implement Security Best Practices
+            
+                Enhance container security by following the principle of least privilege and implementing defense-in-depth strategies.
+            
+            
+                Create and use a non-root user for running the application
+                Use read-only root filesystem when possible
+                Minimize the attack surface by removing unnecessary packages
+                Scan images for vulnerabilities regularly
+                Use secrets management for sensitive data
+            
+            
+### Example : 
+
+Title: 
+Description: 
+
+        
+
+        
+            Optimize Image Layers and Caching
+            
+                Structure Dockerfile commands to maximize Docker layer caching and minimize image size.
+            
+            
+                Order commands from least to most frequently changing
+                Copy dependency files before source code to leverage cache
+                Combine related RUN commands to reduce layers
+                Use `.dockerignore` to exclude unnecessary files
+                Clean up package caches and temporary files in the same layer
+            
+            
+### Example : 
+
+Title: 
+Description: 
+
+        
+
+        
+            Configure Health Checks and Monitoring
+            
+                Implement comprehensive health checking and monitoring to ensure application reliability and observability.
+            
+            
+                Define Docker health checks for container orchestration
+                Implement application health endpoints
+                Configure proper logging to stdout/stderr
+                Use structured logging formats (JSON) for better parsing
+                Include JVM metrics and garbage collection monitoring
+            
+            
+### Example : 
+
+Title: 
+Description: 
+
+        
+
+        
+            Manage Configuration and Secrets
+            
+                Externalize configuration and handle secrets securely to support different deployment environments.
+            
+            
+                Use environment variables for configuration
+                Support configuration files mounted as volumes
+                Never embed secrets in Docker images
+                Use Docker secrets or external secret management
+                Implement configuration validation at startup
+            
+            
+### Example : 
+
+Title: 
+Description: 
+
+        
+
+        
+            Optimize for Different Deployment Scenarios
+            
+                Create flexible Docker configurations that work well across development, testing, and production environments.
+            
+            
+                Use build arguments for environment-specific customization
+                Support both standalone and orchestrated deployments
+                Implement graceful shutdown handling
+                Configure appropriate resource limits and requests
+                Use init systems for proper signal handling in containers
+            
+            
+### Example : 
+
+Title: 
+Description: 
+
+        
+
+        
+            Leverage Java 25 Specific Features
+            
+                Take advantage of Java 25's latest features and improvements for better container performance and developer experience.
+            
+            
+                Use Virtual Threads for improved scalability in I/O-intensive applications
+                Leverage Pattern Matching and Switch Expressions for cleaner code
+                Use Record Classes for data transfer objects
+                Take advantage of improved garbage collection algorithms
+                Use Text Blocks for embedded configuration or SQL
+            
+            
+### Example : 
+
+Title: 
+Description: 
+
+        
+
+        
+            Implement Efficient Development Workflow
+            
+                Create Docker configurations that support efficient development cycles and debugging capabilities.
+            
+            
+                Use Docker Compose for local development environments
+                Implement hot-reload capabilities for development
+                Support remote debugging configurations
+                Create separate profiles for development and production
+                Use volume mounts for rapid iteration during development
+            
+            
+### Example : 
+
+Title: 
+Description: 
+
+        
+    
+
+    
+        
+            Using Root User in Production
+            Running applications as root user increases security risks
+            
+### Example : 
+
+Title: 
+Description: 
+
+        
+        
+        
+            Installing Unnecessary Packages
+            Including development tools and unnecessary packages in production images
+            
+### Example : 
+
+Title: 
+Description: 
+
+        
+        
+        
+            Hardcoding Configuration
+            Embedding environment-specific configuration in Docker images
+            
+### Example : 
+
+Title: 
+Description: 
+
+        
+        
+        
+            Ignoring JVM Container Settings
+            Not configuring JVM for container resource limits
+            
+### Example : 
+
+Title: 
+Description: 
+
+        
+        
+        
+            Using Latest Tags in Production
+            Using unstable or latest tags for base images in production
+            
+### Example : 
+
+Title: 
+Description: 
+
+        
+    
+
+    
+        Use multi-stage builds with appropriate base images
+        Configure JVM for container environments
+        Implement security best practices with non-root users
+        Optimize Docker layers and caching strategies
+        Configure comprehensive health checks and monitoring
+        Externalize configuration and manage secrets properly
+        Leverage Java 25 specific features and improvements
+        Support efficient development workflows

system-prompts-generator/src/test/java/info/jab/pml/SystemPromptsInventory.java

@@ -21,6 +21,7 @@ public static final Stream<String> baseNames() {
             "126-java-logging",
             "127-java-exception-handling",
             "128-java-generics",
+            "130-java-docker-best-practices",
             "131-java-unit-testing",
             "141-java-refactoring-with-modern-features",
             "142-java-functional-programming",