Configuration Management

Configuration management means separating configuration from code so the same code runs in different environments.

Why Externalize Configuration?

Development → localhost:5432, debug=true, log=DEBUG
Staging     → staging-db:5432, debug=false, log=INFO
Production  → prod-db:5432, debug=false, log=WARN

You don't want to change code for each environment. Spring makes this easy.

application.yml (Primary Config)

# application.yml
server:
  port: 8080

spring:
  datasource:
    url: jdbc:postgresql://localhost:5432/mydb
    username: ${DB_USERNAME:postgres}
    password: ${DB_PASSWORD:password}
  jpa:
    hibernate:
      ddl-auto: validate
    show-sql: false

app:
  jwt:
    secret: ${JWT_SECRET:myDefaultSecret}
    expiration: 86400000

logging:
  level:
    root: INFO
    com.example: DEBUG

Profile-Specific Configuration

# application-dev.yml (Development)
spring:
  datasource:
    url: jdbc:postgresql://localhost:5432/mydb_dev
  jpa:
    show-sql: true
    hibernate:
      ddl-auto: create-drop

logging:
  level:
    com.example: DEBUG

---
# application-prod.yml (Production)
spring:
  datasource:
    url: jdbc:postgresql://prod-db:5432/mydb
  jpa:
    show-sql: false
    hibernate:
      ddl-auto: validate

logging:
  level:
    root: WARN
    com.example: INFO

Activating Profiles

# Via command line
java -jar app.jar --spring.profiles.active=prod

# Via environment variable
SPRING_PROFILES_ACTIVE=prod java -jar app.jar

# In application.yml
spring:
  profiles:
    active: dev

@ConfigurationProperties (Type-Safe Config)

@ConfigurationProperties(prefix = "app.jwt")
public class JwtProperties {
    private String secret;
    private long expiration;
    private String issuer;

    // Getters and Setters
}

@Configuration
@EnableConfigurationProperties(JwtProperties.class)
public class AppConfig {
}

Key Principles

1. Follow SOLID principles
2. Write clean, readable code
3. Test thoroughly
4. Document decisions
5. Monitor in production

Implementation

• Start simple, refactor as needed
• Use established patterns
• Consider trade-offs
• Review with peers

Continuous Improvement

• Learn from incidents
• Update documentation
• Share knowledge
• Mentor others

Key Points

• Understanding Configuration Management is essential for production systems
• Always consider scalability and maintainability
• Test thoroughly before deploying to production
• Monitor performance and set up alerting

Common Patterns

1. Validation: Always validate input at the boundary
2. Error Handling: Use structured error responses
3. Logging: Log key events for debugging
4. Testing: Unit, integration, and load tests
5. Documentation: Keep docs updated with code changes