Personalizar selección de servidor

Overview

Todos los drivers de MongoDB siguen un algoritmo definido al seleccionar un servidor del cual leer o al que guardar. El Controlador de Rust de MongoDB permite personalizar este algoritmo para seleccionar un servidor que funcione mejor para tu aplicación.

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

• Usar una preferencia de lectura para describir servidores adecuados de manera estandarizada, como primario, secundario o el más cercano, con conjuntos de etiquetas y obsolescencia máxima.

• Proporciona un predicado personalizado a través de SelectionCriteria::Predicate aplicar tu propia lógica cuando filtras servidores adecuados.

Algoritmo de selección personalizado

Cuando el driver 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 driver selecciona los servidores que coinciden con el SelectionCriteria activo, ya sea aquellos que coincidan con una preferencia de lectura o aquellos para los cuales un predicado personalizado devuelve true.

2. Aplicar ventana de latencia: El controlador aplica la configuración de local_threshold 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 driver selecciona aleatoriamente un servidor entre los que quedan en la ventana de latencia y ejecuta la operación contra este servidor.

Cuando el controlador Rust ejecuta una operación de escritura, comienza seleccionando todos los servidores en los que se puede escribir, no solo los 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 por defecto, 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 servidores con el enum SelectionCriteria, como se muestra en el siguiente ejemplo:

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

Para cualquier operación determinada, utiliza o bien SelectionCriteria::ReadPreference o bien SelectionCriteria::Predicate, nunca ambos:

• ReadPreferenceDescribe los servidores adecuados en función del tipo de servidor, los conjuntos de etiquetas y la máxima antigüedad, siguiendo las reglas estándar de preferencia de lectura de MongoDB.

• PredicatePermite proporcionar una lógica personalizada para casos que ReadPreference no puede expresar, como preferir servidores según patrones de nombres de host u otros criterios personalizados.

Un predicado es cualquier cierre que acepte una referencia ServerInfo y devuelva true, indicando la idoneidad del servidor. El driver lo define como el alias de tipo Predicate, que 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 supervisión.

Ejemplo: Usa predicados para seleccionar servidores en localhost

Si usas un clúster fragmentado con varios servidores mongos, puedes preferir las implementaciones que se ejecutan en localhost. Las operaciones contra estas implementaciones tienen menor latencia y mayor rendimiento. Este ejemplo muestra cómo personalizar el algoritmo de selección de servidores para considerar únicamente servidores que funcionen 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 más información sobre la personalización del algoritmo de selección de servidor del driver de Rust, consulta la siguiente documentación de la API:

• SelectionCriteria

• ServerInfo

• MongoClient