YAML avec Rust : bibliothèque serde_yaml

Bibliothèque serde_yaml : manipuler YAML en Rust

YAML (YAML Ain't Markup Language) est l'un des formats de sérialisation de données les plus populaires, largement utilisé pour les fichiers de configuration, la description de structures de données et l'échange d'informations entre services. Dans l'écosystème Rust, la bibliothèque mature et performante serde_yaml, construite sur le puissant framework de sérialisation serde, permet de travailler avec YAML. Dans cet article, nous allons voir en détail comment analyser, créer et traiter des documents YAML en Rust.

Installation et configuration

Pour commencer, ajoutez les dépendances suivantes à votre fichier Cargo.toml :

[dependencies]
serde = { version = "1.0", features = ["derive"] }
serde_yaml = "0.9"

La bibliothèque serde_yaml inclut automatiquement tous les composants nécessaires pour l'analyse et la génération de YAML.

Désérialisation de base (YAML → structure Rust)

Le scénario le plus courant est la lecture d'un fichier de configuration. Définissons une structure qui correspond au document YAML :

use serde::Deserialize;

#[derive(Debug, Deserialize)]
struct Config {
    server: ServerConfig,
    database: DatabaseConfig,
}

#[derive(Debug, Deserialize)]
struct ServerConfig {
    host: String,
    port: u16,
    workers: Option<u32>,
}

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

Lisons maintenant le fichier YAML et transformons-le en structure :

use std::fs;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let yaml_content = fs::read_to_string("config.yaml")?;
    let config: Config = serde_yaml::from_str(&yaml_content)?;
    
    println!("Serveur : {}:{}", config.server.host, config.server.port);
    println!("Base de données : {}", config.database.url);
    
    Ok(())
}

Exemple de fichier config.yaml :

server:
  host: "127.0.0.1"
  port: 8080
  workers: 4
database:
  url: "postgres://user:pass@localhost/db"
  pool_size: 10

Sérialisation (structure Rust → YAML)

Le processus inverse consiste à créer un document YAML à partir de données en mémoire :

use serde::Serialize;

#[derive(Debug, Serialize)]
struct Project {
    name: String,
    version: String,
    dependencies: Vec<Dependency>,
}

#[derive(Debug, Serialize)]
struct Dependency {
    name: String,
    version: String,
    optional: bool,
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let project = Project {
        name: "mon-app".to_string(),
        version: "0.1.0".to_string(),
        dependencies: vec![
            Dependency {
                name: "serde".to_string(),
                version: "1.0".to_string(),
                optional: false,
            },
            Dependency {
                name: "tokio".to_string(),
                version: "1.35".to_string(),
                optional: true,
            },
        ],
    };

    let yaml_string = serde_yaml::to_string(&project)?;
    println!("{}", yaml_string);
    
    // Sauvegarde dans un fichier
    std::fs::write("project.yaml", &yaml_string)?;
    
    Ok(())
}

Manipulation de documents YAML arbitraires

Parfois, la structure YAML n'est pas connue à l'avance. Dans ce cas, utilisez serde_yaml::Value :

use serde_yaml::Value;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let yaml_data = "
apiVersion: v1
kind: Service
metadata:
  name: mon-service
  labels:
    app: web
spec:
  ports:
    - port: 80
      targetPort: 8080
  selector:
    app: web
";
    
    let value: Value = serde_yaml::from_str(yaml_data)?;
    
    // Accès aux données imbriquées
    if let Some(ports) = value["spec"]["ports"].as_sequence() {
        for port in ports {
            if let Some(port_num) = port["port"].as_u64() {
                println!("Port : {}", port_num);
            }
        }
    }
    
    // Modification