How to read multiple config file from Spring Cloud Config Server

spring cloud config multiple profiles
spring cloud config client
spring cloud config server without git
spring cloud config server github
spring config server local file
spring cloud config server database example
spring cloud config: enabled: false not working
spring-cloud config: uri not working

Spring cloud config server supports reading property files with name ${spring.application.name}.properties. However I have 2 properties files in my application.

a.properties
b.properties

Can I get the config server to read both these properties files?

Rename your properties files in git or file system where your config server is looking at.

a.properties -> <your_application_name>.properties
a.properties -> <your_application_name>-<profile-name>.properties

For example, if your application name is test and you are running your application on dev profile, below two properties will be used together.

test.properties
test-dev.properties

Also you can specify additional profiles in bootstrap.properties of your config client to retrieve more properties files like below. For example,

spring:
  profiles: dev
  cloud:
    config:
      uri: http://yourconfigserver.com:8888
      profile: dev,dev-db,dev-mq

If you specify like above, below all files will be used together.

test.properties
test-dev.properties
test-dev-db.prpoerties
test-dev-mq.properties

2. Spring Cloud Config Server, server.port: 8888 spring.cloud.config.server.git.uri: file://${user.home}/config-repo You may need to do so if you are going to run apps with multiple profiles, as shown in the Note. The used UAA client-id should have credhub.read as scope . Spring Cloud Config Server provides an HTTP resource-based API for external configuration (name-value pairs or equivalent YAML content). The server is embeddable in a Spring Boot application, by using the @EnableConfigServer annotation. Consequently, the following application is a config server: ConfigServer.java.

Note that the provided answer assumes your property files address different execution profiles. If they dont, i.e., your properties are split into different files for some other reason, e.g., maintenance purposes, divided by business/functional domain, or any other reason that suits your needs, then, by defining a profile for each such file, you are just "abusing" the profile feature, for achieving your goal (multiple property files per app).

You could then ask "OK, so what is the problem with that?". The problem is that you restrain yourself from various possibilities that you would otherwise have. If you actually want to customize your application configuration by profile you will have to create pseudo, sub, profiles for that since the file name is already a profile. Example:

Your application configuration could be customized by different profiles, which you use inside your springboot application (e.g. in @Profile() annotation), let them be dev, uat, prod. You can boot your application setting different profiles as active, e.g. 'dev' vs 'uat', and get the group of properties that you desire. For your a.properties b.properties and c.properties file, if different file names were supported, you would have a-dev.properties b-dev.properties and c-dev.properties files vs a-uat.properties b-uat.properties and c-uat.properties files for 'dev' and 'uat' profile.

Nevertheless, with the provided solution, you already have defined 3 profiles for each file: appname-a.properties appname-b.properties, and appname-c.properties: a, b, and c. Now imagine you have to create a different profile for each... profile(! it already shows something goes wrong here)! you would end up with a lot of profile permutations (which would get worse as files increase): The files would be appname-a-dev.properties, appname-b-dev.properties, app-c-dev.properties vs appname-a-uat.properties, appname-b-uat.properties, app-c-uat.properties, but the profiles would have been increased from ['dev', ' uat'] to ['a-dev', 'b-dev', 'c-dev', 'a-uat', 'b-uat', 'c-uat'] !!!

Even worse, how are you going to cope with all these profiles inside your code and more specifically your @Profile() annotations? Will you clutter the code space with "artificial" profiles just because you want to add one or two more different property files? It should have been sufficient to define your dev or uat profiles, where applicable, and define somewhere else the applicable property file names (which could then be further supported by profile, without any other configuration action), just as it happens in the externalized properties configuration for individual springboot apps

For argument completeness, I will just add here that if you want to switch to .yml property files one day, with the provided profile-based naming solution, you also loose the ability to define different "yaml document sections per profile" inside the same .yml file (Yes, in .yml you can have one property file yet define multiple logical yml documents inside, which its usually done for customizing the properties for different profiles, while having all related properties in one place). You loose the ability because you have already used the profile in the file name (appname-profile.yml)

I have issued a pull request with a minor fix for spring-cloud-config-server 1.4.x, which allows defining additionally supported file names (appart from "application[-profile]" and "{appname}[-profile]", that are currently supported) by providing a spring.cloud.congif.server.searchNames environment property - analogous to spring.config.name for springboot apps. I hope it gets reviewed and accepted.

Spring Cloud Config, server.port: 8888 spring.cloud.config.server.git.uri: file://${user.home}/config-repo You may need to do this if you are going to run apps with multiple profiles. will cause all applications that are config clients to read foo=bar independent of� I want to try the spring cloud config for microservice project where I have a common config for all services and multiple configs for each service. I got idea on how to use multiple profiles using spring.profiles.active and include .

I came across the same requirement lately with a little more constraint that I am not allowed to play around the environment profiles. So I wasn't allowed to do as the accepted answer. I'm sharing how I did it as an alternative to those who might have same case as me.

In my application, I have properties such as:

appxyz-data-soures.properties
appxyz-data-soures-staging.properties
appxyz-data-soures-production.properties
appxyz-interfaces.properties
appxyz-interfaces-staging.properties
appxyz-interfaces-production.properties
appxyz-feature.properties
appxyz-feature-staging.properties
appxyz-feature-production.properties

application.properties // for my use, contains local properties only
bootstrap.properties // for my use, contains management properties only

In my application, I have these particular properties set that allow me to achieve what I needed. But note I have the rest of needed config as well (enable cloud config, actuator refresh, eureka service discovery and so on) - just highlighting these for emphasis:

spring.application.name=appxyz
spring.cloud.config.name=appxyz-data-soures,appxyz-interfaces,appxyz-feature

You can observe that I didn't want to play around my application name but instead I used it as prefix for my config property files.

In my configuration server I configured in application.yml to capture pattern: 'appxyz-*':

spring:
  cloud:
    config:
      server:
        git:
          uri: <git repo default>
          repos:
            appxyz:
              pattern: 'appxyz-*'
              uri: <another git repo if you have 1 repo per app>
              private-key: ${git.appxyz.pk}
          strict-host-key-checking: false
          ignore-local-ssh-settings: true
          private-key: ${git.default.pk}

In my Git repository I have the following. No application.properties and bootstrap because I didn't want those to be published and overridden/refreshed externally but you can do if you want.

appxyz-data-soures.properties
appxyz-data-soures-staging.properties
appxyz-data-soures-production.properties
appxyz-interfaces.properties
appxyz-interfaces-staging.properties
appxyz-interfaces-production.properties
appxyz-feature.properties
appxyz-feature-staging.properties
appxyz-feature-production.properties

It will be the pattern matching pattern: 'appxyz-*' that will capture and return the matching files from my git repository. The profile will also apply and fetch the correct property file accordingly. The prioritization of value is also preserved.

Furthermore, if you wish to add more file in your application (say appxyz-circuit-breaker.properties), we only need to do:

  1. Add the name pattern in the spring.cloud.config.name=...,appxyz-circuit-breaker
  2. The add the copies of the file locally and also externally (in the git repo.

No need to add/modify more or restart your configuration server later on. For new application, it's like a one time registration thing to add an entry under the repos of application.yml.

Hope it helps in one way or another!

7. Spring Cloud Config Client, Placeholders in Git URI; Pattern Matching and Multiple Repositories server.port : 8888 spring.cloud.config.server.git.uri: file://${user.home}/config-repo will cause all applications that are config clients to read foo=bar independent of their � This tutorial will show you how write a microservice to access centralized properties files on a Spring Cloud config server, as set up in a previous series.

Spring Cloud Config Server client, The default behavior for any application that has the Spring Cloud Config Client on For example, the following YAML file is for a Config Server that is a Eureka client: multiple URLs (as a comma-separated list under the spring.cloud.config. uri can be done by using the property spring.cloud.config.request-read-timeout . as my project has some common configuration file, so I put it to commonconfig.git. commonconfig.git contains datasource-dev.properties, datasource-prod.properties project1.git contains application-dev.yml, application-prod.yml

Config Server Reading from multiple property files � Issue #863 , server.port: 8888 spring.cloud.config.server.git.uri: file://${user.home}/config-repo and, if there are multiple profiles, the last one wins (similar to adding entries to a Map ). The used UAA client-id should have credhub.read as scope. How Spring Cloud Config Server Stores Configuration:-The Spring cloud config server stores configuration in two ways. Git or SVN; Using local File System; We are going to use a Github repository and store configuration in a properties file. We are going to create a properties file for each microservice.

Quick Intro to Spring Cloud Configuration, Hi , I want to have one config server running Say i have one spring-cloud / spring-cloud-config Config Server Reading from multiple property files #863 Your clients just need spring.application.name set appropriately. spring.cloud.config.uri is the property to mention the config server url. Point to note that our config server is running on port 8888; verify it by opening the application.properties file of the spring config server code base and check the server.port=8888.

Comments
  • you can also do spring.application.name=a,b