Dynamic Configuration Updates: Implementing ConfigMap Reloading in Java Applications

In Kubernetes, ConfigMaps are essential for externalizing configuration from your Java applications. But what happens when you need to update configuration without restarting your application? ConfigMap reloading enables dynamic configuration updates while your application continues running. Let's explore various strategies to implement ConfigMap reloading in Java applications.

Understanding ConfigMap Updates in Kubernetes

When a ConfigMap is updated in Kubernetes:

The update is eventually propagated to mounted volumes
Environment variables from ConfigMaps are NOT updated - they're injected only at pod startup
Volume-mounted ConfigMap files ARE updated - typically within 1-2 minutes

Strategy 1: File Watching with Spring Boot

Basic Spring Boot Configuration

// src/main/java/com/company/config/ReloadableConfig.java @Configuration @ConfigurationProperties(prefix = "app") @Data public class AppConfig { private String featureFlag; private int timeout; private String apiUrl; private List<String> allowedHosts; }

File Watcher Implementation

// src/main/java/com/company/config/ConfigMapWatcher.java @Component @Slf4j public class ConfigMapWatcher { private final AppConfig appConfig; private final ObjectMapper objectMapper; private WatchService watchService; private Path configPath; public ConfigMapWatcher(AppConfig appConfig, @Value("${config.path:/etc/config}") String configPath) { this.appConfig = appConfig; this.objectMapper = new ObjectMapper(); this.configPath = Paths.get(configPath); initializeWatcher(); } @PostConstruct public void initializeWatcher() { try { this.watchService = FileSystems.getDefault().newWatchService(); configPath.register(watchService, StandardWatchEventKinds.ENTRY_MODIFY); Thread watchThread = new Thread(this::watchForChanges); watchThread.setDaemon(true); watchThread.setName("config-watcher"); watchThread.start(); log.info("ConfigMap watcher initialized for path: {}", configPath); } catch (IOException e) { log.error("Failed to initialize config watcher", e); } } private void watchForChanges() { while (!Thread.currentThread().isInterrupted()) { try { WatchKey key = watchService.take(); for (WatchEvent<?> event : key.pollEvents()) { WatchEvent.Kind<?> kind = event.kind(); if (kind == StandardWatchEventKinds.ENTRY_MODIFY) { Path changedFile = (Path) event.context(); if (changedFile.toString().equals("application.properties") || changedFile.toString().equals("app-config.json")) { log.info("Config file changed: {}", changedFile); reloadConfiguration(); } } } boolean valid = key.reset(); if (!valid) { log.error("Watch key no longer valid"); break; } } catch (InterruptedException e) { Thread.currentThread().interrupt(); log.info("Config watcher interrupted"); } catch (Exception e) { log.error("Error in config watcher", e); } } } private void reloadConfiguration() { try { // Reload from mounted ConfigMap volume Properties properties = new Properties(); Path propertiesFile = configPath.resolve("application.properties"); if (Files.exists(propertiesFile)) { try (InputStream input = Files.newInputStream(propertiesFile)) { properties.load(input); } // Update configuration beans updateAppConfig(properties); log.info("Configuration reloaded successfully"); } } catch (Exception e) { log.error("Failed to reload configuration", e); } } private void updateAppConfig(Properties properties) { // Update the configuration object if (properties.containsKey("app.feature-flag")) { appConfig.setFeatureFlag(properties.getProperty("app.feature-flag")); } if (properties.containsKey("app.timeout")) { appConfig.setTimeout(Integer.parseInt(properties.getProperty("app.timeout"))); } if (properties.containsKey("app.api-url")) { appConfig.setApiUrl(properties.getProperty("app.api-url")); } log.info("Updated AppConfig - featureFlag: {}, timeout: {}", appConfig.getFeatureFlag(), appConfig.getTimeout()); } }

Strategy 2: Spring Cloud Kubernetes Reload

Dependencies Setup

<!-- pom.xml --> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-kubernetes-fabric8-all</artifactId> <version>2.1.7</version> </dependency>

Configuration

# application.yml spring: cloud: kubernetes: reload: enabled: true mode: event strategy: refresh config: sources: - name: ${spring.application.name} namespace: default

Application Setup

// src/main/java/com/company/Application.java @SpringBootApplication @Configuration @RefreshScope @EnableScheduling public class Application { public static void main(String[] args) { SpringApplication.run(Application.class, args); } @Bean @RefreshScope public RestTemplate restTemplate() { return new RestTemplate(); } } // Config class that will be refreshed @Component @RefreshScope @Data public class DynamicConfig { @Value("${app.feature.enabled:false}") private boolean featureEnabled; @Value("${app.cache.timeout:300}") private int cacheTimeout; @Value("${app.api.endpoint:http://localhost:8080}") private String apiEndpoint; }

Strategy 3: Kubernetes API Watch Implementation

Direct Kubernetes API Integration

// src/main/java/com/company/k8s/KubernetesConfigWatcher.java @Component @Slf4j public class KubernetesConfigWatcher { private final KubernetesClient kubernetesClient; private final ApplicationEventPublisher eventPublisher; private final String namespace; private final String configMapName; public KubernetesConfigWatcher(KubernetesClient kubernetesClient, ApplicationEventPublisher eventPublisher, @Value("${app.configmap.name:app-config}") String configMapName) { this.kubernetesClient = kubernetesClient; this.eventPublisher = eventPublisher; this.configMapName = configMapName; this.namespace = getCurrentNamespace(); } @PostConstruct public void startWatching() { Thread watchThread = new Thread(this::watchConfigMap); watchThread.setDaemon(true); watchThread.setName("k8s-config-watcher"); watchThread.start(); } private void watchConfigMap() { try { kubernetesClient.configMaps() .inNamespace(namespace) .withName(configMapName) .watch(new Watcher<ConfigMap>() { @Override public void eventReceived(Action action, ConfigMap configMap) { if (action == Action.MODIFIED) { log.info("ConfigMap {} modified", configMapName); eventPublisher.publishEvent(new ConfigMapUpdateEvent(this, configMap.getData())); } } @Override public void onClose(WatcherException cause) { log.warn("ConfigMap watch closed, reconnecting...", cause); // Implement reconnection logic } }); log.info("Started watching ConfigMap: {} in namespace: {}", configMapName, namespace); } catch (Exception e) { log.error("Failed to watch ConfigMap", e); } } private String getCurrentNamespace() { try { return kubernetesClient.getNamespace(); } catch (Exception e) { log.warn("Could not determine namespace, using 'default'", e); return "default"; } } } // Custom event for configuration updates public class ConfigMapUpdateEvent extends ApplicationEvent { private final Map<String, String> configData; public ConfigMapUpdateEvent(Object source, Map<String, String> configData) { super(source); this.configData = configData; } public Map<String, String> getConfigData() { return configData; } } // Event listener to handle updates @Component @Slf4j public class ConfigMapUpdateListener { private final DynamicConfig dynamicConfig; public ConfigMapUpdateListener(DynamicConfig dynamicConfig) { this.dynamicConfig = dynamicConfig; } @EventListener public void onConfigMapUpdate(ConfigMapUpdateEvent event) { log.info("Processing ConfigMap update"); Map<String, String> newData = event.getConfigData(); // Update configuration based on new data if (newData.containsKey("feature.enabled")) { dynamicConfig.setFeatureEnabled(Boolean.parseBoolean(newData.get("feature.enabled"))); } if (newData.containsKey("cache.timeout")) { dynamicConfig.setCacheTimeout(Integer.parseInt(newData.get("cache.timeout"))); } log.info("Dynamic configuration updated: featureEnabled={}, cacheTimeout={}", dynamicConfig.isFeatureEnabled(), dynamicConfig.getCacheTimeout()); } }

Strategy 4: Scheduled Configuration Reload

Periodic Config Checker

// src/main/java/com/company/config/ScheduledConfigReloader.java @Component @Slf4j @EnableScheduling public class ScheduledConfigReloader { private final ConfigMapWatcher configMapWatcher; private final File configFile; private long lastModified; public ScheduledConfigReloader(@Value("${config.file:/etc/config/app.properties}") String configFilePath) { this.configMapWatcher = configMapWatcher; this.configFile = new File(configFilePath); this.lastModified = configFile.lastModified(); } @Scheduled(fixedDelay = 30000) // Check every 30 seconds public void checkForConfigChanges() { if (!configFile.exists()) { return; } long currentModified = configFile.lastModified(); if (currentModified > lastModified) { log.info("Config file changed detected, reloading configuration..."); lastModified = currentModified; configMapWatcher.reloadConfiguration(); } } }

Complete Kubernetes Deployment Example

ConfigMap Definition

# k8s/configmap.yaml apiVersion: v1 kind: ConfigMap metadata: name: java-app-config labels: app: java-app data: application.properties: | app.feature-flag=ENABLED app.timeout=5000 app.api-url=https://api.company.com/v1 app.cache.enabled=true app.retry.count=3 logback.xml: | <configuration> <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender"> <encoder> <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern> </encoder> </appender> <root level="info"> <appender-ref ref="STDOUT" /> </root> </configuration>

Deployment with Volume Mounts

# k8s/deployment.yaml apiVersion: apps/v1 kind: Deployment metadata: name: java-app spec: replicas: 2 selector: matchLabels: app: java-app template: metadata: labels: app: java-app spec: containers: - name: java-app image: my-registry/java-app:latest ports: - containerPort: 8080 volumeMounts: - name: config-volume mountPath: /etc/config readOnly: true - name: logging-config-volume mountPath: /app/config readOnly: true env: - name: CONFIG_PATH value: "/etc/config" - name: LOG_CONFIG_PATH value: "/app/config" resources: requests: memory: "512Mi" cpu: "500m" limits: memory: "1Gi" cpu: "1000m" livenessProbe: httpGet: path: /actuator/health port: 8080 initialDelaySeconds: 30 periodSeconds: 10 readinessProbe: httpGet: path: /actuator/health/readiness port: 8080 initialDelaySeconds: 5 periodSeconds: 5 volumes: - name: config-volume configMap: name: java-app-config items: - key: application.properties path: application.properties - name: logging-config-volume configMap: name: java-app-config items: - key: logback.xml path: logback.xml

Advanced: Dynamic Log Level Configuration

// src/main/java/com/company/config/DynamicLoggingConfig.java @Component @Slf4j public class DynamicLoggingConfig { private final LoggerContext loggerContext = (LoggerContext) LoggerFactory.getILoggerFactory(); @EventListener public void onConfigMapUpdate(ConfigMapUpdateEvent event) { Map<String, String> configData = event.getConfigData(); if (configData.containsKey("log.level.root")) { String logLevel = configData.get("log.level.root"); setLogLevel("ROOT", logLevel); log.info("Updated root log level to: {}", logLevel); } if (configData.containsKey("log.level.com.company")) { String logLevel = configData.get("log.level.com.company"); setLogLevel("com.company", logLevel); log.info("Updated package log level to: {}", logLevel); } } private void setLogLevel(String loggerName, String level) { Logger logger = loggerContext.getLogger(loggerName); switch (level.toUpperCase()) { case "TRACE": logger.setLevel(Level.TRACE); break; case "DEBUG": logger.setLevel(Level.DEBUG); break; case "INFO": logger.setLevel(Level.INFO); break; case "WARN": logger.setLevel(Level.WARN); break; case "ERROR": logger.setLevel(Level.ERROR); break; default: logger.setLevel(null); // Inherit from parent } } }

Testing ConfigMap Reloading

Unit Test

// src/test/java/com/company/config/ConfigMapWatcherTest.java @ExtendWith(MockitoExtension.class) class ConfigMapWatcherTest { @Mock private AppConfig appConfig; @TempDir Path tempDir; private ConfigMapWatcher configMapWatcher; @Test void testConfigReload() throws Exception { // Create test config file Path configFile = tempDir.resolve("application.properties"); Files.write(configFile, "app.feature-flag=TEST\napp.timeout=1000".getBytes()); configMapWatcher = new ConfigMapWatcher(appConfig, tempDir.toString()); // Update config file Files.write(configFile, "app.feature-flag=PROD\napp.timeout=2000".getBytes()); // Allow time for file system events Thread.sleep(100); verify(appConfig, times(1)).setFeatureFlag("PROD"); verify(appConfig, times(1)).setTimeout(2000); } }

Best Practices for ConfigMap Reloading

Use Readiness Probes: Update readiness status during configuration reload
Implement Circuit Breakers: Prevent issues during configuration transitions
Version Your ConfigMaps: Include version information in ConfigMap metadata
Graceful Fallbacks: Maintain previous configuration if reload fails
Monitoring: Track configuration reload events and failures
Resource Limits: Set appropriate memory and CPU limits for watch operations

// Health indicator for configuration state @Component public class ConfigHealthIndicator implements HealthIndicator { private final ConfigMapWatcher configWatcher; private volatile boolean configValid = true; @Override public Health health() { if (configValid) { return Health.up().withDetail("config", "healthy").build(); } else { return Health.down().withDetail("config", "reload failed").build(); } } }

Conclusion

ConfigMap reloading in Java applications provides powerful dynamic configuration capabilities:

Spring Cloud Kubernetes: Simplest approach for Spring Boot applications
File Watching: Universal approach that works with any Java application
Kubernetes API Watch: Most responsive but requires more setup
Scheduled Reloading: Simple and reliable for less frequent updates

Choose the strategy that best fits your application's requirements:

Use Spring Cloud Kubernetes for full-featured Spring Boot applications
Use file watching for non-Spring applications or when you need fine-grained control
Use Kubernetes API watch for real-time updates and complex configuration scenarios

By implementing ConfigMap reloading, your Java applications can adapt to configuration changes without downtime, improving operational flexibility and deployment velocity.

Java Logistics, Shipping Integration & Enterprise Inventory Automation (Tracking, ERP, RFID & Billing Systems)

https://macronepal.com/blog/aftership-tracking-in-java-enterprise-package-visibility/
Explains how to integrate AfterShip tracking services into Java applications to provide real-time shipment visibility, delivery status updates, and centralized tracking across multiple courier services.

https://macronepal.com/blog/shipping-integration-using-fedex-api-with-java-for-logistics-automation/
Explains how to integrate the FedEx API into Java systems to automate shipping tasks such as creating shipments, calculating delivery costs, generating shipping labels, and tracking packages.

https://macronepal.com/blog/shipping-and-logistics-integrating-ups-apis-with-java-applications/
Explains UPS API integration in Java to enable automated shipping operations including rate calculation, shipment scheduling, tracking, and delivery confirmation management.

https://macronepal.com/blog/generating-and-reading-qr-codes-for-products-in-java/
Explains how Java applications generate and read QR codes for product identification, tracking, and authentication, supporting faster inventory handling and product verification processes.

https://macronepal.com/blog/designing-a-robust-pick-and-pack-workflow-in-java/
Explains how to design an efficient pick-and-pack workflow in Java warehouse systems, covering order processing, item selection, packaging steps, and logistics preparation to improve fulfillment efficiency.

https://macronepal.com/blog/rfid-inventory-management-system-in-java-a-complete-guide/
Explains how RFID technology integrates with Java applications to automate inventory tracking, reduce manual errors, and enable real-time stock monitoring in warehouses and retail environments.

https://macronepal.com/blog/erp-integration-with-odoo-in-java/
Explains how Java applications connect with Odoo ERP systems to synchronize inventory, orders, customer records, and financial data across enterprise systems.

https://macronepal.com/blog/automated-invoice-generation-creating-professional-excel-invoices-with-apache-poi-in-java/
Explains how to automatically generate professional Excel invoices in Java using Apache POI, enabling structured billing documents and automated financial record creation.

https://macronepal.com/blog/enterprise-financial-integration-using-quickbooks-api-in-java-applications/
Explains QuickBooks API integration in Java to automate financial workflows such as invoice management, payment tracking, accounting synchronization, and financial reporting.