配置管理

概述

Silent框架提供了灵活的配置管理机制，本章节将介绍如何有效地管理应用程序的配置。

配置方式

环境变量

使用环境变量进行配置是最常见的方式：

use std::env;

// 读取环境变量
let port = env::var("SERVER_PORT").unwrap_or("8080".to_string());
let database_url = env::var("DATABASE_URL").expect("DATABASE_URL must be set");

配置文件

使用配置文件可以更好地组织配置项：

use serde::Deserialize;
use std::fs;

#[derive(Deserialize)]
struct Config {
    server: ServerConfig,
    database: DatabaseConfig,
    redis: Option<RedisConfig>,
}

#[derive(Deserialize)]
struct ServerConfig {
    port: u16,
    host: String,
}

#[derive(Deserialize)]
struct DatabaseConfig {
    url: String,
    max_connections: u32,
}

// 加载配置文件
let config: Config = toml::from_str(
    &fs::read_to_string("config.toml").expect("Failed to read config file")
).expect("Failed to parse config");

配置管理最佳实践

分环境配置

为不同环境维护不同的配置：

use std::env;

pub enum Environment {
    Development,
    Production,
    Testing,
}

impl Environment {
    pub fn from_env() -> Self {
        match env::var("APP_ENV").unwrap_or_default().as_str() {
            "production" => Environment::Production,
            "testing" => Environment::Testing,
            _ => Environment::Development,
        }
    }

    pub fn get_config_path(&self) -> &'static str {
        match self {
            Environment::Development => "config/development.toml",
            Environment::Production => "config/production.toml",
            Environment::Testing => "config/testing.toml",
        }
    }
}

配置验证

使用类型系统进行配置验证：

use serde::Deserialize;
use std::net::SocketAddr;

#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ServerConfig {
    #[serde(default = "default_port")]
    pub port: u16,
    #[serde(default = "default_host")]
    pub host: String,
    pub workers: Option<usize>,
}

impl ServerConfig {
    pub fn socket_addr(&self) -> SocketAddr {
        format!("{}{}", self.host, self.port)
            .parse()
            .expect("Invalid host or port")
    }

    pub fn validate(&self) -> Result<(), String> {
        if self.port < 1024 {
            return Err("Port must be >= 1024".to_string());
        }
        Ok(())
    }
}

fn default_port() -> u16 { 8080 }
fn default_host() -> String { "127.0.0.1".to_string() }

配置热重载

实现配置热重载功能：

use std::sync::Arc;
use tokio::sync::RwLock;

pub struct ConfigManager {
    config: Arc<RwLock<Config>>,
}

impl ConfigManager {
    pub async fn reload_config(&self) -> Result<(), Box<dyn std::error::Error>> {
        let new_config = Config::load_from_file("config.toml")?;
        let mut config = self.config.write().await;
        *config = new_config;
        Ok(())
    }

    pub async fn get_config(&self) -> Arc<RwLock<Config>> {
        self.config.clone()
    }
}

敏感信息处理

密钥管理

安全地处理敏感配置信息：

use std::env;

pub struct Secrets {
    api_key: String,
    database_password: String,
}

impl Secrets {
    pub fn from_env() -> Self {
        Self {
            api_key: env::var("API_KEY")
                .expect("API_KEY must be set"),
            database_password: env::var("DB_PASSWORD")
                .expect("DB_PASSWORD must be set"),
        }
    }
}

配置使用示例

应用配置整合

use silent::prelude::*;

#[tokio::main]
async fn main() {
    // 加载配置
    let config = Config::from_env();
    
    // 创建应用
    let app = Route::new("")
        .hook(ExceptionHandler::new())
        .get("/", |_| async { Ok("Hello World") });

    // 使用配置启动服务器
    Server::new()
        .bind(config.server.socket_addr())
        .worker_threads(config.server.workers.unwrap_or_else(num_cpus::get))
        .run(app)
        .await;
}

最佳实践总结

1. 类型安全：使用强类型系统管理配置

2. 环境隔离：为不同环境维护独立配置

3. 默认值：为配置项提供合理的默认值

4. 验证：在启动时验证配置有效性

5. 文档化：详细记录配置项的用途和约束

6. 安全性：妥善处理敏感配置信息

通过遵循这些配置管理最佳实践，您可以更好地管理应用程序的配置，提高系统的可维护性和安全性。