Какие знаешь способы хранения значений внешних конфигураций?

Способы хранения значений внешних конфигураций

Внешние конфигурации отделяют код от изменяемых параметров. Это критично для разных окружений (dev, test, prod). Расскажу о различных подходах и лучших практиках.

1. application.properties

Самый простой встроенный способ в Spring.

# application.properties
spring.application.name=prepbro
spring.jpa.database-platform=org.hibernate.dialect.PostgreSQL10Dialect

# Кастомные параметры
app.name=Prepbro
app.version=1.0.0
app.description=Interview Preparation Platform

# Настройки БД
spring.datasource.url=jdbc:postgresql://localhost:5432/prepbro
spring.datasource.username=postgres
spring.datasource.password=password

# Безопасность
app.security.jwt.secret=${JWT_SECRET:default-secret-key}
app.security.jwt.expiration=3600000

# Email
app.email.from=noreply@prepbro.ru
app.email.host=smtp.example.com
app.email.port=587

Использование в коде:

@Component
public class AppProperties {
    @Value("${app.name}")
    private String appName;
    
    @Value("${app.version:0.0.0}") // с дефолтным значением
    private String version;
    
    @Value("${JWT_SECRET:secret}") // из переменной окружения
    private String jwtSecret;
}

2. application.yml (YAML)

Более читаемый формат, особенно для сложных структур.

# application.yml
spring:
  application:
    name: prepbro
  jpa:
    database-platform: org.hibernate.dialect.PostgreSQL10Dialect
    hibernate:
      ddl-auto: validate
  datasource:
    url: jdbc:postgresql://localhost:5432/prepbro
    username: ${DB_USERNAME:postgres}
    password: ${DB_PASSWORD:password}
    hikari:
      maximum-pool-size: 20
      minimum-idle: 5
  redis:
    host: ${REDIS_HOST:localhost}
    port: ${REDIS_PORT:6379}

app:
  name: Prepbro
  version: 1.0.0
  security:
    jwt:
      secret: ${JWT_SECRET}
      expiration: 3600000
  email:
    from: noreply@prepbro.ru
    host: ${SMTP_HOST}
    port: ${SMTP_PORT}
  features:
    enable-analytics: true
    enable-notifications: true

Использование в коде:

@Configuration
@ConfigurationProperties(prefix = "app")
public class AppConfig {
    private String name;
    private String version;
    private Security security = new Security();
    private Email email = new Email();
    private Features features = new Features();
    
    // getters/setters
    
    @Configuration
    @Data
    public static class Security {
        private Jwt jwt = new Jwt();
        
        @Data
        public static class Jwt {
            private String secret;
            private long expiration;
        }
    }
    
    @Configuration
    @Data
    public static class Email {
        private String from;
        private String host;
        private int port;
    }
    
    @Configuration
    @Data
    public static class Features {
        private boolean enableAnalytics;
        private boolean enableNotifications;
    }
}

3. Environment Properties

Чтение из переменных окружения OS.

@Service
public class ConfigService {
    @Autowired
    private Environment env;
    
    public String getDatabaseUrl() {
        return env.getProperty("DATABASE_URL", 
            "jdbc:postgresql://localhost:5432/prepbro");
    }
    
    public boolean isProductionMode() {
        return env.getProperty("ENVIRONMENT", "dev")
            .equals("production");
    }
    
    public String getSecretKey() {
        String secret = env.getProperty("SECRET_KEY");
        if (secret == null) {
            throw new IllegalStateException("SECRET_KEY не установлен");
        }
        return secret;
    }
}

4. Profile-specific configurations

Разные конфиги для разных окружений.

src/main/resources/
├── application.yml              # общие параметры
├── application-dev.yml          # для dev
├── application-test.yml         # для test
└── application-prod.yml         # для prod

# application.yml (общее)
spring:
  profiles:
    active: ${SPRING_PROFILE:dev}

app:
  name: Prepbro

---
# application-dev.yml
spring:
  config:
    activate:
      on-profile: dev
  datasource:
    url: jdbc:postgresql://localhost:5432/prepbro_dev
    username: dev_user
    password: dev_password
  jpa:
    hibernate:
      ddl-auto: create-drop

app:
  debug: true
  features:
    enable-analytics: false

---
# application-prod.yml
spring:
  config:
    activate:
      on-profile: prod
  datasource:
    url: ${DATABASE_URL}
    username: ${DB_USERNAME}
    password: ${DB_PASSWORD}
  jpa:
    hibernate:
      ddl-auto: validate

app:
  debug: false
  features:
    enable-analytics: true

Использование:

java -jar app.jar --spring.profiles.active=prod

# Или через переменную окружения
export SPRING_PROFILE=prod
java -jar app.jar

5. ConfigMap и Secrets в Kubernetes

Для контейнеризованных приложений.

# configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
  name: prepbro-config
data:
  application.yml: |
    app:
      name: Prepbro
      version: "1.0.0"
    spring:
      datasource:
        url: jdbc:postgresql://postgres-service:5432/prepbro
      jpa:
        hibernate:
          ddl-auto: validate

---
# secrets.yaml
apiVersion: v1
kind: Secret
metadata:
  name: prepbro-secrets
type: Opaque
stringData:
  DB_PASSWORD: actual-password-here
  JWT_SECRET: secret-jwt-key
  SMTP_PASSWORD: email-password

Использование в Deployment:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: prepbro-app
spec:
  containers:
  - name: prepbro
    image: prepbro:1.0.0
    envFrom:
    - configMapRef:
        name: prepbro-config
    - secretRef:
        name: prepbro-secrets
    volumeMounts:
    - name: config
      mountPath: /etc/config
  volumes:
  - name: config
    configMap:
      name: prepbro-config

6. Consul для распределённых систем

Centralized configuration management.

@Configuration
@EnableConsulConfigServer
public class ConsulConfig {
    // Spring автоматически подгружает config из Consul
}

@RestController
@RequestMapping("/config")
public class ConfigController {
    @Autowired
    private Environment env;
    
    @GetMapping("/database-url")
    public String getDatabaseUrl() {
        return env.getProperty("app.datasource.url");
    }
}

7. Spring Cloud Config Server

Централизованное управление конфигурацией.

// Config Server
@SpringBootApplication
@EnableConfigServer
public class ConfigServerApplication {
    public static void main(String[] args) {
        SpringApplication.run(ConfigServerApplication.class, args);
    }
}

// application.yml для Config Server
spring:
  cloud:
    config:
      server:
        git:
          uri: https://github.com/example/config-repo
          default-label: main
          search-paths: configs/{application}

// Client приложение
@SpringBootApplication
public class ClientApplication {
    public static void main(String[] args) {
        SpringApplication.run(ClientApplication.class, args);
    }
}

// bootstrap.yml
spring:
  cloud:
    config:
      uri: http://config-server:8888
      name: prepbro
      profile: prod

8. Env файлы (для локальной разработки)

Используем spring-boot-dotenv или аналог.

# .env файл
DATABASE_URL=jdbc:postgresql://localhost:5432/prepbro
DB_USERNAME=dev
DB_PASSWORD=dev_password
JWT_SECRET=my-secret-key-dev
REDIS_HOST=localhost
REDIS_PORT=6379
SMTP_HOST=smtp.mailtrap.io
SMTP_PORT=2525

// Загружаем .env в начале приложения
@Configuration
public class EnvConfig {
    static {
        try {
            DotEnv dotEnv = DotEnv.load();
        } catch (Exception e) {
            // .env может не существовать в prod
        }
    }
}

9. System Properties

Для программного задания конфигурации.

public class SystemPropertyConfig {
    static {
        System.setProperty("spring.jpa.database-platform", 
            "org.hibernate.dialect.PostgreSQL10Dialect");
        System.setProperty("spring.datasource.url", 
            "jdbc:postgresql://localhost:5432/prepbro");
    }
}

// Или через Java code
properties = new Properties();
properties.load(new FileInputStream("config.properties"));
properties.forEach((k, v) -> System.setProperty(k.toString(), v.toString()));

10. YAML конфигурация с профилями

Комбо подход для сложных приложений.

# application.yml
spring:
  profiles:
    include:
      - database
      - security
      - external-services
  config:
    import: optional:configserver:http://localhost:8888

app:
  version: 1.0.0

---
# application-database.yml
spring:
  config:
    activate:
      on-profile: database
  datasource:
    hikari:
      maximum-pool-size: 20
      minimum-idle: 5

---
# application-security.yml  
spring:
  config:
    activate:
      on-profile: security
security:
  jwt:
    secret: ${JWT_SECRET}
    expiration: 3600000

---
# application-external-services.yml
spring:
  config:
    activate:
      on-profile: external-services
app:
  api:
    stripe:
      key: ${STRIPE_KEY}
    email:
      api-key: ${EMAIL_API_KEY}

Лучшие практики

// ✅ Правильно — типобезопасно
@ConfigurationProperties(prefix = "app")
@Validated
@Data
public class AppProperties {
    @NotNull
    private String name;
    
    @Min(0)
    @Max(3600000)
    private long jwtExpiration;
    
    @Email
    private String adminEmail;
}

// ❌ Неправильно — строковые значения везде
@Value("${some.config}")
private String value;

// ✅ С дефолтами и валидацией
@Value("${app.timeout:5000}")
private int timeout;

// ❌ Hardcoded значения
private String databaseUrl = "jdbc:postgresql://localhost:5432/db";

Приоритет источников конфигурации (от высшего к низшему)

1. Параметры командной строки (самый высокий приоритет)
2. Переменные окружения OS
3. .env файл
4. System properties
5. application-{profile}.yml
6. application.yml
7. application.properties
8. Дефолтные значения в коде (самый низкий приоритет)

Сравнение методов

Заключение

Для локальной разработки используй .env или application-dev.yml. Для production используй переменные окружения или Kubernetes ConfigMap/Secrets. Никогда не коммитай sensitive данные в код.