Client Elasticsearch pour Rust : bibliothèque officielle elasticsearch-rs

Client Elasticsearch pour Rust : elasticsearch-rs

elasticsearch-rs est le client asynchrone officiel pour interagir avec Elasticsearch depuis l'écosystème Rust. La bibliothèque fournit un ensemble complet d'outils pour travailler avec le moteur de recherche : des opérations CRUD simples aux agrégations complexes et aux requêtes bulk. Développée et maintenue par l'équipe Elastic, elle garantit l'actualité de l'API et la compatibilité avec les dernières versions d'Elasticsearch.

Fonctionnalités clés

• Prise en charge complète de l'API Elasticsearch — indexation, recherche, agrégations, gestion des index, du mapping et des paramètres du cluster.
• Asynchrone — construite sur tokio et reqwest, permettant de traiter des milliers de requêtes sans bloquer les threads.
• Sécurité de type — toutes les requêtes et réponses sont strictement typées, les erreurs de validation sont détectées à la compilation.
• Prise en charge des opérations bulk — chargement et mise à jour massifs de documents avec gestion automatique des erreurs.
• SSL/TLS et authentification — prise en charge intégrée de HTTPS, Basic Auth, clés API et jetons.
• Sérialisation via serde — les documents sont automatiquement convertis en/du JSON à l'aide de la crate serde.

Installation et configuration

Ajoutez la dépendance dans Cargo.toml :

[dependencies]elasticsearch = "8.14.0"serde = { version = "1.0", features = ["derive"] }serde_json = "1.0"tokio = { version = "1.0", features = ["full"] }

Connexion de base à une instance locale d'Elasticsearch :

use elasticsearch::{Elasticsearch, Error};use url::Url;

#[tokio::main]async fn main() -> Result<(), Error> {    let client = Elasticsearch::new(        elasticsearch::http::transport::Transport::single_node(            Url::parse("http://localhost:9200")?        )?    );        // Vérification de la connexion    let response = client.ping().send().await?;    println!("Elasticsearch disponible : {}", response.status_code());    Ok(())}

Travailler avec les documents

Indexation d'un document

Définissons une structure pour la sérialisation :

use serde::{Serialize, Deserialize};

#[derive(Debug, Serialize, Deserialize)]struct Book {    title: String,    author: String,    year: u16,    isbn: String,}

Indexation d'un nouveau document :

use elasticsearch::{IndexParts, SearchParts};use serde_json::json;

async fn index_book(client: &Elasticsearch, book: &Book) -> Result<(), Error> {    let response = client        .index(IndexParts::IndexId("books", &book.isbn))        .body(book)        .send()        .await?;        println!("Document indexé : {:?}", response);    Ok(())}

Recherche dans l'index

Exemple de recherche en texte intégral :

async fn search_books(client: &Elasticsearch, query: &str) -> Result, Error> {    let response = client        .search(SearchParts::Index(&["books"]))        .body(json!({            "query": {                "multi_match": {                    "query": query,                    "fields": ["title^2", "author"]                }            }        }))        .send()        .await?;        let response_body = response.json::().await?;    let hits = response_body["hits"]["hits"]        .as_array()        .unwrap_or(&vec![]);        let books: Vec = hits        .iter()        .filter_map(|hit| {            let source = hit["_source"].clone();            serde_json::from_value(source).ok()        })        .collect();        Ok(books)}

Opérations bulk pour le chargement massif

Chargement efficace de milliers de documents :

use elasticsear