Présentation de Lucene distribué
NCache fournit une Lucene module, qui vous permet d'utiliser Lucene pour la recherche de texte avec NCache. Chaque serveur de NCache dispose d'un module Lucene dédié. Cela rend Lucene distribué, évolutif et hautement disponible avec NCache.
Notes
Cette fonctionnalité est disponible en NCache Entreprise ainsi que Professional pour le Topologies partitionnées seulement.
Notes
NCache utilise la version 4.8 de Lucene.Net.
Pourquoi utiliser Lucene avec NCache?
Lucene, comme nous le savons, est un moteur de recherche puissant et efficace qui propose une vaste gamme de techniques de recherche de texte pour répondre aux besoins de votre entreprise. Lucene est bien plus que n’importe quel autre moteur de recherche textuelle car les choix proposés à l’utilisateur sont multiples. Il dispose d’algorithmes de recherche puissants et prend en charge un large éventail de requêtes de recherche.
Bien qu'aussi puissant que Lucene soit à lui seul, il a ses limites. Lucene s'exécute en cours dans l'application cliente. Cela signifie que Lucene n'est pas évolutif et qu'il a un point de défaillance unique.
NCache fournit une implémentation distribuée de Lucene avec des modifications mineures dans son API. Appels API de Lucene NCache à l'arrière. NCache être distribué par nature avec Lucene offre une évolutivité d'écriture linéaire car les documents indexés par les applications sont automatiquement distribués entre les nœuds de cache où ils sont indexés séparément.
Notes
Distributed Lucene utilise un magasin Lucene séparé et dédié au lieu du NCache cache-magasin.
De même, Distributed Lucene offre également une évolutivité de lecture linéaire puisque les requêtes sont propagées sur chaque partition et les résultats sont fusionnés. Un nombre plus élevé de partitions offre une plus grande évolutivité en lecture et en écriture. Les index Lucene sont conservés sur votre disque physique. Plus il y a de nœuds, plus l'évolutivité, les performances et la capacité de stockage sont élevées pour accueillir un grand nombre de documents Lucene et de données indexées.
Fonctionnement du Lucène distribué
Important
Il est fortement recommandé d'utiliser un SSD pour indexer et rechercher des documents Lucene au lieu d'un disque dur.
Le comportement et le fonctionnement de Lucene et de Distributed Lucene sont presque les mêmes avec quelques changements. Le flux de travail, la distribution des données et les composants de Distributed Lucene sont expliqués dans les sections suivantes :
Flux de travail Lucene distribué
Le diagramme ci-dessous montre le fonctionnement du modèle Distributed Lucene.
L'application client peut souhaiter indexer et analyser (analysés par les analyseurs Lucene pris en charge) ou interroger des documents indexés existants à l'aide de l'API Lucene. Ces opérations avec l'API agissent comme des appels de procédure distante (RPC) et sont directement transmises au NCache grappe. Le cluster détermine la nature de ces appels et transmet les appels aux modules Distributed Lucene attachés à chaque nœud de serveur. Ces modules exécutent ces appels, et selon la nature des appels, l'une ou l'autre des actions suivantes a lieu :
Appel de document de requête : Dans le cas d'un appel de requête, les modules Distributed Lucene renvoient les résultats côté client, où tous ces résultats sont fusionnés et traités.
Appel de document d'index : S'il s'agit d'un appel pour indexer un document, les modules Lucene distribués conservent ce document sur un lecteur de disque.
Distribution de données
Une carte de distribution est générée par rapport à un cluster de cache. Pour Distributed Lucene, cette carte est générée :
- Lors de la création du cache.
- Lors de l'ajout ou de la suppression d'un nœud de serveur.
Si la carte de distribution n'existe pas, le cache ne démarre pas et les exceptions sont enregistrées dans l'observateur d'événements et les journaux de service.
Cette carte contient des informations concernant les compartiments par rapport aux nœuds de cache. Le nombre total de buckets pour un cache Lucene distribué est de 100. Ces 100 buckets sont distribués dans le cluster à l'aide d'une stratégie spécifique.
Avoir 100 compartiments signifie qu'un index est divisé en 100 sous-index dans le cluster de cache. En fonction du nombre de compartiments attribués à chaque nœud, tous les fichiers d'index respectifs sont également déplacés vers ce nœud particulier. Par conséquent, chaque fois qu'un transfert d'état entraîne le déplacement de compartiments à travers le cluster de cache, les fichiers d'index correspondants sont également déplacés dans le cadre du processus.
Un nœud de serveur peut contenir plusieurs index, et chaque index de ce nœud de serveur contient des compartiments qui lui sont attribués en fonction de la stratégie de distribution du cluster. Les documents par rapport aux index sont également distribués via ces compartiments. Ces index sont également conservés sur votre disque physique.
NCache a un temps d'exécution ou une distribution dynamique. Le démarrage ou l'arrêt du nœud déclenchera un changement dans la carte de distribution du cluster de cache et déclenchera le transfert d'état. Cependant, dans NCache Distribué Lucene, les index sont conservés sur votre disque physique pour éviter une distribution inutile des index au démarrage ou à l'arrêt du nœud. Cela signifie que dans NCache Lucene distribué, seul l'ajout ou la suppression d'un nœud du cluster de cache modifiera la carte de distribution et déclenchera le transfert d'état pour les nœuds de serveur en cours d'exécution. Pour les nœuds de serveur arrêtés, le transfert d'état aura lieu une fois qu'ils reviendront en ligne.
Voici quelques points importants à considérer pour NCache Lucène distribué :
- Carte de distribution du cache : La carte de distribution d'un nouveau cache n'est générée que lorsque la création du cache est réussie. Si la génération de la carte de distribution échoue pour une raison quelconque, la création du cache est annulée (inversée).
- Transfert d'État : Toute modification de la configuration de l'appartenance au cluster de cache entraînera des modifications de la carte de distribution car cela déclenchera un transfert d'état dans le cluster de cache.
- Ajout de nœud à un cluster existant : Dans ce cas, tous les nœuds de serveur (même celui qui est ajouté) doivent être physiquement disponibles et leur service doit être en cours d'exécution. Lorsqu'un nœud est ajouté au cluster de cache Lucene distribué, la carte de distribution existante est extraite des nœuds de serveur existants. Une nouvelle carte de distribution est alors générée et partagée avec tous les nœuds du serveur. Un appel de validation est envoyé pour conserver cette carte de distribution.
- Suppression d'un nœud d'un cluster existant : Dans ce cas, comme pour l'ajout de nœuds à un cluster existant, tous les nœuds de serveur (à l'exception de celui qui est supprimé) doivent être physiquement disponibles et leur service doit être en cours d'exécution. Sinon, cette opération échouera.
- Arrêt du nœud pendant le transfert d'état : Si un nœud de serveur s'arrête pendant le transfert d'état, le transfert d'état pour ce nœud est interrompu et reprend à partir du même compartiment (où le nœud s'arrête) lorsque le nœud redémarre.
Important
Dans le cas de l'installation du développeur, les magasins peuvent configurer Distributed Lucene.
Initialiser Lucene distribué
Avant de commencer à utiliser Distributed Lucene pour indexer vos documents et les rechercher par la suite, vous devez initialiser cela en premier. Une fois que vous l'avez initialisé, vous devez fournir le nom du cache et le nom de l'index.
Données d'index
Le processus d'indexation dans Distributed Lucene est le même que dans Lucene lui-même. Dans le cas de Distributed Lucene, NCache gère un magasin clé-valeur pour la distribution des documents et une clé générée automatiquement est ajoutée à chaque document. Le document est indexé sur le nœud par rapport à cette clé spécifique.
Recherche d'index
Une fois que Distributed Lucene a été initialisé et que vos documents ont été indexés, vous pouvez effectuer des recherches textuelles sur ces documents.
Facettes
Une catégorie est un aspect essentiel d'un document indexé qui sert à le classer. Par exemple, lors de la recherche de vêtements dans une boutique e-commerce, les catégories de vêtements peuvent être le prix, la matière, la marque, etc.
Dans la recherche à facettes, en plus des résultats de recherche normaux, vous obtenez également des résultats à facettes, constitués de sous-catégories pour certaines catégories. En reprenant l'exemple ci-dessus, les sous-catégories des facettes matérielles peuvent être le coton, la laine, le cuir, etc.
La recherche à facettes vous permet de rechercher très facilement les documents spécifiques dont vous avez besoin. NCache prend désormais en charge Facets avec Distributed Lucene, ce qui vous aidera à rédiger les documents souhaités de manière efficace et efficiente. Le fonctionnement des facettes dans Lucene et Distributed Lucene est essentiellement le même, mais avec de nombreuses améliorations de performances mises en évidence dans Facettes Lucene distribuées.
API géospatiale
Les données qui contiennent des valeurs de coordonnées de longitude et de latitude sont appelées Données géospatiales. Ces données sont utiles si vous souhaitez rechercher des données en fonction de leur emplacement. Par exemple, vous souhaitez indexer un document contenant les informations d'un restaurant. Ce document contient divers champs, et l'un de ces champs contient les valeurs de longitude et de latitude. Pour rechercher ce document à l'avenir en fonction de son emplacement (disons le restaurant le plus proche de chez vous), vous souhaiterez également indexer les champs de longitude et de latitude.
Lucene dispose d'une fonction d'indexation et de recherche de données géospatiales très puissante, et maintenant NCache permet également d'indexer puis de rechercher des documents en fonction de leur emplacement avec l'API Lucene. Le lien suivant vous aidera à comprendre comment indexer les données et les rechercher API distribuée Lucene Geo-Spatial .
Comportement de Lucene distribué dans un cluster partiel
Un cluster de cache est déclaré partiel lorsqu'un ou plusieurs nœuds qu'il contient deviennent indisponibles. Par conséquent, la connectivité est limitée, ce qui fait du cluster de cache un cluster partiel. Le comportement de Distributed Lucene dans un cluster partiel est expliqué ci-dessous :
Opérations de lecture sur un cluster partiel
NCache Distributed Lucene vous permet de récupérer (lire) des données à partir d'un cluster partiel en définissant la valeur de AllowPartialResults
propriété à TRUE
sur le IndexReader
exemple de classe. Par défaut, la valeur de la AllowPartialResults
l'indicateur est défini sur FALSE
.
Ces opérations de lecture renverront des données partielles ou incomplètes. Cependant, dans le cas de Topologie de partition-réplication, le cluster de cache tolérera une défaillance d'un seul nœud via son réplica et vous pourrez récupérer des données complètes. Mais, en cas de défaillance de plusieurs nœuds, vous ne pourrez récupérer que des données partielles.
Si vous essayez de lire les données d'un cluster partiel et que vous avez défini la valeur de AllowPartialResults
drapeau à FALSE
, une exception sera levée.
Opérations d'écriture sur un cluster partiel
Lucene distribué ne vous permet pas d'effectuer des opérations d'écriture telles que l'ajout, la mise à jour et la suppression sur un cluster partiel. Si vous essayez d'effectuer ces opérations sur un cluster partiel, une exception sera levée.
API Lucene non prise en charge
Vous trouverez ci-dessous une liste des API Lucene non prises en charge dans Distributed Lucene.
DirectoryReader
public static DirectoryReader Open(IndexCommit commit)
public static DirectoryReader Open(IndexCommit commit, int termInfosIndexDivisor)
public static DirectoryReader OpenIfChanged(DirectoryReader oldReader)
public static DirectoryReader OpenIfChanged(DirectoryReader oldReader, IndexCommit commit)
public static DirectoryReader OpenIfChanged(DirectoryReader oldReader, IndexWriter writer, bool applyAllDeletes)
IndexSearcher
public IndexSearcher(IndexReaderContext context, TaskScheduler executor)
public Document Document(int docID, ISet<string> fieldsToLoad)
public virtual Weight CreateNormalizedWeight(Query query)
public virtual TopDocs SearchAfter(ScoreDoc after, Query query, int n)
public virtual TopDocs SearchAfter(ScoreDoc after, Query query, Filter filter, int n)
public virtual TopDocs SearchAfter(ScoreDoc after, Query query, Filter filter, int n, Sort sort)
public virtual TopDocs SearchAfter(ScoreDoc after, Query query, int n, Sort sort)
public virtual TopDocs SearchAfter(ScoreDoc after, Query query, Filter filter, int n, Sort sort, bool doDocScores, bool doMaxScore)
IndexReader
public static DirectoryReader Open(Directory directory)
public static DirectoryReader Open(Directory directory, int termInfosIndexDivisor)
public static DirectoryReader Open(IndexWriter writer, bool applyAllDeletes)
public static DirectoryReader Open(IndexCommit commit)
public static DirectoryReader Open(IndexCommit commit, int termInfosIndexDivisor)
public IList<AtomicReaderContext> Leaves
NCacheDirectory
public override string[] ListAll()
public override long FileLength(string name)
public override void DeleteFile(string name)
public override string GetLockID()
public override IndexInput OpenInput(string name, IOContext context)
CompositeReader
public override sealed IndexReaderContext Context
Ressources additionnelles
NCache fournit un exemple d'application pour Distributed Lucene sur GitHub.
Voir aussi
Composants Lucene et aperçu
Configurer les index de requête Lucene
Recherche SQL dans le cache
Cache de recherche avec LINQ