Dynamic configuration updates in Microservices - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Architecture

intermediate

Designing a dynamic configuration update system for microservices

You need to design a system that allows microservices to update their configuration dynamically without restarting. Which architectural component is essential to achieve this?

A A centralized configuration service that microservices poll periodically for updates.

B Embedding configuration files inside each microservice's container image.

C Hardcoding configuration values in the microservice source code.

D Using environment variables set only at microservice startup.

💡 Hint

Think about a component that can serve updated settings to many services without restarting them.

A centralized configuration service allows microservices to fetch updated configurations dynamically. Polling or push mechanisms enable updates without restarts. Embedding configs or hardcoding them prevents dynamic updates.

❓ scaling

intermediate

Scaling configuration updates in a large microservices environment

You have 1000 microservice instances needing configuration updates simultaneously. What is the best approach to efficiently propagate updates?

A Each instance polls the configuration service every second independently.

B Use a publish-subscribe system where the configuration service pushes updates to instances.

C Restart all microservices to reload configuration from local files.

D Manually update configuration on each instance via SSH.

💡 Hint

Consider a method that avoids thousands of independent requests at once.

A publish-subscribe system efficiently pushes updates to all instances simultaneously, reducing load and latency. Polling causes heavy load, restarts cause downtime, and manual updates are not scalable.

❓ tradeoff

advanced

Tradeoffs between push and pull models for configuration updates

Which statement best describes a tradeoff between push and pull models for dynamic configuration updates in microservices?

A Pull models guarantee immediate consistency; push models do not.

B Pull models reduce latency but require persistent connections; push models increase latency but simplify client design.

C Push models reduce latency but require persistent connections; pull models increase latency but simplify client design.

D Push models always use less network bandwidth than pull models regardless of scale.

💡 Hint

Think about how updates reach clients and the connection types involved.

Push models send updates immediately but need persistent connections like websockets. Pull models have clients ask periodically, increasing latency but simplifying client logic. Bandwidth and consistency depend on implementation.

❓ component

advanced

Key component for ensuring consistency of dynamic configuration across microservices

Which component is critical to ensure all microservices see a consistent configuration version during dynamic updates?

A A versioning system that tags configuration snapshots and enforces atomic updates.

B A load balancer that routes requests to updated microservices only.

C A logging system that records configuration changes asynchronously.

D A caching layer that stores old configuration indefinitely.

💡 Hint

Think about how to prevent microservices from using mixed or partial configurations.

Versioning and atomic updates ensure microservices switch to a new configuration simultaneously, avoiding inconsistency. Load balancers, caches, and logs do not guarantee configuration consistency.

❓ estimation

expert

Estimating capacity for configuration update propagation

You have 10,000 microservice instances. Each configuration update is 50 KB. Updates occur once every 10 minutes. Estimate the minimum network bandwidth needed to propagate updates to all instances within 1 minute.

A Approximately 50 Mbps

B Approximately 67 Mbps

C Approximately 100 Mbps

D Approximately 83 Mbps

💡 Hint

Calculate total data size and divide by propagation time, then convert to Mbps.

Total data = 10,000 instances * 50 KB = 500,000 KB = 500 MB. To send in 1 minute (60 seconds): 500 MB / 60 s ≈ 8.33 MB/s. Convert to Mbps: 8.33 MB/s * 8 = 66.64 Mbps. Considering overhead and safety margin, ~83 Mbps is reasonable.

Practice

1. What is the main benefit of using dynamic configuration updates in microservices?

easy

A. Encrypt all service communication by default

B. Change service settings without restarting or downtime

C. Reduce the size of service containers

D. Increase the number of microservices automatically

Solution

1. Step 1: Understand dynamic configuration updates

   Dynamic configuration updates allow changing settings while the service is running.

2. Step 2: Identify the main benefit

   This avoids restarting services, preventing downtime and improving flexibility.

3. Final Answer:

   Change service settings without restarting or downtime -> Option B

4. Quick Check:

   Dynamic config = no downtime updates [OK]

Hint: Dynamic config means no restart needed for changes [OK]

Common Mistakes:

• Confusing dynamic config with scaling services
• Thinking it reduces container size
• Assuming it encrypts communication automatically

2. Which of the following is a common method for microservices to receive dynamic configuration updates?

easy

A. Polling a central configuration server periodically

B. Hardcoding config values in source code

C. Restarting the service every hour

D. Using static environment variables only

Solution

1. Step 1: Review methods for dynamic config updates

   Common methods include polling or push from a central config server.

2. Step 2: Identify the correct method

   Polling a config server lets services fetch updates regularly without restart.

3. Final Answer:

   Polling a central configuration server periodically -> Option A

4. Quick Check:

   Polling config server = dynamic updates [OK]

Hint: Dynamic config needs active update fetching, not static values [OK]

Common Mistakes:

• Thinking hardcoded values can update dynamically
• Assuming restart is needed for updates
• Believing static env vars update automatically

3. Consider this pseudocode for a microservice fetching config updates:

config = load_config()
while True:
    if config_server.has_update():
        config = config_server.get_update()
    sleep(10)
    print(config['feature_flag'])

What will this code do when the feature_flag changes on the config server?

medium

A. Print the old feature_flag value forever

B. Crash because config_server.has_update() is undefined

C. Print nothing because of missing initial config

D. Update and print the new feature_flag value every 10 seconds

Solution

1. Step 1: Analyze the update check loop

   The code checks if the config server has an update, then fetches it.

2. Step 2: Understand the print behavior

   Every 10 seconds it prints the current feature_flag from the updated config.

3. Final Answer:

   Update and print the new feature_flag value every 10 seconds -> Option D

4. Quick Check:

   Polling loop updates config = prints new value [OK]

Hint: Polling loop updates config then prints latest value [OK]

Common Mistakes:

• Assuming config never updates after initial load
• Thinking code crashes due to undefined methods (assumed defined)
• Ignoring the sleep and print inside the loop

4. A microservice uses a push-based config update system but sometimes misses updates. What is a likely cause?

medium

A. The service does not acknowledge receipt of updates

B. The service polls the config server too frequently

C. The service restarts after every update

D. The config server uses static environment variables

Solution

1. Step 1: Understand push-based config update mechanism

   Push systems send updates and expect acknowledgments to confirm delivery.

2. Step 2: Identify why updates are missed

   If the service does not acknowledge, the server may not resend or confirm updates.

3. Final Answer:

   The service does not acknowledge receipt of updates -> Option A

4. Quick Check:

   Missing ack = missed updates in push system [OK]

Hint: Push updates need acknowledgments to avoid missing data [OK]

Common Mistakes:

• Confusing push with polling frequency issues
• Assuming restarts cause missed updates
• Thinking static env vars relate to push update failures

5. You design a microservices system with dynamic config updates using a central config server. To ensure minimal latency and high availability, which approach is best?

hard

A. Embed config in each service and restart services on config change

B. Use a single config server with clients polling every second

C. Deploy multiple config server replicas with push notifications and local caching

D. Use static config files updated manually on each service host

Solution

1. Step 1: Consider latency and availability needs

   Multiple replicas reduce single points of failure and improve response times.

2. Step 2: Evaluate update delivery methods

   Push notifications with local caching reduce latency and avoid constant polling.

3. Final Answer:

   Deploy multiple config server replicas with push notifications and local caching -> Option C

4. Quick Check:

   Replicas + push + cache = low latency & high availability [OK]

Hint: Replicas + push + cache = best for latency and availability [OK]

Common Mistakes:

• Relying on single server causes downtime
• Polling every second wastes resources
• Restarting services causes downtime
• Manual static updates are error-prone and slow