Personalizar selección de servidor

Overview

Todos los controladores de MongoDB siguen un algoritmo definido para seleccionar un servidor desde el que leer o escribir. El controlador de MongoDB para Rust permite personalizar este algoritmo para elegir el servidor que mejor se adapte a tu aplicación.

Puedes influir en la selección del servidor de las siguientes maneras:

• Utilice una preferencia de lectura para describir los servidores adecuados de forma estandarizada, como primario, secundario o más cercano, con conjuntos de etiquetas y un período máximo de obsolescencia.

• Proporcione un predicado personalizado a través de SelectionCriteria::Predicate Aplicar tu propia lógica al filtrar los servidores adecuados.

Algoritmo de selección personalizado

Cuando el controlador de Rust ejecuta una operación con criterios de selección personalizados, realiza los siguientes pasos, en orden, para seleccionar una implementación de MongoDB:

1. Elija servidores elegibles: De la lista de servidores conocidos, el controlador selecciona los servidores que coinciden con el activo,SelectionCriteria ya sean aquellos que coinciden con una preferencia de lectura o aquellos para los que un predicado personalizado true devuelve.

2. Aplicar ventana de latencia: El controlador aplica la local_threshold configuración a la lista de servidores elegibles, filtrando cualquier servidor cuyo tiempo promedio de ida y vuelta esté fuera de la ventana configurada del servidor elegible más rápido.

3. Selección aleatoria: El controlador selecciona aleatoriamente un servidor de entre los que quedan en la ventana de latencia y ejecuta la operación en ese servidor.

Cuando el controlador de Rust ejecuta una operación de escritura, comienza seleccionando todos los servidores en los que se puede escribir, no solo aquellos que coinciden con la preferencia de lectura activa. Los pasos restantes son idénticos.

Para obtener más información sobre el algoritmo de selección de servidor predeterminado, consulte Algoritmo de selección de servidor en el manual del MongoDB Server.

Criterios de selección y predicados

El controlador de Rust representa las reglas de selección de servidor con la enumeración SelectionCriteria, como se muestra en el siguiente ejemplo:

pub enum SelectionCriteria {
    ReadPreference(ReadPreference),
    Predicate(Predicate),
}

Para cualquier operación dada, se utiliza SelectionCriteria::ReadPreference o SelectionCriteria::Predicate, no ambos:

• ReadPreference: Describe los servidores adecuados en función del tipo de servidor, los conjuntos de etiquetas y el tiempo máximo de obsolescencia, siguiendo las reglas estándar de preferencia de lectura de MongoDB.

• Predicate: Permite proporcionar lógica personalizada para casos que ReadPreference no puede expresar, como dar preferencia a los servidores en función de patrones de nombres de host u otros criterios personalizados.

Un predicado es cualquier cierre que acepta una referencia ServerInfo y devuelve true, lo que indica la idoneidad del servidor. El controlador lo define como el alias de tipo Predicate, como se muestra en el siguiente código:

pub type Predicate = Arc<dyn Send + Sync + Fn(&ServerInfo) -> bool>;

Se considera que un servidor es adecuado cuando el predicado devuelve true para el valor ServerInfo de ese servidor. El tipo ServerInfo expone información sobre el servidor, como la dirección, el tipo y otros metadatos de monitorización.

Ejemplo: Usar predicados para seleccionar servidores en localhost

Si utiliza un clúster fragmentado con varios servidores mongos, es posible que prefiera las implementaciones que se ejecutan en localhost. Las operaciones en estas implementaciones tienen menor latencia y mayor rendimiento. Este ejemplo muestra cómo personalizar el algoritmo de selección de servidores para que solo considere los servidores que se ejecutan en localhost.

let prefer_localhost = Arc::new(|server_info: &ServerInfo| {
    matches!(
        server_info.address(),
        ServerAddress::Tcp { host, .. } if host == "localhost"
    )
});

let prefer_localhost = Arc::new(|server_info: &ServerInfo| {
    matches!(
        server_info.address(),
        ServerAddress::Tcp { host, .. } if host == "localhost"
    )
});
let options = ClientOptions::builder()
    .hosts(vec![ServerAddress::Tcp {
        host: "<hostname>".to_string(),
        port: Some(27017),
    }])
    .selection_criteria(SelectionCriteria::Predicate(prefer_localhost))
    .build();
let client = Client::with_options(options)?;

let mut options = ClientOptions::parse(
    "mongodb://<db_username>:<db_password>@<hostname>:<port>",
)
.await?;
let prefer_localhost = Arc::new(|server_info: &ServerInfo| {
    matches!(
        server_info.address(),
        ServerAddress::Tcp { host, .. } if host == "localhost"
    )
});
options.selection_criteria = Some(
    SelectionCriteria::Predicate(prefer_localhost),
);
let client = Client::with_options(options)?;

Documentación de la API

Para obtener más información sobre cómo personalizar el algoritmo de selección de servidor del controlador Rust, consulte la siguiente documentación de la API:

• Criterios de selección

• ServerInfo

• MongoClient