Why externalized config enables flexibility in Microservices - Design It to Understand It

Design: Externalized Configuration Management in Microservices

Focus on design of externalized configuration system and its integration with microservices. Out of scope: detailed security encryption algorithms, UI for config management.

Functional Requirements

FR1: Allow microservices to load configuration settings at runtime

FR2: Enable configuration changes without redeploying services

FR3: Support different configurations per environment (dev, test, prod)

FR4: Provide secure storage and access control for sensitive config data

FR5: Allow dynamic updates to configuration with minimal downtime

Non-Functional Requirements

NFR1: Configuration fetch latency should be under 100ms

NFR2: System must handle 1000+ microservices fetching configs concurrently

NFR3: Availability of config service should be 99.9%

NFR4: Configuration data size per service should be under 1MB

Think Before You Design

Questions to Ask

❓ Question 1

❓ Question 2

❓ Question 3

❓ Question 4

❓ Question 5

Key Components

Centralized configuration server or service

Configuration storage (database, key-value store)

Client libraries or agents in microservices to fetch and refresh config

Cache layer to reduce load and latency

Access control and audit logging

Design Patterns

Configuration as a Service

Cache-Aside pattern for config caching

Publish-Subscribe for config change notifications

Circuit Breaker pattern for config service failures

Secrets management integration

Reference Architecture

          +---------------------+
          |  Configuration Store |
          |  (e.g., Consul, etcd) |
          +----------+----------+
                     |
          +----------v----------+
          | Configuration Server |
          | (API + Auth + Cache) |
          +----------+----------+
                     |
       +-------------+-------------+
       |                           |
+------v------+             +------v------+
| Microservice|             | Microservice|
|  Instance 1 |             |  Instance 2 |
+-------------+             +-------------+
       |                           |
       +-----------+---------------+
                   |
          +--------v---------+
          | Config Client Lib |
          +------------------+

Components

Configuration Store

Consul, etcd, or ZooKeeper

Stores all configuration data centrally with versioning and consistency guarantees

Configuration Server

REST API service with caching layer

Provides secure, authenticated access to configuration data for microservices

Config Client Library

Lightweight client SDK in each microservice

Fetches configuration from server, caches locally, refreshes on changes

Cache Layer

In-memory cache (e.g., Redis or local memory)

Reduces latency and load on configuration store by caching config data

Access Control & Audit

Role-based access control and logging

Secures sensitive config data and tracks changes

Request Flow

1. Microservice starts and calls Config Client Library to fetch configuration.

2. Client library sends authenticated request to Configuration Server API.

3. Configuration Server checks cache; if miss, fetches from Configuration Store.

4. Configuration Server returns config data to client library.

5. Client library caches config locally and provides it to microservice.

6. When config changes, Configuration Server notifies clients via pub-sub or clients poll periodically.

7. Clients refresh local cache with updated config without restarting service.

Database Schema

Entities: - ConfigurationItem: id, key, value, version, environment, service_name, is_secret - Service: id, name, owner - AccessControlEntry: id, service_id, permission_type Relationships: - One Service has many ConfigurationItems - AccessControlEntry links Services to permissions on ConfigurationItems

Scaling Discussion

Bottlenecks

Configuration Server API becomes overloaded with many microservices fetching config simultaneously

Cache invalidation delays cause stale config usage

Configuration Store write/read throughput limits

Network latency impacts config fetch times

Security risks if access control is weak

Solutions

Add horizontal scaling and load balancing for Configuration Server

Use efficient pub-sub or event-driven updates for cache invalidation

Partition configuration data and use distributed stores for scalability

Deploy config servers closer to microservices (regional caches)

Implement strict authentication, encryption, and audit logging

Interview Tips

Time: Spend 10 minutes understanding requirements and clarifying scope, 20 minutes designing architecture and data flow, 10 minutes discussing scaling and trade-offs, 5 minutes summarizing.

Explain why externalizing config avoids redeployments and enables dynamic updates

Discuss how caching reduces latency and load

Highlight security considerations for sensitive config data

Describe how pub-sub or polling keeps configs fresh

Mention scaling strategies for high availability and performance