关于Netflix Archaius集中配置与Spring Cloud Config Server适配的技术问询

Hey there! Let's tackle your two questions about Archaius and Spring Cloud Config Server one by one, based on my experience working with these tools.

Question 1: Can we build a centralized Archaius configuration service for client-side active pulling? #

Absolutely! Archaius is built with extensibility at its core, so you can definitely set up a centralized configuration service that your client services pull from—eliminating the need to redeploy every client when your config loading logic changes.

Here's a practical approach:

• Use Archaius's DynamicConfiguration interface alongside PolledConfigurationSource (or WatchedConfigurationSource for event-driven updates) to create a custom client-side config source that fetches data from your centralized service.
• Build a lightweight centralized config service (e.g., a REST API) that handles the core config loading logic—whether that's reading from databases, custom storage, or other resources. This is the only component you'll need to update if your config loading logic shifts.
• On the client side, implement a PolledConfigurationSource that calls your centralized service's API at regular intervals to fetch the latest configs, then install this into Archaius's ConfigurationManager.

Here's a quick code snippet for the client-side custom config source:

public class CentralizedConfigSource extends PolledConfigurationSource {
    private final String configServiceBaseUrl;

    public CentralizedConfigSource(String configServiceBaseUrl) {
        this.configServiceBaseUrl = configServiceBaseUrl;
    }

    @Override
    public PollResult poll(boolean initialLoad, Object lastCheckpoint) throws Exception {
        // Fetch configs tailored to the current service from the centralized service
        RestTemplate restTemplate = new RestTemplate();
        String serviceConfigUrl = String.format("%s/configs/%s", configServiceBaseUrl, "your-service-id");
        Map<String, Object> latestConfigs = restTemplate.getForObject(serviceConfigUrl, Map.class);
        
        return PollResult.createFull(latestConfigs);
    }
}

Then initialize Archaius with this source in your client service:

// Poll for config updates every 60 seconds
DynamicConfiguration centralizedConfig = new DynamicConfiguration(
    new CentralizedConfigSource("http://your-central-config-service:8080"),
    new FixedDelayPollingScheduler(60000)
);
ConfigurationManager.install(centralizedConfig);

With this setup, any changes to config loading logic (like switching from files to a database) only need to be made in the centralized service—your clients will automatically pull updated configs without redeployment.

Question 2: Is there a feasible way to let Spring Cloud Config Server load configurations from Archaius (or custom data sources like Archaius-supported databases)? #

Yes! You can extend Spring Cloud Config Server to support custom data sources (including those Archaius uses, like databases) by implementing its EnvironmentRepository interface. This lets you replace or augment the default config loading logic with your own—including integrating Archaius's existing config sources.

Here's how to do it:

1. Create a custom EnvironmentRepository bean in your Spring Cloud Config Server application. This bean will handle fetching configs from your desired source (e.g., a database that Archaius would normally use).
2. Inside this repository, you can either directly implement database query logic, or reuse Archaius's existing JDBCConfigurationSource (or other Archaius config sources) to load configs, then convert those into the Environment object Spring Cloud Config Server expects.
3. Register this custom repository as the primary bean so Spring Cloud Config Server uses it instead of the default file/git-based repositories.

Here's a sample implementation that uses Archaius's JDBC source:

@Component
public class ArchaiusJdbcEnvironmentRepository implements EnvironmentRepository {
    private final DynamicConfiguration archaiusConfig;

    // Inject your pre-configured DataSource
    public ArchaiusJdbcEnvironmentRepository(DataSource dataSource) {
        // Initialize Archaius with your database schema
        JDBCConfigurationSource jdbcSource = new JDBCConfigurationSource(
            dataSource,
            "SELECT config_key, config_value FROM service_configs WHERE app_name = ? AND profile = ?",
            new String[]{"app_name", "profile"}
        );
        // Refresh configs every 30 seconds
        this.archaiusConfig = new DynamicConfiguration(jdbcSource, new FixedDelayPollingScheduler(30000));
        ConfigurationManager.install(archaiusConfig);
    }

    @Override
    public Environment findOne(String application, String profile, String label) {
        Environment env = new Environment(application, new String[]{profile}, label, null, null);
        Map<String, Object> configProperties = new HashMap<>();

        // Map Archaius config keys to Spring Cloud Config's format
        Iterator<String> configKeys = archaiusConfig.getKeys();
        while (configKeys.hasNext()) {
            String key = configKeys.next();
            configProperties.put(key, archaiusConfig.getProperty(key));
        }

        // Add Archaius-loaded properties as a property source
        env.add(new MapPropertySource("archaius-jdbc-config", configProperties));
        return env;
    }
}

Once this bean is in place, your Spring Cloud Config Server will load configs directly from the database (using Archaius's logic) and serve them to clients just like it would with git/file-based configs. If you don't need Archaius's dynamic features in the Config Server, you can also skip Archaius entirely and implement the database query logic directly in the custom EnvironmentRepository for a lighter setup.

内容的提问来源于stack exchange，提问作者Débora