Config Updates Without Redeployment for Spring and Kubernetes

By Archie Cowan

Prototype Developer for AWS global and strategic customers, former ITHAKA/JSTOR Chief Architect. Generative AI builder. Aspiring to do everything.

• Create a small Spring Boot application that loads a property file from a configurable location overriding configuration that is packaged with the application.
• Package the application in a docker image and see how to override the config file via docker commands.
• Deploy the application to kubernetes.
• Use a Kubernetes Configmap to update your configuration without redeployment of your application.
• Learn about when using these methods together is recommended.

Starting your Spring Boot application example

import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {

    @GetMapping(path = "/hello")
    public Greeting hello(@Value("${message}") String message ) {
        return new Greeting(message);
    }

}

class Greeting {
    private String greeting;
    public Greeting(String greeting) {
        this.greeting = greeting;
    }

    public String getGreeting() {
        return greeting;
    }

    public void setGreeting(String greeting) {
        this.greeting = greeting;
    }
}

• @RestController tells spring this class provides endpoints to make available on the web server
• @GetMapping(path = "/hello") creates an endpoint on the path /hello
• @Value("${message}") String message injects a property called message whenever this function is called
• The Greeting class is just a struct for us to return in our message

message=This is the default message.

{"greeting":"This is the default message."}

<dependency>
  <groupId>commons-configuration</groupId>
  <artifactId>commons-configuration</artifactId>
  <version>1.10</version>
</dependency>

import org.apache.commons.configuration.PropertiesConfiguration;
import org.springframework.core.env.PropertySource;

/**
 * ReloadablePropertySource wraps a commons-config PropertiesConfiguration
 * in a Spring PropertySource interface so that a PrpoertiesConfiguration
 * can be added to a Spring Environment Property Sources list.
 */
class ReloadablePropertySource extends PropertySource {

    private PropertiesConfiguration propertiesConfiguration;

    public ReloadablePropertySource(String name,
                        PropertiesConfiguration propertiesConfiguration) {
        super(name);
        this.propertiesConfiguration = propertiesConfiguration;
    }

    @Override
    public Object getProperty(String s) {
        return propertiesConfiguration.getProperty(s);
    }
}

import org.apache.commons.configuration.PropertiesConfiguration;
import org.apache.commons.configuration.reloading.FileChangedReloadingStrategy;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.env.ConfigurableEnvironment;
import org.springframework.core.env.MutablePropertySources;

import java.io.File;

@Configuration
public class DemoConfiguration {

    private ConfigurableEnvironment env;

    public DemoConfiguration(@Autowired ConfigurableEnvironment env) {
        this.env = env;
    }

    @Bean
    @ConditionalOnProperty(name = "spring.config.location",
                            matchIfMissing = false)
    public PropertiesConfiguration propertiesConfiguration(
            @Value("${spring.config.location}") String path) throws Exception {
        PropertiesConfiguration configuration =
            new PropertiesConfiguration( new File(path));
        FileChangedReloadingStrategy fcrs = new FileChangedReloadingStrategy();
        fcrs.setRefreshDelay(1000);
        configuration.setReloadingStrategy(fcrs);
        return configuration;
    }

    @Bean
    @ConditionalOnProperty(name = "spring.config.location",
                            matchIfMissing = false)
    public ReloadablePropertySource reloadablePropertySource(
            PropertiesConfiguration properties) {
        ReloadablePropertySource ret =
            new ReloadablePropertySource("dynamic", properties);
        MutablePropertySources sources = env.getPropertySources();
        sources.addFirst(ret);
        return ret;
    }
}

• @ConditionalOnProperty(name = "spring.config.location", matchIfMissing = false) gates these methods from running unless a property spring.config.location is available. You will pass this on the command line with a system property in a few steps.
• the propertiesConfiguration method creates a commons-configuration PropertiesConfiguration object that refreshes after 1 second if there are nay changes.
• the reloadablePropertySource method takes the PropertiesConfiguration you created and makes it the first place Spring will look for properties with sources.addFirst(ret).

message=Hello my name is Jake

-Dspring.config.location=k8s/config.properties

Running the DemoApplication in Docker

mvn spring-boot:build-image -Dspring-boot.build-image.imageName=demoapplication:0.1

docker run -it --rm -p 8081:8080 demoapplication:0.1

curl http://localhost:8081/hello ; echo
{"greeting":"Default message in application.properties"}

docker run -it --rm -p 8081:8080 \
  -e JAVA_TOOL_OPTIONS='-Dspring.config.location=/hello/config.properties' \
  -v $PWD/k8s/:/hello/  \
  demoapplication:0.1

curl http://localhost:8081/hello ; echo
{"greeting":"Hello my name is Jake"}

message=Hello my name is Enzo

curl http://localhost:8081/hello ; echo
{"greeting":"Hello my name is Enzo"}

Now with Kubernetes

eval $(minikube docker-env)

kubectl create namespace hello-ns

kubectl config set-context --current --namespace=hello-ns

ConfigMap

kubectl create configmap hello-config --from-file=k8s/config.properties

kubectl describe configmap hello-config
Name:         hello-config
Namespace:    hello-ns
Labels:       <none>
Annotations:  <none>

Data
====
config.properties:
----
message=Hello my name is Jake

BinaryData
====

Events:  <none>

kubectl get configmap hello-config -o yaml

kubectl create deployment helloapp --image=demoapplication:0.1

kubectl expose deployment helloapp --type=LoadBalancer --port 8080

minikube tunnel

{"greeting":"This is the default message."}

spec:
  template:
    spec:
      containers:
        ...
        - image: demoapplication:0.1
          volumeMounts:
            - name: config-vol
              mountPath: "/hello/"
      volumes:
      - name: config-vol
        configMap:
          name: hello-config

spec:
  containers:
    - image: demoapplication:0.1
      env:
        - name: JAVA_TOOL_OPTIONS
          value: "-Dspring.config.location=/hello/config.properties"

{"greeting":"Hello my name is Jake"}

When this is recommended

• You're already running Kubernetes.
• There is a business benefit to updating configuration without restarting your application.
• The time to deploy a configuration update is much faster than simply deploying a new container image.
• You prefer not to run a dedicated configuation server in addition to your application ³.
• Your application configuration is contextual to the Kubernetes namespace in which it runs and you operate many namespaces with different configurations deployed.
• Multiple applications running in the same namespace share configuration values.
• Configuration is committed to your source control system.
• Configuration is delivered to Kubernetes from source control via deployment automation.

Enjoy!