rapportSOLR

RAPPORT DE STAGE
Sujet de recherche sur le moteur de recherche open source Apache
Solr et sa comparaison avec les autres plates-formes de recherche
existantes
07-08/2014
MENTAT CONSEIL
LOUIZI Hamza
Remerciements
Il n’est jamais facile pour un étudiant de trouver un stage, c’est pourquoi
je
tiens
à
remercier
monsieur
Abdeljalil
GUEDDOU,
directeur
de
Mentat
Coseil de m’avoir accepté en tant que stagiaire au sein de sa société.
Je
tiens
aussi
à
remercier
mon
tuteur
de
stage
monsieur
Rafik
AMEUR
pour son soutien technique et son encadrement tout au long de ma période
de stage et monsieur Tarik Saidi pour son soutien moral et pour l’intérêt
qu’il m’a porté tout au long de ces deux mois.
D’une
façon
plus
générale,
je
remercie
toute
l’équipe
pour leur bienveillance et leur accueil chaleureux lors de mon stage.
1
de
Mentat
Conseil
Sommaire
Remerciements .................................................................................................................................. 1
Introduction ........................................................................................................................................ 3
1.
Présentation de la société Mentat Conseil ................................................................................ 4
2.
Etude des besoins ...................................................................................................................... 5
3.
Moteur de recherche ................................................................................................................. 6
3.1. Fonctions de bases .................................................................................................................. 6
3.2. Fonctions avancées ................................................................................................................. 7
4.
5.
6.
Recherche Full-Text .................................................................................................................. 9
4.1.
La recherche par radicaux ................................................................................................ 9
4.2.
La recherche par consonances ........................................................................................ 10
Présentation de LUCENE ....................................................................................................... 11
5.1.
Principe ............................................................................................................................ 11
5.2.
Indexation ........................................................................................................................ 12
5.3.
Recherche......................................................................................................................... 12
5.4.
Classes d’indexation ........................................................................................................ 13
5.5.
Classes de recherche ........................................................................................................ 13
Présentation d’Apache Solr .................................................................................................... 15
6.1.
Mise en place.................................................................................................................... 16
6.2.
Principe de fonctionnement ............................................................................................. 17
7.
Comparaison ........................................................................................................................... 22
8.
Conclusion ............................................................................................................................... 28
9.
Références Bibliographiques................................................................................................... 29
2
Introduction
e
C
stage,
d’une
documentation
durée
sur
la
de
deux
plate-forme
mois,
a
consisté
logicielle
de
à
établir
recherche
Solr
une
et
à
commencer son intégration dans les projets existants de la société.
Ce rapport présente le travail que j’ai effectué lors de mon stage au sein de
la société Mentat Conseil et qui s’est déroulé du 08 Juillet au 08 Septembre
2014.
J’ai divisé cette période en deux parties, pendant la
suis
familiarisé
forme
avec
logicielle
l’environnement
d’Apache
et
j’ai
technique
consacré
la
première période je me
que
proposait
deuxième
partie
cette
de
plate-
mon
stage
pour
mon
à quelques tests d’intégration de ce moteur de recherche très puissant.
Le
projet
réalisé
s’est
expérience
professionnelle.
présentation
exhaustive
avéré
Le
de
apprendre
ou
approfondir,
faire
tour
d’horizon
un
très
but
de
tous
mais
intéressant
ce
les
aussi,
et
rapport
aspects
de
n’est
aspects
techniques
dans
ce
rapport
en
je
vous
pas
techniques
manière
des
enrichissant
et
de
faire
une
que
j’ai
pu
claire,
de
j’ai
été
présentation
de
synthétique
humains
et
auxquels
confronté.
Je
vous
l’entreprise,
expose
ensuite,
durant ces deux
explique
mois et enfin,
les
premier
différents
en conclusion,
stage.
3
lieu
une
aspects
je résume les
de
mon
travail
apports de
ce
1. Présentation de la société Mentat Conseil
Mentat Conseil est une société de conseil et d’intégration de solutions informatiques
spécialisée dans le domaine de la relation client et ceci depuis dix ans.
Elle œuvre dans le conseil, l’étude, l’intégration, le support, la maintenance et l’infogérance
de solutions de communication d’entreprise.
Mentat Conseil offre l’accompagnement à la conception et mise en œuvre de technologies
et de solutions de communication pour entreprise ainsi que l’intégration et la mise en œuvre de
plates-formes logicielles propriétaires ou libres.
Depuis sa création, de grands comptes sur le marché national et international font confiance
à Mentat Conseil qui accompagne ses clients dans l’étude, la mise en place et l’exploitation de
solutions de centre de contacts. Parmi ses clients les plus prestigieux on distingue : AXA,
Orange et SFR. Ses partenaires sont eux aussi connus, on trouve : Genesys, Synchrone
Technologies et Customer-Square.
4
2. Etude des besoins
La mission que j’ai eu à remplir à Mentat Conseil consiste à fournir une plate-forme de
recherche qui établit des recherches dans les bases de données des applications créées par
l’entreprise ainsi qu’une comparaison des moteurs open source les plus connus.
Actuellement, il existe plusieurs moteurs qui peuvent répondre aux besoins de l’entreprise en
matière de recherche mais celui qui semble les intéresser le plus est la plate-forme logicielle de
recherche Apache Solr.
Dans la suite de ce rapport, j’essayerai bien évidemment de comparer les outils existants avec
celui proposé pour mon sujet de stage et de prouver pourquoi cette plate-forme est la mieux
adaptée aux besoins de l’entreprise, j’expliquerai par la suite les méthodes par lesquelles on
peut intégrer ce moteur de recherche très puissant d’Apache.
5
3. Moteur de recherche
Avant de faire la comparaison des solutions trouvées lors de ma recherche avec celle qu’on m’a
proposée, il faut donner quelques notions de bases qui nous introduiront petit à petit au vif du
sujet.
Il s’agit bien entendu d’une brique essentielle d’applications de gestion d’information.
Trois tendances non exclusives existent dans les solutions de GED (gestion documentaires) :
 Intégration d’un moteur de recherche, les solutions open source intègre souvent Lucene,
moteur de référence du monde open source
 Exploitation de la recherche sur de la base de données, ceci peut limiter les fonctions
disponibles (notamment lemmatisation, troncatures…)
 Ouverture
vers
des
solutions
de
recherche
du
marché
(propriétaire)
via des connecteurs
3.1. Fonctions de bases
A minima, le moteur de recherche d’une GED doit :
 indexer les fiches documentaires, c'est-à-dire toutes les métadonnées d'un document
 indexer les documents électroniques en texte intégral (ou « full text »), c'est-à-dire en
prenant en compte le contenu des fichiers électronique, pour tous ceux qui incluent du
contenu textuel
 filtrer ses résultats de recherche selon les habilitations en lecture de l’utilisateur, c’està-dire ne lui proposer que des documents qu’il a le droit de lire
 permettre des recherches aussi bien sur l’intégralité d’un document que sur un ou
plusieurs champs spécifiques de métadonnées.
 permettre l’utilisation des tables de référence dans les interfaces de recherche
 permettre les recherches utilisant plusieurs critères associés avec des opérateurs
booléens (ET, OU, SAUF), ainsi que des parenthèses
6
 permettre de mixer les approches documentaires, sur les métadonnées et le texte intégral
 autoriser les troncatures centrales et à droite, implicitement ou par l’utilisation de
caractères génériques qui remplace un ou plusieurs caractères (classiquement l’étoile «
* » ou le « ? »)
 permettre de personnaliser les pages de recherche, si possible plusieurs pages
différentes, pour correspondre aux attentes des utilisateurs
3.2. Fonctions avancées
L’utilisation de moteurs élaborés est souvent envisagée pour prendre en charge des fonctions
avancées comme :
 permettre l’enregistrement de résultats sous forme de « panier » par exemple, pour
permettre aux utilisateurs de constituer une sélection
 permettre l’enregistrement des stratégies de recherche, c'est-à-dire les critères utilisés
pour la recherche, afin de pouvoir les relancer simplement
 rechercher successivement de façon à affiner une requête par rapport aux résultats de la
recherche précédente
 étendre une recherche, par rapport à des synonymes par exemple
 fédérer la recherche sur plusieurs bases documentaires
 automatiser les approximations, suggestion orthographique et la lemmatisation (c'est-àdire la recherche sur les racines des mots)
 permettre la recherche en langage naturel ou recherche par l’exemple, c'est-à-dire
déduire l’équation de recherche d’une phrase ou d’un texte interprété par le moteur
 suggérer des résultats approchant à l’issue d’une recherche, par différents moyens :
o explicites, via des liens entre documents spécifiés dans l’indexation de chacun.
o implicites, des rapprochements issus de calculs statistiques ou sémantiques
 détecter automatiquement des « entités nommées », c'est-à-dire des noms propres
(personnes, lieux) et de leurs relations.
7
Parmi les besoins fréquemment évoqués, on retrouve par exemple : la navigation par
arborescence, la recherche sur intervalle de dates, la recherche simple (pour les aficionados de
Google), la recherche par référence, la recherche fédérée couvrant à la fois la GED et les
applications tierces.
Il est donc fondamental d’analyser les attentes des utilisateurs pour définir leurs besoins de
recherche. C’est un bon point de départ pour bâtir l’architecture (structure des données et
ergonomie) de l’application cible.
Tous les outils proposent une fonction de recherche à minima sur les métadonnées.
Les fonctions de recherche plus avancées ne seront pas disponibles nativement et demanderont
une intégration ou une configuration.
8
4. Recherche Full-Text
La recherche full-text est le principe d'opérer des traitements (l'indexation) sur du texte afin d'y
retrouver plus facilement des mots. Ce procédé consiste à effectuer une suite de manipulations
sur chacun des mots du texte afin d'augmenter la pertinence des recherches.
En règle générale, les interfaces de recherche full text permettent de segmenter le texte en mots
(tokens) selon diverses règles (espaces, ponctuation, changement de casse etc.). Les
manipulations possibles sur ces mots sont diverses : modifier la casse, remplacer les lettres
accentuées, etc. Outre ces traitements simples (et qui ne sont pas toujours judicieux), il existe
deux procédés plus complexes mais qui donnent de meilleurs résultats : la recherche par
radicaux (lexèmes) et la recherche par consonances (phonétique).
4.1. La recherche par radicaux
Un lexème est la forme élémentaire de chaque mot, c'est en quelque sorte sa racine linguistique.
C'est sa forme, réduite au point de ne pas avoir d'existence dans la langue écrite ou orale, mais
qui sert de point de départ pour toutes les formes dérivées de ce mot. Le procédé permettant
d'obtenir le lexème d'un mot s'appelle la racinisation, ou stemming en anglais.
Le lexème est le point de départ pour constituer les lemmes, qui sont eux-mêmes le point de
départ pour constituer les mots. La racinisation est un procédé complexe et il est différent dans
chaque langue, c'est pourquoi il n'existe pas d'algorithme informatique pour toutes les langues.
De même, les algorithmes existants ne sont pas implémentés dans tous les langages
informatiques. Ainsi, le langage informatique convenant le mieux à vos choix techniques (Java,
.NET, PHP, etc.) n'a peut-être pas d'implémentation d'un algorithme de racinisation pour les
langues qui vous intéressent. Un projet, cependant, facilite leur implémentation : Snowball. Il
présente une liste d'exemples pour chaque algorithme, notamment en français.
La flexion consiste à dériver un mot afin d'obtenir toutes ses représentations possibles :
déclinaisons grammaticales (genre et nombre), conjugaisons, préfixes, suffixes et modifications
du radical. C'est l'approche inverse de la racinisation, mais l'effet en est souvent proche.
9
En informatique, plusieurs programmes et bibliothèques permettent de fléchir un mot : ispell
(d'adoption
historiquement
plus
large),
aspell/pspell
(remplacement
d'ispell),
MySpell/Hunspell (créés par OpenOffice.org et utilisés par Mozilla), etc. Leur nombre
croissant, un projet connexe a vu le jour : Enchant, qui propose une API commune et qui permet
donc d'utiliser n'importe lequel de ces programmes avec les mêmes appels de fonctions.
L'inconvénient majeur de la méthode par flexion est qu'elle ne donne de bons résultats que si
l'on part d'un mot équivalent au lexème (mot non fléchi). Par exemple, si dans le texte se trouve
le mot "développaient" et qu'un utilisateur cherche le mot "développement", une méthode par
flexion est incapable de les faire correspondre. En revanche, une méthode par racinisation
permet de retrouver le lexème commun à ces deux mots : "développ".
4.2.
La recherche par consonances
Soundex est un algorithme décrit en 1918 par Robert C. Russell and Margaret K. Odell. Il
permet de décrire la prononciation des mots anglais au moyen de lettres et de chiffres.
Soundex est prévu exclusivement pour la langue anglaise et, même dans cette langue, il a des
limites.
Les algorithmes Metaphone (1990) et Double Metaphone (2000), tous deux par Lawrence
Philips, permettent une meilleure représentation des mots pour la langue anglaise. Le Double
Metaphone permet en principe de mieux identifier le contexte d'utilisation de chaque mot, et ce
dans diverses langues (notamment le français).
Pour ma part, je ne suis pas persuadé qu'il soit possible de déterminer la prononciation d'un
mot, et donc sa représentation informatique, sans savoir dans quelle langue (voire même dans
quel dialecte local) il est utilisé. Toutefois, Double Metaphone semble être l'algorithme
bénéficiant de la plus vaste adoption de nos jours.
10
5. Présentation de LUCENE
Lucene est une bibliothèque open source écrite en Java qui permet d'indexer et de chercher du
texte. Il est utilisé dans certains moteurs de recherche.
C'est un projet de la fondation Apache mis à disposition sous licence Apache. Il est également
disponible pour les langages Ruby, Perl, C++, PHP, C#.
Lucene est une librairie open source en Java (mais il existe de nombreux portages) permettant
d’ajouter des fonctionnalités de recherche plein-texte à vos applications.
Il s’agit bien d’une librairie avec laquelle il n’est pas fourni d’outils permettant l’indexation de
données en quelques clics de souris et quelques paramétrages. Il faut donc en passer par du code
Java afin de mettre en place une solution sur mesure de recherche plein-texte.
5.1. Principe
Lucene indexe et retrouve des “documents”. Par document, on ne parle pas de fichiers Excel,
Word, PDF ou HTML, mais d’une structure de données constituée de champs. Un champ est
une donnée possédant un nom (titre, auteur, date de publication, contenu, ..) et à laquelle est
associé du texte. C’est ce texte qui est indexé, recherchable et affichable. Les documents
indexés sont regroupés au sein d’une collection de documents appelée “index”. Un index peut
contenir plusieurs centaines, milliers ou millions de documents et il est possible de créer autant
d’index différents que le nécessite votre ou vos applications. Physiquement, un index est un
répertoire (que vous spécifiez) hébergeant un nombre variable de fichiers (ça c’est l’affaire de
Lucene).
Si le texte qui est à indexé est contenu dans des fichiers Excel, Word, PDF ou HTML, c’est de
votre ressort d’en extraire de contenu textuel qui sera indexé. Il est possible d’utiliser par
exemple pdftotext pour les fichiers PDF et Antiword pour les fichiers Microsoft Word.
11
5.2. Indexation
Jusqu'à l'explosion de l'internet, la classification décimale de Dewey était très efficace pour
catégoriser des objets dans une bibliothèque. Cependant, comme la somme des données
collectée est devenue trop vaste, il faut maintenant utiliser des moyens alternatifs et plus
dynamiques pour trouver de l'information.
Au cœur de tous les moteurs de recherche se trouve un mécanisme d'indexation automatique :
en traitant une seule fois les données brutes et en leur donnant de multiples liens hautement
efficients, on accélère l'opération de recherche. Le concept est assez analogue à l'index
terminologique que l'on trouve généralement à la fin d'un livre, qui permet de trouver
rapidement les pages qui traitent d'un sujet donné.
Si l'on a besoin de couvrir un large champ de fichiers ou de trouver une chaîne de caractères
précise dans un seul fichier, il ne faut pas scanner séquentiellement chaque fichier pour la phrase
donnée. Car, plus le nombre de fichiers est grand, plus longue est la recherche d'information. Il
vaut mieux établir un index des textes dans un format qui permet la recherche rapide, ce qui
évite la méthode séquentielle. Ce processus est appelé indexation.
5.3. Recherche
La recherche est l'action de regarder des mots dans un index pour trouver des références à des
documents lorsqu'ils apparaissent. La qualité d'une recherche est évaluée par le positionnement
et la pertinence des résultats. Cependant, d'autres facteurs entrent en compte dans une recherche.
La rapidité est un facteur déterminant pour traiter une vaste quantité d'informations. De même,
pouvoir supporter des requêtes simples ou complexes, des interrogations de phrases, des
caractères, les résultats de positionnement et de tri sont aussi importants qu'une syntaxe facile
à prendre en main pour entrer ces requêtes.
12
5.4. Classes d’indexation
 IndexWriter - La classe IndexWriter est le composant central du processus d'indexation.
Cette classe crée un nouvel index et ajoute des documents à un index existant. On peut
se la représenter comme un objet par lequel on peut écrire dans l'index mais qui ne
permet pas de le lire ou de le rechercher.
 Directory - La classe Directory représente l'emplacement de l'index de Lucene.
IndexWriter utilise une des implémentations de Directory, FSDirectory, pour créer son
index dans un répertoire dans le Système de fichiers. Une autre implémentation,
RAMDirectory, prend toutes ses données en mémoire. Cela peut être utile pour de plus
petits indices qui peuvent être pleinement chargés en mémoire et peuvent être détruits
sur la fin d'une application.
 Analyzer - Avant que le texte soit dans l'index, il passe par l'Analyser. Celui-ci est une
classe abstraite qui est utilisée pour extraire les mots importants pour l'index et supprime
le reste. Cette classe tient une part importante dans Lucene et peut être utilisée pour faire
bien plus qu'un simple filtre d'entrée.
 Document - La classe Document représente un rassemblement de champs. Les champs
d'un document représentent le document ou les métadonnées associées avec ce
document. La source originelle (comme des enregistrements d'une base de données, un
document Word, un chapitre d'un livre, etc.) est hors de propos pour Lucene. Les
métadonnées comme l'auteur, le titre, le sujet, la date, etc. sont indexées et stockées
séparément comme des champs d'un document.
 Field - Chaque document est un index contenant un ou plusieurs champs, inséré dans
une classe intitulé Field. Chaque champ (field) correspond à une portion de donnée qui
est interrogé ou récupéré depuis l'index durant la recherche.
5.5. Classes de recherche

IndexSearcher - La classe IndexSearcher est à la recherche ce que IndexWriter est à
l'indexation. On peut se la représenter comme une classe qui ouvre un index en mode
lecture seule.
13

Term - Un terme est une unité basique pour la recherche, similaire à l'objet field. Il est
une chaîne de caractère : le nom du champ et sa valeur. Notez que les termes employés
sont aussi inclus dans le processus d'indexation.

Query - La classe Query est une classe abstraite qui comprend BooleanQuery,
PhraseQuery, PrefixQuery, PhrasePrefixQuery, RangeQuery, FilteredQuery, et
SpanQuery.

TermQuery - C'est la méthode la plus basique d'interrogation de Lucene. Elle est utilisée
pour égaliser les documents qui contiennent des champs avec des valeurs spécifiques.

QueryParser - La classe QueryParser est utilisée pour générer un décompositeur
analytique qui peut chercher à travers un index.

Hits - La classe Hits est un simple conteneur d'index pour classer les résultats de
recherche de documents qui apparaissent pour une interrogation donnée. Pour des
raisons de performances, les exemples de classement ne chargent pas depuis l'index tous
les documents pour une requête donnée, mais seulement une partie d'entre eux.
14
6. Présentation d’Apache Solr
Solr est une plate-forme logicielle de recherche s'appuyant sur le moteur de recherche Lucene,
créé par la Fondation Apache et distribuée et conçue sous licence libre.
Solr utilise le langage Java et est exécuté par un conteneur de servlets, comme par exemple
Tomcat. Il communique avec le client à l'aide d'une interface de programmation en XML et
JSON, généralement via le protocole HTTP.
C’est un outil open source permettant de mettre en place des fonctionnalités de recherche dans
différents types d’applications et notamment des sites web (mais pas seulement). Solr est basé
sur Lucene.
Solr offre la possibilité d'importer des données depuis une base de données, ou même un flux
RSS. Pour la base de données, les colonnes d'une table deviendront les champs du Document
manipulé.
Comme Lucene, Solr est développé en Java. Il étend les fonctionnalités de Lucene et en
simplifie la mise en oeuvre. Sorl fournit principalement 3 choses :

un web service d’indexation des données

un web service de recherche

une interface web d’administration
Avec Solr, les documents sont ajoutés à une collection via “XML over HTTP” (une requête
HTTP en mode POST qui envoie des données XML décrivant le document à indexer), et les
recherches sont faites avec au moyen d’une requête HTTP qui retourne un résultat au for mat
XML (les documents correspondants à la requête). Le traitement des requêtes HTTP par Solr
se fait au moyen d’une servlet (installé sous Tomcat par exemple).
Solr gère le spell sheck : si des termes sont proches que certains présents au sein de documents
indexés, il propose des propositions de termes à rechercher. Google dispose de la même
fonctionnalité.
15
Cette fonctionnalité permet de mettre en surbrillance les termes recherchés. Ce principe est le
même que les pages "en cache" de Google où les termes recherchés apparaissent surlignés en
jaune. C'est une fonctionnalité puissante et pratique.
Une des caractéristiques intéressantes de Solr est la gestion des facettes. Cette fonctionnalité
permet de regrouper les informations par catégories. C'est de plus en plus utilisé aujourd'hui car
c'est très pratique et rapide.
Figure 1: Exemple de gestion de facettes
6.1. Mise en place
Pour télécharger la dernière archive d'Apache Solr, il suffit de la récupérer à l'adresse
http://www.apache.org/dyn/closer.cgi/lucene/solr.
Une fois téléchargée, il suffit simplement d'extraire l'archive à l'endroit souhaité.
Une application complète de démonstration est fournie dans le répertoire "example". Il est donc
plus simple de considérer ce répertoire comme le répertoire de travail, et y effectuer les
modifications voulues. En effet, Solr est déjà configuré pour être lancé avec Jetty.
Pour lancer le serveur, il suffit de lancer la commande suivante en ligne de commandes dans le
répertoire "example" :
java -jar start.jar
Cette commande lance ainsi le serveur d'application Jetty sur le port 8983,
et les informations de logging apparaissent dans le terminal.
16
6.2. Principe de fonctionnement
Pour montrer comment fonctionne Apache solr je vais présenter un simple exemple qui englobe
les principales étapes à suivre lors de son utilisation.
Commençons tout d’abord par le processus qu’adopte Solr, dans la partie gauche, on souhaite
indexer un document concernant le super héros Spiderman, identifié par un ID, un nom, un
super-nom,
des
pouvoirs
et
une
histoire.
En dessous, est représenté Solr, dans son conteneur de servlets, se basant sur la bibliothèque
Lucene. On passe donc par l'URL update, puisque c'est un ajout d'un nouveau document.
Ensuite, en fonction de si le document est au format XML ou CSV (comma-separated values)
un handler effectue le traitement d'analyse de la requête. Le plus souvent, c'est XML qui est
utilisé.
La partie de droite concerne la demande de recherche de document. On passe donc par l'URL
Select,
en
demandant tous les
superhéros
qui
détiennent
le
pouvoir
d'agilité.
Un handler de requête permet de traiter la recherche, et la réponse est écrite en XML, via le
XML
response
writer.
Les documents qui correspondent à la requête sont ainsi renvoyés à l'application cliente, qui
peut par exemple retranscrire, le tout au format HTML pour présenter les données.
17
Figure 2: Principe de fonction d’Apache Solr
Je vais procéder à l’explication des étapes du processus une par une.
Pour indexer des documents, il faut tout d'abord les formater au format XML (ou CSV). Dans
l'exemple ci-dessus, on considère le fichier "superheroes.xml", comportant un seul superhéro,
Spider-Man :
La balise <add> précise qu'on ajoute des documents. Chaque document est alors décrit entre
les balises <doc>. Ici on ajoute le superhéro Spider-Man, identifié 0001, dont le nom est Peter
Parker et qui comporte les pouvoirs d'agilité et la sensibilité d'une araignée.
<add><doc>
<field name=“id”>0001</field>
<field name=“name”>Peter Parker</field>
<field name=“supername”>Spider-Man</field>
<field name=“powers”>agility</field>
<field name=“powers”>spider sense</field>
<field name=“story”>lors de sa première apparition, Peter Parker …</field>
18
</add></doc>
Une fois le document rédigé, on va l'indexer en utilisant n'importe quel logiciel qui sait faire du
POSTing. Solr propose dans ses exemples, un JAR qui simplifie l'ajout de documents :
java -jar post.jar superheroes.xml
Pour la suppression, la méthode à adopter est simple Il suffit d’une balise <delete> comme suit :
<delete>
<query>powers:agility</query>
</delete>
Pour appliquer les modifications faites au niveau du document on doit bien évidemment faire
un commit qui se fait en ajoutant la balise <commit />.
Concernant la recherche il suffit de passer par une requête HTTP GET. Imaginons que l'on ait
au préalable indexé le document "superheroes.xml" comme vu précédemment. Le document
propre
à
Superman
est
donc
présent
dans
l'index.
On demande par exemple, tous les documents comportant un champ "powers" ayant pour valeur
"spider sense". C'est en effet le cas pour Spider-Man. Il suffit d'accéder à l'URL Select suivante
http://localhost:8983/solr/select?q=powers:spidersense&fl=name,supername
Le paramètre "fl" permet de spécifier quels sont les champs que l'on souhaite retourner pour les
documents qui correspondent à la recherche. Si celui-ci n'est pas renseigné, tous les champs des
documents qui correspondent seront renvoyés. Dans notre cas, on veut uniquement le nom et le
supernom des héros trouvés.
La réponse affichée au format XML est la suivante :
<response>
<lst name="responseHeader">
<int name="status">0</int>
19
<int name="QTime">0</int>
<str name="q">powers:spidersens</str>
</lst>
<result name="response" numFound="1" start="0">
<doc>
<str name="name">Peter Parker</str>
<str name="supername">Spider-Man</str>
</doc>
</result>
</response>
Le statut à 0 signifie que l'opération s'est correctement déroulée. Le QTime à 0 est le temps de
traitement côté serveur.
On retrouve bien la requête dans le "q", en rouge. Dans cet exemple, un seul document est
retourné (numFound=1). Il s'agit bien du document décrivant Spider-Man. On retrouve aussi
les deux seuls champs demandés, en bleu, le nom et le super-nom.
Cet exemple est donc une petite présentation des étapes suivies lors du fonctionnement de cette
plate-forme de recherche partant de l’indexation jusqu’à la recherche.
Les 3 principaux avantages à utiliser Solr et non pas Lucene seul sont :

Le fonctionnement en mode services WEB (REST1), c’est à dire, la possibilité d’indexer
et de rechercher des documents sans la moindre ligne de code si ce n’est la construction
des données XML pour l’indexation et l’exploitation des données XML retournées par
une recherche

l’utilisation dans des applications écrites dans n’importe quel langage et permettant de
communiquer en HTTP

Solr étend et optimise Lucene (performances, analyseurs de texte, monitoring, …)
Les fonctionnalités principales ajoutées à Lucene sont donc :

1
Configuration au moyen de fichiers XML
Representational State Transfer (REST) est un style d’architecture pour les systèmes hypermédia distribués.
20

Mise en évidence des termes trouvés (Hit highlighting). Cette fonctionnalité permet de
mettre en surbrillance les termes recherchés. Ce principe est le même que les pages "en
cache" de Google où les termes recherchés apparaissent surlignés en jaune.
C'est une fonctionnalité puissante et pratique.

Navigateurs dans les résultats (Faceted search).

Gestion de cache

Une interface d’administration Web

Architecture extensible basée sur des plugins

Optimisation pour des hauts trafics Web

Statistiques
21
7. Comparaison
Fondamentalement, Solr est un moteur de recherche Full Text (ou texte plein en français). Nous
pourrions donc utiliser un moteur open-source qui s'intègre plus facilement à notre SGBD,
comme par exemple Sphinx pour les moteurs MySQL et PostgreSQL. Malheureusement, la
plupart des moteurs full-text sont faibles pour la racinisation de la langue française, c'est-à-dire
retrouver la racine de chaque mot et s'en servir pour effectuer les comparaisons.
Solr implémente différents algorithmes de racinisation et pour un nombre de langues parfois
supérieur aux autres moteurs. Malgré le nom du filtre utilisé par Solr (SnowballPorterFilter)
suggérant l'exclusivité de l'algorithme Porter 2, il permet en réalité d'utiliser différents
algorithmes.
Il faut faire plusieurs considérations basées sur le langage de programmation et/ou sur le
serveur (exemple la mémoire disponible sur la RAM). Par exemple, si la taille de la collection
à indexer est très importante et à une tendance à changer (besoin fréquent d’indexation), on
doit plutôt porter notre attention sur Lucene, ht://Dig ou MG4J car ils ont les meilleurs temps
d’indexation.
2
C’est un algorithme de normalisation des mots. Il permet de supprimer les affixes des mots pour obtenir une
forme canonique du mot.
22
Figure 3: Temps d’indexation des documents de différentes tailles (750MB, 1.GB et 2.7GB)
Si par exemple la taille du disque est critique, il faudra penser à utiliser Lucene, IXE ou SwishE car la taille d’index est égale à 30% de celle de la collection, le seul inconvénient dans ce cas
serait le temps d’indexation que ça prendra.
Si dans un autre cas la collection ne change pas souvent et sachant que le temps de recherche
est similaire chez la plupart des moteurs de recherche, on pourrait se baser sur le langage de
programmation au dépend des applications dans lesquelles sera intégrer ce moteur de
recherche : pour Java on peut utiliser Lucene, Terrier ou MG4J et pour C/C++ on peut utiliser
Swish++, ht://Dig ou XMLSearch.
23
Je vais résumer ceci dans un tableau comparatif :
Critères
Moteurs de recherche
Meilleurs temps d’indexation
Lucene – ht://Dig – IXE – MG4J –
XMLSearch – Terrier
Taille des index
Lucene – MG4J – IXE – XMLSearch
Utilisation de la mémoire RAM
Lucene – XMLSearch – ht://Dig
Meilleurs temps de réponse
Lucene – XMLSearch – IXE
Meilleure performance d’indexation
Zettair
Certes, le test de performance est un art difficile. La difficulté croit avec la complexité de l'outil
qu'on
teste
et
avec
le
nombre
de
cas
d'utilisation
possible.
Dans le cas d'un moteur de recherche, les cas d'utilisation sont extrêmement nombreux. La
typologie de donnée à indexer est très variable (pages web, documents office, métadonnées),
tout
comme
les
modes
d'utilisation
(extranet,
intranet).
Le temps d'indexation est certes une métrique mais elle est de loin insuffisante pour juger de la
qualité d'un moteur de recherche.
Il existe aussi une plate-forme de recherche libre qui donne à Apache Solr du fil à retordre :
c’est ElasticSearch. Dans le chapitre qui suit je vais essayer de comparer ces deux plates-formes
pour savoir qui est plus adapté que l’autre.
Dans le petit monde des moteurs de recherche, Solr était jusqu'à 2012 le moteur de recherche
open source le plus complet, mais cela a quelques peu changé depuis la sortie d’ElasticSearch.
Lorsque l'on parle d’ElasticSearch il est très difficile de ne pas le comparer à son grand-frère
Solr (ou plus précisément SolrCloud). Ils ont beaucoup de fonctionnalités communes, seuls
quelques points discriminants permettent de différencier l'un par rapport à l'autre.
La grande différence entre Solr "classique" et ElasticSearch est le fonctionnement en mode
distribué qui est intégré nativement dans ElasticSearch alors que cela apparait comme une
extension de Solr via SolrCloud.
24
Pour la communication, les deux utilisent le protocole HTTP, mais déjà l’utilisation de ce
protocole diffère avec l'intégration par défaut du XML pour la communication avec Solr
et JSON pour la communication avec ElasticSearch.
Du côté des données, les informations ingérées par Solr et ElasticSearch doivent être présentées
comme des documents structurés. Une nouvelle différence apparaît entre les deux moteurs, car
du côté de ElasticSearch les indexes sont dynamiques (dynamic mapping) et peuvent donc
mélanger des documents de structures différentes ou des documents imbriqués (nested
documents), ces derniers permettent d'embarquer des sous informations permettant par exemple
de gérer des ACL 3 complexes par document. Elasticsearch intègre également nativement les
types de données de géolocalisations permettant rapidement la gestion des résultats
cartographiés (intégré depuis peu dans la version 4 de Solr).
Un point fort d’ElasticSearch est l'utilisation des recherches potentielles (percolate). Cette
fonctionnalité permet d'enregistrer les termes recherchés comme une recherche potentielle et
par la suite d'effectuer une recherche à travers ses résultats prédéfinis plus rapidement. Ce sont
des index dédiés qui sont entretenus par ElasticSearch à chaque ajout de nouveaux documents.
En termes d'administration ElasticSearch peut modifier sa configuration, à la volée sans
redémarrage, directement avec son API en REST/JSON. Le format des fichiers de configuration
sont en YAML4 permettant d’avoir des fichiers plus concis.
Là où ElasticSearch apporte un plus, est sa capacité à facilement intégrer des données externes
à travers des connecteurs d'import déjà packagés appelés des « rivières ». Il y a déjà plus d'une
vingtaine de rivières existantes intégrant les classiques JDBC ou LDAP, en passant par des
bases de données NoSQL comme CouchDB ou MongoDB, jusqu'à des rivières plus orientées
WEB comme Twitter, Dropbox ou Wikipedia.
3
Access Control List (ACL) est un système permettant de faire une gestion fine des droits d’accès aux fichiers.
YAML est un format de représentation de données par sérialisation Unicode qui reprend des concepts
d’autres langages comme XML.
4
25
Voici une comparaison des deux outils sous forme de tableau :
API
Caractéristiques
Solr
ElasticSearch
Format
XML – CSV – JSON
JSON
Binary API
SolrJ
TransportClient – Thrift
Client Libraries
PHP – Ruby – Perl – Scala –
PHP – Ruby – Perl – Scala –
Python - .NET - Javascript
Python - .NET – Javascript –
Erlang - Clojure
Output
JSON – XML – PHP –
JSON - XML/HTML
Python – Ruby – CSV –
Velocity – XSLT - native
Java
INDEXATION
Caractéristiques
Solr
ElasticSearch
Data Import
DataImportHandler - JDBC,
Rivers modules - CouchDB,
CSV, XML, Tika, URL, Flat
Dropbox, DynamoDB,
File
FileSystem, Git, GitHub,
JDBC, LDAP, MongoDB,
RSS, Solr, Subversion,
Twitter, Wikipedia
Synonyms
Oui
Oui
Complex documents
Non
Oui
Online shema changes
Non
Oui
Dynamic fields
Oui
Oui
26
RECHERCHE
Caractéristiques
Solr
ElasticSearch
Spatial search
Oui
Oui
Faceting
Oui
Oui
Spellcheck
Oui
Oui
Autocomplete
Oui
Oui
Joins
Non
Oui
Result highlighting
Oui
Oui
Result grouping
Oui
Non
Apache Solr et ElasticSearch se basent tous les deux sur la bibliothèque Apache Lucene et
fournissent des services de recherche aux APIs Java, donc les départager sera une tâche
difficile car ils ont de nombreux points en communs.
27
8. Conclusion
P
our rendre compte de mon stage au sein de Mentat Conseil, ce rapport a procédé en
plusieurs étapes. J’ai commencé par définir théoriquement, puis techniquement le
concept qui constituait la problématique principale du stage, et ensuite j’ai exposé les
modèles de configuration de Solr que j’ai pu élaborer pour répondre à la problématique initiale,
puis les tests menés pour motiver un choix éventuel d’une de ces configurations. J’ai consacré
une partie de mon stage à la comparaison des outils open source déjà présents comme a été
convenu dans ma mission de stage.
Le travail réalisé s’est avéré très enrichissant pour mon expérience professionnelle aussi bien
en ce qui concerne le domaine technique que l’aspect humain. Le fait de travailler de près avec
l’équipe qui supervise les projets menés par Mentat Conseil m’a permis d’avoir une vision
détaillée de la supervision et de la gestion de projets informatiques et m’a permis de voir en
quoi consistait le travail d’un ingénieur au sein d’une structure comme Mentat Conseil.
28
9. Références Bibliographiques
Adresse web de la société Mentat Conseil :
http://www.mentat-conseil.com/fr
Documentation
Intégration d’une table MySQL avec Apache Solr
http://lasithtechavenue.blogspot.fr/2013/11/crawling-mysql-database-with-apache-solr.html
http://www.sunilgulabani.com/2013/01/import-mysql-database-with-apache-solr.html
Définitions de moteurs de recherche
g-rossolini.developpez.com/tutoriels/solr/?page=introduction
ged-open-source.smile.fr/Les-fonctionnalites/Moteur-de-recherche
Introduction à Lucene
www.eolya.fr/2008/08/06/introduction-a-lucene/
Introduction à Solr
www.eolya.fr/2008/09/18/presentation-de-lucene-solr/
blog.touret.info/blog/index.php/post/2013/10/28/Premiers-pas-avec-SOLR
Comparaison des moteurs de recherche
www.journaldunet.com/solutions/0310/031002_pano_moteur3.shtml
blog.soat.fr/2013/07/elasticsearch/
blog.smile.fr/Elasticsearch-fait-de-l-ombre-a-solr
http://blog.tuquoque.com/post/2008/03/23/Comparaison-de-moteurs-de-recherche-open-source
29