Demarrage rapide

English | 中文 | 日本語 | 한국어 | Français | Deutsch | Español | Português | Svenska | Suomi | Nederlands

Ajoutez la crate et les bibliotheques de schema/execution utilisees par votre application :

[dependencies]
rust-config-tree = "0.2"
confique = { version = "0.4", features = ["yaml", "toml", "json5"] }
figment = { version = "0.10", features = ["yaml", "toml", "json", "env"] }
schemars = { version = "1", features = ["derive"] }
serde = { version = "1", features = ["derive"] }
clap = { version = "4", features = ["derive"] }

Definissez un schema confique et implementez ConfigSchema pour le type racine :

#![allow(unused)]
fn main() {
use std::path::PathBuf;

use confique::Config;
use rust_config_tree::ConfigSchema;

#[derive(Debug, Config)]
struct AppConfig {
    #[config(default = [])]
    include: Vec<PathBuf>,

    #[config(nested)]
    server: ServerConfig,
}

#[derive(Debug, Config)]
struct ServerConfig {
    #[config(default = "127.0.0.1")]
    #[config(env = "APP_SERVER_BIND")]
    bind: String,

    #[config(default = 8080)]
    #[config(env = "APP_SERVER_PORT")]
    port: u16,
}

impl ConfigSchema for AppConfig {
    fn include_paths(layer: &<Self as Config>::Layer) -> Vec<PathBuf> {
        layer.include.clone().unwrap_or_default()
    }
}
}

Chargez la configuration :

#![allow(unused)]
fn main() {
use rust_config_tree::load_config;

let config = load_config::<AppConfig>("config.yaml")?;
println!("{config:#?}");
Ok::<(), Box<dyn std::error::Error + Send + Sync>>(())
}

Utilisez un fichier racine avec des inclusions recursives :

# config.yaml
include:
  - config/server.yaml

# config/server.yaml
server:
  bind: 0.0.0.0
  port: 3000

La priorite par defaut de load_config est :

environment variables
  > config files, with later merged files overriding earlier files
    > confique code defaults

Lorsque les inclusions sont chargees par l’API de haut niveau, le fichier racine a la priorite de fichier la plus elevee. Les fichiers inclus fournissent des valeurs de priorite plus faible et peuvent servir de valeurs par defaut ou de fichiers propres a une section.

Les arguments de ligne de commande sont propres a chaque application, donc load_config ne les lit pas automatiquement. Fusionnez les remplacements CLI apres build_config_figment lorsque l’application possede des drapeaux de remplacement de configuration :

Les arguments de ligne de commande sont propres a chaque application, donc load_config ne les lit pas automatiquement. Utilisez la macro derivee ConfigOverrides pour construire un fournisseur de remplacement a partir des drapeaux CLI analyses :

#![allow(unused)]
fn main() {
use clap::Parser;
use rust_config_tree::{
    ConfigSchema,
    cli::ConfigOverrides,
    config::{build_config_figment, load_config_from_figment},
};

#[derive(Debug, Parser, ConfigOverrides)]
struct Cli {
    #[arg(long)]
    config: Option<std::path::PathBuf>,

    #[arg(long)]
    #[config_override(path = "server.port")]
    server_port: Option<u16>,

    #[arg(long)]
    #[config_override(path = "log.level")]
    log_level: Option<String>,
}

let cli = Cli::parse();
let figment = build_config_figment::<AppConfig>("config.yaml")?
    .merge(cli.config_overrides()?);
let config = load_config_from_figment::<AppConfig>(&figment)?;
let _ = config;
Ok::<(), Box<dyn std::error::Error + Send + Sync>>(())
}

L’attribut #[config_override(path = "...")] mappe chaque drapeau CLI vers un chemin de configuration pointille. Seuls les drapeaux fournis produisent des valeurs de remplacement ; les drapeaux omis disparaissent. Le fournisseur de remplacement est fusionne en dernier, donc les drapeaux fournis remplacent les valeurs des fichiers et de l’environnement :

command-line overrides
  > environment variables
    > config files
      > confique code defaults