La recherche Full Text avec Solr

Configurer un moteur de recherche performant à l'aide d'Apache Lucene/Solr et Apache Tomcat
Solr


précédentsommairesuivant

III. Installation et configuration des applications

III-A. Pré requis techniques

Si vous suivez cet article sur une machine Microsoft Windows, vous devez savoir installer des logiciels. Si vous avez un firewall sur votre machine, vous devez savoir le configurer pour permettre à Tomcat d'utiliser le réseau.

Si vous suivez cet article sur une machine Linux, vous devez être familier avec les lignes de commandes et un outil d'installation de paquets (apt-get ou autre). La compilation des logiciels n'est pas utile dans cet article.

Lucene est à la fois un logiciel d'indexation écrit en langage Java et un format de fichier. Il existe diverses implémentationsLucene implementations in languages other than Java dans des langages différents (je pense notamment à Zend_Search_Lucene pour Zend FrameworkGuide de référence Zend Framework : Zend_Search_Lucene), mais le principe général est d'obtenir un fichier d'index compatible Lucene. L'un des inconvénients de Lucene est le couplage fort avec sa partie logicielle. Il est par exemple difficile d'utiliser un index Lucene pour alimenter les recherches d'une entreprise entière, à cause de l'hétérogénéité de son parc informatique.

Chaque implémentation a ses conditions techniques. Pour utiliser la version Java de Lucene, une machine virtuelle Java (JVM) est nécessaire ; pour en utiliser la version Zend Framework, il faut disposer de PHP.

Pour sa part, Solr utilise le format d'index de Lucene mais la partie logicielle, écrite uniquement en langage Java, s'appuie sur un moteur de servlets/JSP comme Tomcat ou Jetty (voir une liste complèteLa boîte à outils du développeur Java : Serveurs sur la rubrique Java). Cela permet d'installer Solr sur un serveur et de l'interroger à distance (API RESTful) depuis tout système capable d'émettre des requêtes HTTP. On obtient alors une architecture client-serveur où le client peut prendre la forme d'un site web, d'une application desktop, d'un terminal mobile, etc. Afin d'utiliser Solr, il faut donc disposer d'un serveur Tomcat ou Jetty, qui ont eux-mêmes besoin d'une JVM ; de plus, il faut prévoir d'ouvrir un port du système d'exploitation (ou plusieurs, suivant le cas). Par conséquent, cela peut générer des inquiétudes de sécurité et la décision ne doit pas être prise à la légère.

Les exemples qui suivent traitent uniquement de Solr (version 3.3) installé sur un serveur Tomcat (version 6.0). Contrairement au tutoriel officiel, le fonctionnement de Solr sur Jetty ne sera pas traité ici.

Vous devez installer une JVM (au choix) :

Afin d'éviter la confusion causée par les allers et retours entre les mots Solr et Lucene, j'utiliserai désormais "Solr" même si certains paragraphes sont également vrais pour "Lucene".

III-B. Installer Tomcat

Je présenterai ici les étapes minimales pour installer Tomcat sous les deux systèmes que je connais à peu près : Linux et Microsoft Windows.

III-B-1. Installer Tomcat sous Microsoft Windows

Télécharger Tomcat : http://tomcat.apache.org/download-60.cgi

L'Apache Software Foundation fournit un installeur très facile à utiliser : "32-bit/64-bit Windows Service Installer", je vous le recommande plutôt que les ZIP. L'installation s'effectue donc sans problème. Si vous avez Microsoft Windows Vista ou 7 avec UAC, vous aurez quelques messages de confirmation à valider en tant qu'administrateur. À l'issue de l'installation, pensez à vérifier que l'utilisateur système utilisé par Tomcat a le droit d'écrire dans les dossiers installés, particulièrement dans "work" et dans les logs.

À noter que l'installeur de l'ASF ne nous oblige pas à manipuler les variables d'environnement de notre système, contrairement à ce que certains articles peuvent laisser croire.

Après installation, ouvrez la page d'accueil de Tomcat avec votre navigateur pour vérifier que tout fonctionne comme prévu : http://localhost:8080

Vous pouvez arrêter et démarrer Tomcat à l'aide de l'application "Monitor Tomcat" dont le raccourci se trouve dans le menu démarrer. Si vous avez Microsoft Windows Vista ou 7 avec UAC, vous devrez le lancer en tant qu'administrateur.

Vous pouvez utiliser Junction, dont j'ai déjà parlé dans un autre articleSysinternals Junction, pour déplacer le répertoire "conf" hors du disque système à la manière des liens symboliques d'Unix/Linux.

Dans la suite de l'article, je vais utiliser la variable $CATALINA_HOME pour faire référence au dossier d'installation de Tomcat.

III-B-2. Installer Tomcat sous Linux

Avant d'installer des applications à l'aide d'apt-get, pensez à lancer apt-get update. Cela vous assurera d'obtenir les dernières versions disponibles pour votre système.

Le chemin d'installation dépend de votre distribution et de vos habitudes. Le wiki de Solr préconise /opt/tomcat mais, pour ma part, je vais vous proposer /usr/local/lib/tomcat. Vous pouvez compiler vous-mêmes Tomcat mais ce n'est pas nécessaire, dans la mesure où l'Apache Software Foundation propose les binaires en téléchargement. Afin de ne pas confondre les lecteurs moins expérimentés, je ne traiterai donc pas la compilation ici.

Comme nous l'avons mentionné précédemment, vous aurez besoin d'une machine virtuelle Java : soit celle d'Oracle, soit celle d'OpenJDK. La licence de celle d'Oracle est peut-être restrictive pour vous, tandis qu'OpenJDK est peut-être moins optimal techniquement (les opinions à ce sujet sont diverses et variées). À vous de voir laquelle vous inspire le plus confiance. Lancez l'une de ces deux commandes :

 
Sélectionnez
apt-get install sun-java6-jre
 
Sélectionnez
apt-get install openjdk-6-jre

Lancer la commande suivante pour disposer de la variable d'environnement JAVA_HOME (modifiez le chemin selon votre installation) :

 
Sélectionnez
JAVA_HOME=/usr/lib/jvm/java-6-openjdk/jre

Ajouter la ligne suivante au fichier /etc/profile afin de rendre cette variable disponible à chaque ouverture de session (modifiez le chemin selon votre installation) :

 
Sélectionnez
export JAVA_HOME=/usr/lib/jvm/java-6-openjdk/jre

Nous allons éviter de lancer Tomcat en tant qu'utilisateur root. Pour cela, on peut utiliser sudo. Si vous ne l'avez pas encore, c'est le moment de l'installer :

 
Sélectionnez
apt-get install sudo

Création de l'utilisateur système qui exécutera Tomcat. Cette ligne peut être adaptée suivant votre système et vos habitudes, par exemple ici j'ai mis le groupe 33 qui correspond à www-data, créé lorsque j'ai installé Apache httpd. Nous ne donnons pas de shell à cet utilisateur, il ne nous est donc pas demandé de mot de passe.

 
Sélectionnez
useradd tomcat -m -d /home/tomcat -g 33 -s /bin/false -c "Apache Tomcat server"

Installation de Tomcat :

 
Sélectionnez
# Télécharger puis extraire Tomcat
cd /usr/local/src
wget http://mirror.ibcp.fr/pub/apache//tomcat/tomcat-6/v6.0.29/bin/apache-tomcat-6.0.29.tar.gz
tar -xzf apache-tomcat-6.0.29.tar.gz
mv apache-tomcat-6.0.29 /usr/local/lib/tomcat

# Lien pour retrouver la conf de Tomcat à côté des autres dans /etc
ln -s /usr/local/lib/tomcat/conf /etc/tomcat

# Droits d'accès pour l'utilisateur système
chown -R tomcat:www-data /usr/local/lib/tomcat
chown tomcat:www-data /etc/tomcat

Si le lien direct de cet exemple pour télécharger Tomcat ne fonctionne pas, rendez-vous sur http://www.apache.org/dyn/closer.cgi/tomcat/ et trouvez-en un autre.

Créer le script de démarrage /etc/init.d/tomcat :

 
Sélectionnez
#!/bin/bash
#
# tomcat
#
# chkconfig:
# description:  Start up the Tomcat servlet engine.

CATALINA_HOME=/usr/local/lib/tomcat

case "$1" in
    start)
        if [ -f $CATALINA_HOME/bin/catalina.sh ];
        then
            echo $"Starting Tomcat"
            sudo -u tomcat $CATALINA_HOME/bin/catalina.sh start
        fi
    ;;

    stop)
        if [ -f $CATALINA_HOME/bin/catalina.sh ];
        then
            echo $"Stopping Tomcat"
            sudo -u tomcat $CATALINA_HOME/bin/catalina.sh stop
        fi
    ;;

    restart)
        if [ -f $CATALINA_HOME/bin/catalina.sh ];
        then
            echo $"Stopping Tomcat"
            sudo -u tomcat $CATALINA_HOME/bin/catalina.sh stop
            echo $"Starting Tomcat"
            sudo -u tomcat $CATALINA_HOME/bin/catalina.sh start
        fi
    ;;

    *)
        echo $"Usage: $0 {start|stop|restart}"
        exit 1
    ;;
esac

Modifier les droits d'exécution du script de démarrage :

 
Sélectionnez
chmod a+x /etc/init.d/tomcat

Vérifier que tout fonctionne en trois commandes :

1° commande : Démarrer Tomcat
Sélectionnez
/etc/init.d/tomcat start
Affichage attendu :
Sélectionnez
Starting Tomcat
Using CATALINA_BASE:   /usr/local/lib/tomcat
Using CATALINA_HOME:   /usr/local/lib/tomcat
Using CATALINA_TMPDIR: /usr/local/lib/tomcat/temp
Using JRE_HOME:        /usr
Using CLASSPATH:       /usr/local/lib/tomcat/bin/bootstrap.jar
2° commande : Liste des programmes en exécution, avec leur utilisateur
Sélectionnez
ps -eo user,pid,fname | grep tomcat
Affichage attendu (le pid varie) :
Sélectionnez
tomcat 8313 java
3° commande : Liste des sockets réseau ouverts
Sélectionnez
netstat -ap | grep java
Affichage attendu (la ligne importante est celle affichant "http-alt", qui correspond à 8080) :
Sélectionnez
tcp        0      0 localhost.localdom:8005 *:*                     LISTEN      10462/java
tcp        0      0 *:8009                  *:*                     LISTEN      10462/java
tcp        0      0 *:http-alt              *:*                     LISTEN      10462/java

Ouvrez la page d'accueil de Tomcat avec un navigateur :
http://localhost:8080

Après avoir constaté que tout fonctionne, assurons-nous que le système sache démarrer Tomcat automatiquement, puis arrêtons Tomcat afin de le configurer (Solr + sécurité) :

 
Sélectionnez
update-rc.d tomcat defaults
/etc/init.d/tomcat stop

Dans la suite de l'article, je vais utiliser la variable $CATALINA_HOME pour faire référence au dossier d'installation de Tomcat.

III-C. Ajouter la webapp Solr à Tomcat

III-C-1. Installer Solr sous Microsoft Windows

Télécharger Solr : http://www.apache.org/dyn/closer.cgi/lucene/solr/

Copier le fichier "dist\apache-solr-3.3.0.war", situé dans cette archive, vers un dossier "Solr" où vous souhaitez conserver les fichiers de Solr, par exemple dans "Mes Documents\Solr". Dans la mesure où ce dossier contiendra à la fois l'application Solr ainsi que les fichiers de configuration et les données de chaque index, il est préférable de choisir un dossier hors du disque système. De nouveau, vous avez la possibilité d'utiliser Sysinternals Junction pour obtenir un jeu de liens symboliques.

Créer un dossier "cores" à côté du fichier WAR.

Le dossier que vous avez choisi constituera la variable solr/home pour Tomcat, et nous y ferons référence en tant que $SOLR_HOME dans la suite de l'article.

Passer le chapitre "Installer Solr sous Linux" et continuer avec le chapitre suivant.

III-C-2. Installer Solr sous Linux

 
Sélectionnez
# Préparer les répertoires
mkdir /home/tomcat/solr
mkdir /home/tomcat/solr/cores

# Télécharger puis extraire Solr
cd /usr/local/src
wget http://www.sharethecoupon.com/apache/lucene/solr/3.3.0/apache-solr-3.3.0.tgz
tar -xzf apache-solr-3.3.0.tgz
cp apache-solr-3.3.0/dist/apache-solr-3.3.0.war /home/tomcat/solr/

# Droits d'accès pour l'utilisateur système
chown -R tomcat:www-data /home/tomcat/solr

Si le lien direct de cet exemple pour télécharger Solr ne fonctionne pas, rendez-vous sur http://www.apache.org/dyn/closer.cgi/lucene/solr/ et trouvez-en un autre.

Ajouter au fichier /etc/profile :

 
Sélectionnez
export LOGGING_CONFIG=/home/tomcat/solr/logging.properties

Le dossier que vous avez choisi constituera la variable solr/home pour Tomcat, et nous y ferons référence en tant que $SOLR_HOME dans la suite de l'article.

III-C-3. Configuration de Tomcat pour utiliser Solr

Nous avons installé Tomcat dans $CATALINA_HOME et le fichier WAR de Solr dans $SOLR_HOME, puis nous nous sommes assurés que l'utilisateur de Tomcat puisse lire et écrire dans ces deux dossiers. Tomcat n'est pas encore lancé.

Nous allons modifier le fichier de configuration le plus haut niveau de Tomcat afin de réduire les adresses IP pouvant interroger Tomcat. Pour cela, ouvrir $CATALINA_HOME/conf/server.xml avec un éditeur de texte, trouver le nœud <Host> correspondant à localhost et ajouter cette ligne avant le tag </Host> :

 
Sélectionnez
<Valve className="org.apache.catalina.valves.RemoteAddrValve" allow="127.0.0.1"/>

Une restriction RemoteAddrValve peut être placée à divers endroits de la configuration de Tomcat. Ma suggestion ci-dessus s'applique à l'ensemble de localhost mais pas à l'ensemble de Tomcat, elle est donc plus globale que seulement Solr mais elle n'est pas absolue. À vous de trouver le(s) bon(s) endroit(s) pour appliquer cette restriction selon votre cas. Vous pouvez mettre plusieurs adresses IP en les séparant par des virgules, par exemple : "127.0.0.1,10.0.0.1,192.168.1.1".

Le conseil de restriction ci-dessus vous empêchera d'accéder à Tomcat si vous n'utilisez pas la bonne URL. Par exemple, selon votre système, utiliser "http://localhost:8080/" peut donner une page d'erreur alors que "http://127.0.0.1:8080/" fonctionne, dans la mesure où "localhost" n'est pas strictement équivalent à "127.0.0.1". Pour faire simple, n'utilisez RemoteAddrValve que si vous avez besoin de protéger votre Tomcat !

Nous allons créer le fichier permettant à Tomcat d'identifier la nouvelle webapp, Solr. Tomcat organise ses fichiers de configuration grâce à la directive Host name="..." du fichier $CATALINA_HOME/conf/web.xml en les plaçant sous $CATALINA_HOME/conf/Catalina/... : par exemple, une directive Host name="localhost" correspond au dossier $CATALINA_HOME/conf/Catalina/localhost. En fait, ce dossier localhost existe déjà sur votre système et il contient un ou deux fichiers XML, notamment manager.xml. Ainsi, afin d'indiquer à Solr que le serveur "localhost" doit charger la webapp "solr", il faut créer un fichier $CATALINA_HOME/conf/Catalina/localhost/solr.xml, accessible depuis : http://localhost:8080/solr/

Ce fichier est lu par Tomcat, qui a accès au système de fichiers, les chemins sont donc ceux du système de fichiers :

$CATALINA_HOME/conf/Catalina/localhost/solr.xml
Sélectionnez
<?xml version="1.0" encoding="utf-8"?>
<Context docBase="/home/tomcat/solr/apache-solr-3.3.0.war" crossContext="true" cachingAllowed="true">
    <Environment name="solr/home" type="java.lang.String" value="/home/tomcat/solr" override="true" />
</Context>

Pensez à modifier <Context docBase et <Environment value selon vos valeurs (il s'agit de chemins d'accès absolus vers $SOLR_HOME sur le système).

Puis nous allons créer le fichier de configuration de la webapp Solr. Les valeurs <cores adminPath et <core name sont des URL relatives à http://localhost:8080/solr/. Ce fichier n'est pas lu directement par Tomcat mais plutôt par Solr. Ainsi, les valeurs <core instanceDir sont des chemins d'accès (du système de fichiers) relatifs à $SOLR_HOME :

$SOLR_HOME/solr.xml
Sélectionnez
<?xml version="1.0" encoding="utf-8"?>
<solr persistent="false">
    <cores adminPath="/admin/cores">
        <core name="clients" instanceDir="cores/clients" />
        <core name="fournisseurs" instanceDir="cores/fournisseurs" />
        <core name="produits" instanceDir="cores/produits" />
    </cores>
</solr>

Le fichier $SOLR_HOME/solr.xml permet également d'utiliser le composant CoreAdmin que nous avons évoqué au chapitre II-C-3.

III-D. Ajouter des noyaux à Solr

III-D-1. En théorie

Un noyau Solr utilise plusieurs répertoires :
  • $SOLR_HOME/cores/CORENAME/conf
  • $SOLR_HOME/cores/CORENAME/data
  • $SOLR_HOME/cores/CORENAME/spell
  • $SOLR_HOME/cores/CORENAME/...

Seul le répertoire "conf" est obligatoire. Les autres répertoires sont utilisés pour emmagasiner les différents index : data pour les données, spell pour le correcteur orthographique, etc. Ces répertoires supplémentaires sont créés automatiquement par Solr lorsque Tomcat démarre, il n'est donc pas nécessaire de les créer vous-même.

Ainsi, dans notre exemple, nous avons besoin de créer les répertoires suivants :
  • $SOLR_HOME/cores/clients/conf
  • $SOLR_HOME/cores/fournisseurs/conf
  • $SOLR_HOME/cores/produits/conf

Comme nous l'avons évoqué précédemment, un noyau est composé au minimum de deux fichiers : schema.xml décrit les types de données de l'index de données et solrconfig.xml décrit l'API (principe RESTful) permettant d'utiliser le noyau. Dans un premier temps, nous allons utiliser deux fichiers minimalistes afin de démarrer notre application Solr. Cela nous permettra de nous familiariser avec son interface d'administration avant de commencer à envoyer des commandes XML :

$SOLR_HOME/cores/produits/conf/schema.xml
Sélectionnez
<?xml version="1.0" encoding="UTF-8"?>
<schema>
</schema>
$SOLR_HOME/cores/produits/conf/solrconfig.xml
Sélectionnez
<?xml version="1.0" encoding="UTF-8" ?>
<config>
</config>

Un noyau peut fonctionner avec les fichiers ci-dessus mais il est préférable de leur donner un minimum de contenu, ne serait-ce que pour indiquer l'emplacement des données de l'index de données :

$SOLR_HOME/cores/produits/conf/schema.xml
Sélectionnez
<?xml version="1.0" encoding="UTF-8"?>
<schema name="Tutoriel Solr - Clients" version="1.2">
</schema>
$SOLR_HOME/cores/produits/conf/solrconfig.xml (remplacer "/PATH/TO/SOLR/HOME" par votre chemin système)
Sélectionnez
<?xml version="1.0" encoding="UTF-8" ?>
<config>
    <abortOnConfigurationError>true</abortOnConfigurationError>
    <dataDir>/PATH/TO/SOLR/HOME/cores/produits/data</dataDir>
</config>

Si vous avez plusieurs environnements de travail, par exemple DEV + TEST + PROD, il peut être utile de séparer les valeurs des fichiers XML, en particulier dans le cas de solrconfig. C'est possible en créant un fichier "solrcore.properties" dans le répertoire "conf". De cette manière, ce qui change entre les différents environnements est centralisé dans un fichier INI assez court. La transition d'un environnement à l'autre est ainsi bien plus simple que de rechercher les valeurs dans plusieurs longs fichiers XML (et à coup sûr en oublier la moitié) :

$SOLR_HOME/cores/produits/conf/schema.xml
Sélectionnez
<?xml version="1.0" encoding="UTF-8"?>
<schema name="${solr.schema.name}" version="1.2">
</schema>
$SOLR_HOME/cores/produits/conf/solrconfig.xml
Sélectionnez
<?xml version="1.0" encoding="UTF-8" ?>
<config>
    <abortOnConfigurationError>${solr.config.abortOnConfigurationError}</abortOnConfigurationError>
    <dataDir>${solr.config.dataDir}</dataDir>
</config>
$SOLR_HOME/cores/produits/conf/solrcore.properties (remplacer "/PATH/TO/SOLR/HOME" par votre chemin système)
Sélectionnez
solr.config.abortOnConfigurationError = true
solr.config.dataDir = /PATH/TO/SOLR/HOME/cores/produits/data
solr.schema.name = Tutoriel Solr - Produits

Ici, j'ai choisi de reprendre les noms des nœuds XML comme noms de variables dans le fichier solrcore.properties mais ce n'est pas obligatoire. Le préfixe "solr." est lui aussi facultatif, je l'utilise pour être assuré d'éviter les conflits de noms avec des variables existantes. Ce fichier aurait aussi bien pu contenir les variables abort_on_error, data_path et schema_name, qui auraient été appelées respectivement ${abort_on_error}, ${data_path} et ${schema_name} dans le XML.

En l'état, nos noyaux Solr se lancent mais ils ne sont pas fonctionnels. C'est-à-dire que la webapp démarre sans problème mais, les noyaux n'ayant ni schéma ni API, on ne peut rien en faire. Nous allons les configurer dans la suite de cet article.

III-D-2. Configuration minimale d'un noyau

Afin de pouvoir utiliser les exemples de cet article avec notre propre noyau, nous allons prendre un peu d'avance sur le chapitre dédié à la configuration de l'API de notre application Solr, qui arrivera en fin d'article. Nous allons ajouter deux segments de code permettant de charger la page d'administration et d'exécuter des requêtes simples :

$SOLR_HOME/cores/produits/conf/solrconfig.xml
Sélectionnez
<?xml version="1.0" encoding="UTF-8" ?>
<config>
    <abortOnConfigurationError>${solr.config.abortOnConfigurationError}</abortOnConfigurationError>
    <dataDir>${solr.config.dataDir}</dataDir>

    <requestHandler name="standard" class="solr.SearchHandler" default="true"/>
    <requestHandler name="/admin" class="solr.admin.AdminHandlers" />
</config>

III-D-3. En pratique : installer le noyau d'exemple

Comme nous l'avons vu précédemment, le fichier téléchargé de Solr contient le fichier WAR que nous avons utilisé pour configurer la webapp Solr dans Tomcat. Nous allons maintenant copier le noyau d'exemple fourni dans la même archive.

Cette archive contient deux types d'exemples : le dossier "solr" à la racine contient une configuration complète donnant une vue d'ensemble de toutes les fonctionnalités disponibles ; le dossier "multicore", également à la racine, contient deux noyaux pour démontrer principalement la fonctionnalité dont nous avons déjà parlé : installer plusieurs noyaux côte-à-côte dans la même webapp. Dans la mesure où cette fonctionnalité "multicore" a déjà été configurée précédemment dans ce tutoriel, nous allons utiliser l'exemple complet.

Ainsi, copiez vers votre dossier des noyaux le dossier "example/solr" de l'archive et renommez-le en "exemple" :
  • $SOLR_HOME/cores/clients
  • $SOLR_HOME/cores/exemple
  • $SOLR_HOME/cores/fournisseurs
  • $SOLR_HOME/cores/produits

Dans la mesure où ce noyau est prévu pour fonctionner seul, sa configuration ne tient pas compte des noyaux multiples. Sans aller jusqu'à tout modifier, nous allons nous contenter d'une légère adaptation pour que les données de son index ne soient pas enregistrées n'importe où. Dans le fichier $SOLR_HOME/cores/exemple/conf/sorconfig.xml, modifiez le nœud <dataDir> de la manière suivante :

 
Sélectionnez
<dataDir>${solr.data.dir:./solr/cores/exemple/data}</dataDir>

Chaque fois que vous ajoutez un noyau à Solr, pensez à l'activer dans le fichier solr.xml puis à redémarrer Tomcat :

$SOLR_HOME/solr.xml
Sélectionnez
<?xml version="1.0" encoding="utf-8"?>
<solr persistent="false">
    <cores adminPath="/admin/cores">
        <core name="clients" instanceDir="cores/clients" />
        <core name="exemple" instanceDir="cores/exemple" />
        <core name="fournisseurs" instanceDir="cores/fournisseurs" />
        <core name="produits" instanceDir="cores/produits" />
    </cores>
</solr>

Une fois Tomcat redémarré, vous devriez constater que Solr a créé un dossier "data" dans chacun des noyaux, et notamment dans "exemple". Avant de continuer la lecture de ce tutoriel, vérifier dans un navigateur que tous les noyaux sont bien présents :

Admin des noyaux
Image 1 : Admin des noyaux

Les noyaux affichés dans votre navigateur sont prêts à être utilisés. Cependant, ils ne contiennent encore aucun document. Il est donc inutile d'essayer de lancer des recherches pour le moment. Si vous savez envoyer un fichier avec la méthode HTTP POST à un serveur web, vous pouvez le faire dès à présent pour remplir le noyau d'exemple à l'aide des fichiers XML et du fichier CSV présents dans le dossier "example/exampledocs" de l'archive de Solr. Si vous savez les utiliser, ce même dossier contient deux fichiers post.sh et post.jar pour vous aider dans cette tâche. Sinon, vous pouvez continuer la lecture de cet article, nous apprendrons à mettre à jour un index au chapitre V-G.

Voici comment utiliser le script donné au chapitre V-G pour remplir votre noyau "exemple" :

Exemple d'utilisation en lignes de commandes (Linux et MacOS) :
Sélectionnez
./send.php exemple string "<delete><query>*:*</query></delete>"
./send.php exemple file hd.xml
./send.php exemple file ipod_other.xml
./send.php exemple file ipod_video.xml
./send.php exemple file mem.xml
./send.php exemple file monitor.xml
./send.php exemple file monitor2.xml
./send.php exemple file mp500.xml
./send.php exemple file payload.xml
./send.php exemple file sd500.xml
./send.php exemple file solr.xml
./send.php exemple file vidcard.xml
./send.php exemple string "<optimize waitSearcher='true'/>"
Exemple d'utilisation en lignes de commandes (Windows) :
Sélectionnez
php.exe send.php exemple string "<delete><query>*:*</query></delete>"
php.exe send.php exemple file hd.xml
php.exe send.php exemple file ipod_other.xml
php.exe send.php exemple file ipod_video.xml
php.exe send.php exemple file mem.xml
php.exe send.php exemple file monitor.xml
php.exe send.php exemple file monitor2.xml
php.exe send.php exemple file mp500.xml
php.exe send.php exemple file payload.xml
php.exe send.php exemple file sd500.xml
php.exe send.php exemple file solr.xml
php.exe send.php exemple file vidcard.xml
php.exe send.php exemple string "<optimize waitSearcher='true'/>"

précédentsommairesuivant

Vous avez aimé ce tutoriel ? Alors partagez-le en cliquant sur les boutons suivants : Viadeo Twitter Facebook Share on Google+   

  

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2010 Guillaume Rossolini. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.