Facilitating the Spread of Knowledge and Innovation in Professional Software Development

Write for InfoQ


Choose your language

InfoQ Homepage Articles Optimizing Spring Boot Config Management with ConfigMaps: Environment Variables or Volume Mounts

Optimizing Spring Boot Config Management with ConfigMaps: Environment Variables or Volume Mounts

Key Takeaways

  • Efficient Configuration Management: The article explains methods for effectively managing configuration in Spring Boot applications, emphasizing the utilization of Kubernetes ConfigMaps to store application properties.
  • Seamless Integration with Kubernetes: It outlines seamless integration techniques, showcasing how Spring Boot applications can access ConfigMap data as environment variables or volume mounts within Kubernetes deployments.
  • Streamlined Deployment Process: Through practical use cases and code examples, the article facilitates a streamlined deployment process, allowing developers to efficiently manage and deploy their Spring Boot applications in Kubernetes environments.
  • Choose Configuration Injection Method: The process guides on selecting the appropriate method for injecting ConfigMap data into Spring Boot applications, whether through environment variables or volume mounts, based on their specific use case requirements
  • Enhanced Scalability and Flexibility: By leveraging ConfigMaps, developers can easily update application configurations without rebuilding or redeploying the application, thereby enhancing scalability and flexibility.


In the fast-paced realm of cloud-native development, Spring Boot stands out as a viable framework for its agility and streamlined workflow. Yet, effective configuration management remains a pivotal factor influencing deployment efficiency and ongoing maintenance. Traditionally, configuration intricacies were entrenched within application code or managed through external files, posing challenges in environments like Kubernetes where adaptability is key.

This article is a gateway to unlocking the potential of ConfigMaps, a feature in Kubernetes that provides configuration strategies for Spring Boot applications. By separating configuration from container images, ConfigMaps offer a host of benefits including simplified deployments, dynamic updates, fortified security, and streamlined maintenance.

Throughout this journey, we'll explore two primary methods for harnessing ConfigMaps in Spring Boot applications: leveraging them as environment variables; and utilizing them as volumes. You'll be able to navigate the Kubernetes configuration landscape with confidence.

This article also serves as a roadmap for managing configurations in Spring Boot applications. It delves into integrating ConfigMaps into Spring Boot applications providing  developers with the required agility and insights to tackle configuration challenges in Kubernetes environments.

In the past, developers often embedded configuration details directly within application code or relied on external property files packaged with deployment artifacts. While effective in static environments, such approaches falter in Kubernetes.


To develop a Spring Boot application that utilizes ConfigMaps in Kubernetes and decoupled configuration strategy for Spring Boot applications, you will need the following prerequisites:

Basic Knowledge of Spring Boot: Familiarity with developing applications using the Spring Boot framework.
→ Java Development Kit (JDK): Install a JDK on a development machine. More recent versions of Spring Boot typically require Java 17 or later.
→ Spring Boot Project Setup: Establish a Spring Boot project using a preferred build tool, such as Maven or Gradle, using Spring Initializr.
→ Kubernetes Cluster Access: Establish a Kubernetes cluster where you can deploy and test applications. I would recommend minikube start.
→ kubectl Command-line Tool: Install kubectl, the Kubernetes command-line tool, to interact with the Kubernetes cluster.
→ Kubernetes Configuration Files: Understand how to write Kubernetes configuration files (YAML or JSON) for deploying applications, services, and ConfigMaps.
→ ConfigMap Knowledge: Learn about ConfigMaps in Kubernetes and how they are used to store configuration data separately from application code.
→ Configuration Handling in Spring Boot: Understand how Spring Boot applications can dynamically read configuration properties from environment variables or external configuration files.
→ Docker Knowledge: Knowledge of Docker containers as Spring Boot applications are often deployed as containerized applications in Kubernetes.
→ IDE (Integrated Development Environment): Use an IDE such as IntelliJ IDEA, Eclipse, or Visual Studio Code for Java development.

Kubernetes Configmaps In Spring Boot Applications

Configuring Spring Boot applications in Kubernetes environments presents unique challenges, especially when dealing with multi-stage configuration data across diverse deployment environments. This article offers strategies for efficient configuration management using Kubernetes ConfigMaps to store application property sources. We'll explore two primary methods: loading ConfigMaps as environment variables or volume mounts, shedding light on the benefits and considerations of each approach. Through practical examples and real-world use cases, you will discover how to harness ConfigMaps to enhance application portability, scalability, and maintainability in Kubernetes deployments.

In Kubernetes, ConfigMaps serve as repositories for storing configuration data utilized by Spring Boot applications, effectively separating sensitive information from container image code. For Spring Boot applications in Kubernetes environments, ConfigMaps enable developers to externalize configuration parameters, ranging from properties files to environment variables, streamlining management and adjustment of settings without code changes.

While Kubernetes is a de facto standard in the realm of containerized applications and cloud-native development, efficient configuration management is essential for Spring Boot applications. Traditionally, developers embedded configuration details directly within application code or relied on external property files bundled with deployment packages. While these methods have merits, they pose challenges regarding flexibility and agility, especially in Kubernetes environments.

You can think of ConfigMaps as centralized repositories storing all the configuration data that a Spring Boot application requires, regardless of the deployment environment. ConfigMaps function as key-value stores tailored to hold configuration details accessible to applications within a Kubernetes cluster. This decoupling of configuration from container images offers many advantages:

  • Easy Deployments: ConfigMaps eliminate the hassle of embedding configuration settings within container images or managing external property files. This approach accelerates deployments, reduces image size, and fosters greater agility.
  • Dynamic Configurations: ConfigMaps allows for on-the-fly adjustments to configuration values without altering the codebase. This capability facilitates scaling, environmental adaptation, and A/B testing.
  • Decouple configuration and code: By housing configuration details separately from application code, ConfigMaps promote cleaner code, improved maintainability, and better developer understanding.
  • Strengthen Security: ConfigMaps provide a secure enclave for sensitive information, protecting data like database credentials or API keys within the Kubernetes cluster.

With this straightforward approach, ConfigMaps pave the way for streamlined deployments, dynamic updates, and a more secure and maintainable application architecture.

Various Components of ConfigMaps in Spring Boot Applications

  • Database Connections: Configuration parameters related to database connections, such as database URLs, credentials, and connection pool settings, can be stored in ConfigMaps. The application can then use these configurations to establish connections to databases.
  • Logging Levels: ConfigMaps can include settings for logging levels (TRACE, DEBUG, INFO, WARN, ERROR, FATAL), log file locations, and log output formats. By adjusting these configurations, developers can control the Spring Boot application logs and their locations.
  • Environment Variables: ConfigMaps can define environment variables that are injected into a Spring Boot application runtime that can access these environment variables to customize behavior based on the provided configuration. These include: Spring profiles, Server Port, Context Path, Runtime Environment and memory settings.
  • Properties Files: ConfigMaps can store or application.yml files containing key-value pairs representing configuration settings for a Spring Boot application. These files can be loaded into a Spring Boot application context, allowing the application to read and utilize the configuration data.
  • Feature Toggles: ConfigMaps can contain feature toggle settings, allowing developers to dynamically enable or disable certain features of the application. This enables flexible feature management without redeploying the application.
  • Profile Support: Loads configuration specific to active Spring Boot profiles.
  • Hot Reloading: Automatically reloads configurations when changes are made to the ConfigMap, eliminating the need for application restarts.
  • Messaging Queue Configurations: Messaging queue configurations are another crucial aspect that can be stored and managed using ConfigMaps in Kubernetes for Spring Boot applications.

Examples include: Queue, Topic Names, Broker connection URLs, Redelivery policies, Concurrency, Scaling configurations, Transactions Types, Delivery mode and security.

By storing messaging queue configurations in ConfigMaps, Spring Boot applications running in Kubernetes environments can easily adapt to changes in messaging infrastructure or requirements without requiring code modifications.

Overall, ConfigMaps provide a mechanism for managing configuration data across different components of a Spring Boot application deployed in a Kubernetes environment. Spring Boot applications can dynamically adapt their behavior based on configuration stored in Kubernetes ConfigMaps, promoting flexibility, scalability and easier management.

There are two main approaches to configure Spring Boot applications running on Kubernetes with ConfigMaps: the first approach loads ConfigMaps into Spring Boot applications as environment variables; and the second approach loads ConfigMaps into Spring Boot applications as mounting them as volumes. Volume mounting enables hot reloading of configurations when changes are made to the ConfigMap.

First Approach: Loading ConfigMaps into Spring Boot Applications as Environment Variables

Loading ConfigMaps into Spring Boot applications as environment variables is a best practice for managing configuration data in Kubernetes environments. Here's how to implement this approach with these step-by-step instructions to load Spring Boot configuration using SPRING_APPLICATION_JSON in a ConfigMap as an environment variable in Kubernetes:

definition for a ConfigMap

  1. Create a Spring Boot Application: Develop Spring Boot applications as we normally would, including defining our application properties or YAML configuration files (refer to code).
  2. Prepare the Spring Boot Application for Kubernetes: Ensure that a Spring Boot application is configured to read configuration properties from environment variables. We can achieve this by using Spring Boot's built-in support for environment variable substitution.
  3. Define a ConfigMap YAML File: A ConfigMap YAML contains the JSON configuration we want to inject into Spring Boot application. We can create a ConfigMap using a YAML file. Here's an example YAML definition for a ConfigMap:


  4. Create a ConfigMap Object: Create a ConfigMap Object into Kubernetes Cluster by executing the command, kubectl apply -f config.yml, and the ConfigMap will be created into Kubernetes cluster. We can deploy them separately or as part of the same deployment manifest YML.
  5. Load ConfigMaps as Environment Variables: Configure the Kubernetes deployment YAML file to mount the ConfigMaps (config.yml) as environment variables in the Spring Boot application. This can be done by referencing the ConfigMap keys in the env section of the container specification. Here's an example deployment manifest:


  6. Access ConfigMap Data in Spring Boot: In a Spring Boot application, access the configuration data provided by the ConfigMaps through environment variables. Spring Boot automatically loads environment variables into its Environment object, allowing you to programmatically access them.

    The SPRING_APPLICATION_JSON environment variable in Spring Boot allows you to provide inline JSON to configure Spring Boot applications. When Spring Boot starts up, it looks for this environment variable and, if present, parses the JSON content and merges it with the Spring Boot application's existing configuration properties.

    When Spring Boot application starts up and detects the SPRING_APPLICATION_JSON environment variable with this JSON content, it will override the corresponding properties for the datasource URL, username and password.

  7. Start Spring Boot Application: Once the deployment is created, Kubernetes will inject the environment variables from the ConfigMap into Spring Boot application pods. The Spring Boot application will automatically pick up these environment variables and use them to configure itself.

That's it! The Spring Boot application is now configured to load its configuration from the SPRING_APPLICATION_JSON environment variable, which is sourced from the ConfigMap in Kubernetes. This allows dynamically managing a Spring Boot application's configuration without modifying its code.

The full ConfigMaps application using environmental variables may be found in this GitHub ​​repository.

Second Approach: Loading ConfigMaps into Spring Boot Applications as Volumes

Loading ConfigMaps into Spring Boot applications as volumes in Kubernetes is another practice for managing configuration data in Kubernetes environments.

Here's how to implement this approach with step-by-step instructions to load Spring Boot configuration using volume mounts in Kubernetes:

  1. Create a ConfigMap: Create a ConfigMap in Kubernetes containing the configuration data needed by Spring Boot application. We can create a ConfigMap using YAML configuration:


  2. Mount ConfigMap as a Volume: Modify the Kubernetes deployment configuration YAML file to mount the ConfigMap as a volume into the pods running Spring Boot application. Specify the mount path where the application expects to find its configuration files.


  3. Update the Spring Boot Application: Configure the Spring Boot application to read configuration files from the mounted volume path. We need to adjust the application's property YML file locations accordingly.
  4. Deploy the Application: Deploy the Spring Boot application to Kubernetes using the updated deployment configuration. Make sure to create the ConfigMap in the same namespace as the application running. For example: namespace: dev
  5. Verify the Configuration: Verify that Spring Boot application can access the configuration data from the mounted volume. You can get into a running pod and inspect the mounted volume to ensure that the configuration files are present.
  6. Test Configmap Updates: Make changes to the ConfigMap data using kubectl commands or by updating the ConfigMap YAML configuration. Verify that the changes are reflected in the running Spring Boot application without requiring a redeployment or code changes.


  • This approach allows managing application configuration outside the container image, making deployments more dynamic and easier to update.
  • ConfigMaps are versioned, so you can track changes and roll back if needed.
  • This decoupling of configuration from container images translates to several advantages.

The full ConfigMaps application using volume mounts may be found in this GitHub repository.


Using ConfigMaps as environment variables, we unlock a ton of benefits that enhance the configuration management landscape for Spring Boot applications in Kubernetes environments. By extracting configuration from container images, we foster a deployment environment where updates are seamless and tracking changes becomes effortless through versioning. This decoupling offers a wealth of advantages, from streamlined deployments to reduced error risks and improved maintainability.

Furthermore, this approach allows developers to adopt agile practices, facilitating rapid iterations and promoting a DevOps culture within their organizations. While it may not be a one-size-fits-all solution, particularly for intricate configuration needs, the versatility and simplicity of ConfigMaps as environment variables make them a formidable tool in the Kubernetes arsenal.

Combined with Kubernetes' native capabilities for managing ConfigMaps and secrets, developers have at their disposal a framework that ensures their Spring Boot applications are optimally configured for the cloud-native environment. By adhering to best practices in configuration management, including the strategic utilization of ConfigMaps as environment variables, developers can build resilient, scalable, and maintainable applications that excel in Kubernetes deployments. In essence, ConfigMaps pave the way for a more agile and efficient approach to configuration management, laying the foundation for success in the dynamic world of cloud-native development.

About the Author

Rate this Article