Bird
Raised Fist0
Microservicessystem_design~10 mins

Config server pattern in Microservices - Interactive Code Practice

Choose your learning style10 modes available

Start learning this pattern below

Jump into concepts and practice - no test required

or
Recommended
Test this pattern10 questions across easy, medium, and hard to know if this pattern is strong
Practice - 5 Tasks
Answer the questions below
1fill in blank
easy

Complete the code to define the central configuration server URL.

Microservices
configServerUrl = "http://[1]:8888"
Drag options to blanks, or click blank then click option'
Adatabase
Blocalhost
Cconfig-server
Dservice-registry
Attempts:
3 left
💡 Hint
Common Mistakes
Using 'localhost' instead of the config server name.
Confusing the config server with the service registry.
2fill in blank
medium

Complete the code to fetch configuration from the config server using HTTP GET.

Microservices
response = httpClient.get(f"http://config-server:8888/[1]/default")
Drag options to blanks, or click blank then click option'
Aservice-name
Benvironment
Cconfig
Dapplication
Attempts:
3 left
💡 Hint
Common Mistakes
Using 'service-name' which is not the standard path segment.
Using 'environment' which is usually a separate path segment.
3fill in blank
hard

Fix the error in the config client code to reload configuration on startup.

Microservices
def load_config():
    config = fetch_config_from_server()
    if config is None:
        raise [1]("Config not found")
    return config
Drag options to blanks, or click blank then click option'
ARuntimeError
BValueError
CConfigError
DKeyError
Attempts:
3 left
💡 Hint
Common Mistakes
Using ValueError which is for invalid values, not missing config.
Using KeyError which is for missing dictionary keys.
4fill in blank
hard

Fill both blanks to complete the config server's response handling code.

Microservices
if response.status_code == 200:
    config_data = response.[1]()
else:
    log.error("Failed to fetch config: " + response.[2])
Drag options to blanks, or click blank then click option'
Ajson
Btext
Ccontent
Dstatus_code
Attempts:
3 left
💡 Hint
Common Mistakes
Using content which returns bytes, not parsed data.
Using status_code which is an integer, not a message.
5fill in blank
hard

Fill all three blanks to complete the microservice config client initialization code.

Microservices
class ConfigClient:
    def __init__(self, [1]):
        self.server_url = [2]
        self.config = self.[3]()

    def fetch_config(self):
        # fetch config logic here
        pass
Drag options to blanks, or click blank then click option'
Aserver_url
Bload_config
Cconfig_server_url
Dfetch_config
Attempts:
3 left
💡 Hint
Common Mistakes
Confusing parameter and attribute names.
Calling 'fetch_config' instead of 'load_config' in constructor.

Practice

(1/5)
1. What is the main purpose of the Config Server Pattern in microservices architecture?
easy
A. To manage database connections for microservices
B. To centralize configuration management for multiple microservices
C. To handle user authentication and authorization
D. To balance load between microservices

Solution

  1. Step 1: Understand the role of configuration in microservices

    Each microservice needs configuration settings like URLs, credentials, and feature flags.
  2. Step 2: Identify what the Config Server Pattern provides

    The pattern centralizes these settings in one place, so all microservices can fetch consistent configs.
  3. Final Answer:

    To centralize configuration management for multiple microservices -> Option B
  4. Quick Check:

    Config Server Pattern = Centralized config [OK]
Hint: Config Server centralizes configs, not user or load tasks [OK]
Common Mistakes:
  • Confusing config management with authentication
  • Thinking it manages database connections
  • Assuming it balances load
2. Which of the following is the correct way for a microservice to fetch configuration from a Config Server?
easy
A. Microservice sends HTTP requests to Config Server to get configs
B. Microservice reads local config files only
C. Microservice uses database queries to fetch configs
D. Microservice uses message queues to receive configs

Solution

  1. Step 1: Identify communication method with Config Server

    Config Server usually exposes REST APIs for microservices to request configs.
  2. Step 2: Match options with typical Config Server usage

    HTTP requests are the standard way; local files, DB queries, or message queues are not typical for config fetching.
  3. Final Answer:

    Microservice sends HTTP requests to Config Server to get configs -> Option A
  4. Quick Check:

    Config Server uses HTTP requests [OK]
Hint: Config Server serves configs via HTTP, not local files or DB [OK]
Common Mistakes:
  • Assuming configs come from local files only
  • Thinking configs are fetched via database queries
  • Confusing message queues with config delivery
3. Consider this simplified flow:
1. Microservice starts
2. Requests config from Config Server
3. Config Server returns config
4. Microservice uses config to connect to DB

What happens if the Config Server is down when the microservice starts?
medium
A. Microservice connects to DB without any config
B. Microservice automatically generates default config and continues
C. Microservice uses cached config or fails to start if none available
D. Microservice waits indefinitely for Config Server to respond

Solution

  1. Step 1: Understand Config Server availability impact

    If Config Server is down, microservice cannot fetch fresh config at startup.
  2. Step 2: Consider typical microservice behavior

    Most microservices cache last known config or fail to start if no config is available.
  3. Final Answer:

    Microservice uses cached config or fails to start if none available -> Option C
  4. Quick Check:

    Config Server down = use cache or fail [OK]
Hint: Microservices rely on cached config if Config Server is unreachable [OK]
Common Mistakes:
  • Assuming microservice generates default config automatically
  • Thinking microservice connects without config
  • Believing microservice waits forever
4. A developer notices that after updating configuration in the Config Server, microservices do not reflect changes immediately. What is the most likely cause?
medium
A. Microservices cache old config and need refresh or restart
B. Config Server failed to save the new config
C. Microservices do not support external config fetching
D. Network issues prevent microservices from reaching Config Server

Solution

  1. Step 1: Analyze why config changes are not reflected

    Microservices often cache configs to avoid frequent calls to Config Server.
  2. Step 2: Identify common cause for stale configs

    Without refresh or restart, microservices keep using cached old configs.
  3. Final Answer:

    Microservices cache old config and need refresh or restart -> Option A
  4. Quick Check:

    Config changes need refresh to apply [OK]
Hint: Config changes require microservice refresh to apply [OK]
Common Mistakes:
  • Assuming Config Server did not save changes
  • Thinking microservices ignore external configs
  • Blaming network without checking cache
5. You are designing a Config Server for a large microservices system with hundreds of services. Which approach best ensures scalability and security?
hard
A. Embed configs inside each microservice and update by redeploying services
B. Use a single database table for all configs without encryption
C. Store configs in a public Git repository without access control
D. Use a centralized Config Server with versioned configs, secure access, and caching at clients

Solution

  1. Step 1: Consider scalability needs

    Centralized Config Server with versioning and caching reduces load and supports many services efficiently.
  2. Step 2: Consider security best practices

    Secure access and encryption protect sensitive configs; public repos or unencrypted DB tables are unsafe.
  3. Final Answer:

    Use a centralized Config Server with versioned configs, secure access, and caching at clients -> Option D
  4. Quick Check:

    Scalable & secure config = centralized + versioning + security [OK]
Hint: Centralize configs with security and caching for scale [OK]
Common Mistakes:
  • Embedding configs in services causes redeploy overhead
  • Using public repos exposes sensitive data
  • Storing unencrypted configs risks security breaches