Version du 1 décembre 2014 à 23:10

Cette page est destinée aux utilisateurs confirmés d'ElasticSearch qui souhaitent utiliser JDONREF. Si des éléments vous échappent dans cette page, je vous invite à revoir la page des débutants.

L'utilisation du plugin JDONREFv4 nécessite :

• de disposer d'un cluster elasticsearch !
• d'installer le plugin JDONREFv4 (voir ici)
• de créer le ou les index nécessaires
• de créer les mappings
• puis d'indexer le contenu

Vous êtes ensuite libre d'effectuer les recherches souhaitées ! L'API elasticsearch peut bien sûr être utilisée, mais le plugin jdonrefv4 fourni un moyen de chercher efficacement des adresses (c'est à dire avec les résultats auxquels on devrait s'attendre). Cette page suppose que le cluster elasticsearch et que le plugin jdonref (et éventuelles dépendances) sont installés.

Création de l'index

La version débutant de la création de l'index propose :

 curl -XPUT 'http://localhost:9200/jdonref/' -d @/usr/share/elasticsearch/plugins/jdonrefv4-0.2/jdonref-settings.json

Vous pouvez noter plusieurs choses au sujet de cette configuration d'index :

• Les analyzers jdonrefv4_synonyme et jdonrefv4_nGram sont des versions améliorées des analyzers correspondant d'Elasticsearch. Si vous souhaitez utiliser des synonymes ou des nGrams avec JDONREF, ces variantes doivent être utilisées. Elles sont simplement compatibles avec les payloads.
• A noter que le metaphone n'est plus utilisé pour le moment, car combiné au ngram, il introduit un trop grand nombre de faux positifs. Vous pouvez toutefois le mettre en place à votre guise.
• Le "french_keywords" peut être rétabli si vous notez quelques mots auxquels l'application du stemmer ne fournis pas de bons résultats.

Dans le reste de cette page, cette installation est plusieurs fois remise en cause. Lisez jusqu'au bout.

Un alias

Ces remarques signifient surtout que ce plugin n'est qu'un outil. Vous pouvez l'utiliser à votre guise, modifier le fichier de configuration fourni, et adapter les analyzers à votre propre cas de figure.

A titre d'exemple, vous souhaiterez sans doute effectuer des mises à jour de JDONREF. Si vous effectuez une mise à jour en masse de l'ensemble de vos adresses, vous aurez une interruption de service. Plutôt que d'utiliser un index, elasticsearch vous propose d'utiliser un alias :

 curl -XPUT 'http://localhost:9200/jdonref_20141201/' -d @/usr/share/elasticsearch/plugins/jdonrefv4-0.2/jdonref-settings.json
 ... indexation ...
 curl -XPOST 'http://localhost:9200/_aliases/' -d '{ "actions" : [ {"add" : {"index" : "jdonref_20141201", "alias" : "jdonref"}}]}'

Ce qui vous permettra d'utiliser l'alias "jdonref" tout comme un index, et de réindexer sous un autre nom pour effectuer une mise à jour :

 curl -XPUT 'http://localhost:9200/jdonref_20141202/' -d @/usr/share/elasticsearch/plugins/jdonrefv4-0.2/jdonref-settings.
 ... réindexation ...
 curl -XPOST 'http://localhost:9200/_aliases/' -d '{ "actions" : [ {"add" : {"index":"jdonref_20141202", "alias":"jdonref"}}, {"remove" : {"index":"jdonref_20141201", "alias":"jdonref"}}]}'

Bon. Cela dit j'avais présupposé dans l'introduction que vous étiez familiers de elasticsearch ... Vous ne m'y reprendrez plus. Passons aux choses sérieuses !

Fréquences

  Le reste de cette page est en cours de correction !

En tant que moteur de recherche à index inversé, ElasticSearch est efficace pour effectuer des recherches sur des termes peu fréquents, aussi nombreux soient-ils. Ses fonctionnalités de mises en cache permettent aussi d'obtenir de bonnes performances à l'usage sur les termes plus fréquents, et fréquemment utilisés.

Quelques chiffres : 1. 32 000 communes ; 2. 1 200 000 voies ; 3. 18 000 000 adresses ;

Ce qui signifie une moyenne de 18 adresses pour une même voie. Ce qui signifie aussi une moyenne de 37 voies par commune (bien sûr parfois beaucoup plus !).

En quoi est-ce important ? Cherchez "PARIS" parmi les communes : vous obtenez quelques dizaines de résultat (PARISIS, ...). Cherchez "PARIS" parmi les voies : vous en obtenez mécaniquement au moins 30 fois plus. Cherchez "PARIS" parmi les adresse : le facteur est de 600, soit un nombre à 5 chiffres.

D'accord, ce n'est pas très impressionnant, mais PARIS n'est pas le terme le plus fréquent. Lorsque vous cherchez "RUE" parmi les adresses, ceux sont 12 000 000 de documents qui sont concernés. Sur ma plateforme de test de 6 coeurs virtuels, 40 Go de RAM, 5 shards, cela prend environ 2 minutes (si vous n'avez pas de timeout avant !) ...

Vous avez alors deux stratégies :

• Elasticsearch est scalable ... et vous avez les moyens de le rendre scalable. Comptez 8 coeurs pour 8 départements. La recherche de toutes les RUE de France devient alors humainement possible.
• Vous tentez comme moi d'optimiser le tout.

Optimisation

  Le reste de cette page est en cours de rédaction

Indexation du contenu

Il est ensuite possible d'indexer du contenu, comme une commune :

 curl -XPUT 'http://localhost:9200/jdonref/commune/1' -d '{
   "code_insee" : "75056",
   "code_departement" : "75",
   "code_pays" : "1",
   "commune" : "PARIS",
   "code_postal" : "75000",
   "ligne7" : "FRANCE",
   "type" : "commune",
   "t0" : "22/03/2014",
   "geometrie" : {
       "type": "multipolygon",
       "coordinates" : [
          [[102.0, 2.0], [103.0, 2.0], [103.0, 3.0], [102.0, 3.0], [102.0, 2.0]],
          [[100.0, 0.0], [101.0, 0.0], [101.0, 1.0], [100.0, 1.0], [100.0, 0.0]],
          [[100.2, 0.2], [100.8, 0.2], [100.8, 0.8], [100.2, 0.8], [100.2, 0.2]]
       ]
   }
 }'

ou une voie :

 curl -XPUT 'http://localhost:9200/jdonref/voie/1' -d '{
   "numero_min": "1",
   "numero_max": "192",
   "type_de_voie": "BOULEVARD",
   "article": "DE",
   "voie": "HOPITAL",
   "code_insee_commune" : "75056",
   "code_postal" : "75013",
   "code_insee": "75113",
   "code_departement" : "75",
   "code_pays" : "FR1",
   "commune" : "PARIS",
   "ligne4" : "BOULEVARD DE L HOPITAL",
   "ligne6" : "75013 PARIS",
   "ligne7" : "FRANCE",
   "type": "voie",
   "t0" : "22/03/2014",
   "geometrie" : {
       "type": "multipolygon",
       "coordinates" : [
          [[102.0, 2.0], [103.0, 2.0], [103.0, 3.0], [102.0, 3.0], [102.0, 2.0]],
          [[100.0, 0.0], [101.0, 0.0], [101.0, 1.0], [100.0, 1.0], [100.0, 0.0]],
          [[100.2, 0.2], [100.8, 0.2], [100.8, 0.8], [100.2, 0.8], [100.2, 0.2]]
       ]
   }
 }'

Indexation en masse

A noter qu'il est conseillé d'utiliser l'API [BULK] d'ElasticSearch pour procéder à l'indexation d'un très grand nombre d'adresses.

Attention, pour que la requête du plugin fonctionne correctement, certains champs doivent être correctement renseignés (voir mappings).

Recherches

Une fois le contenu indexé, il vous est possible d'effectuer des recherches à loisir !

Optimisation (une fois que vous vous êtes sortis du reste)

Pour utiliser le paramètre maxSizePerType de la requête JDONREF, il est conseillé (obligatoire) de répartir les types sur de multiples index. D'une manière générale, il est même plus que conseillé de répartir les communes, départements et pays sur un unique shard (avec des réplicats, et potentiellement sur différents index).

A cet effet, et pour simplifier le fonctionnement de l'ensemble, il est possible d'utiliser des alias elasticsearch. Un alias permet de "contenir" différent index. Lorsqu'une requête est faite sur un alias, tous les index de l'alias sont requêtés (et le résultat aggrégé).

Les index de mon cluster sont répartis ainsi (via un batch) :

1. alias jdonref
2. index pays, 1 shard + 1 réplica
3. index departement, 1 shard + 1 réplica
4. index commune, 1 shard + 1 réplica
5. index voie, 5 shards + 1 réplica
6. index adresse, 5 shards + 1 réplica
7. index poizon, 5 shards + 1 réplica

NB: Je n'indexe pas les troncons, je n'en ai pas l'usage. NB: Notez que vous pourriez aussi choisir de regrouper pays, departement et commune. Il faut savoir que dans un même index, les fréquences des termes sont cumulés. Dans le même index, les communes auront donc une influence sur la fréquence des termes des pays. A vous de voir.

Cela me permet de définir maxSizePerType à 5000 (voir optimisation), pour éviter de polluer certaines requêtes avec des résultats d'adresse superflus. Bien sûr, il est nécessaire d'adapter les requêtes de création des index, des mappings, et d'ajouter la création d'un alias.

Par exemple pour les index de pays, departement, commune, il s'agit simplement d'ajouter "number_of_shards" et "number_of_replicas". Ici l'exemple incomplet de l'index des pays :

 curl -XPUT 'http://localhost:9200/jdonref_pays/' -d '{
    "index" : {
       "number_of_shards" : 1,
       "number_of_replicas" : 1,
       "analysis" : {
           "analyzer": {
               "jdonrefv4_index" : {
                   "type" : "custom",
                   "tokenizer" : "whitespace",
                   "filter" : ["delimited_payload_filter", "lowercase", "french_elision", "french_stop", /*/"french_keywords",*/ "french_stemmer","jdonrefv4_synonyme", "jdonrefv4_nGram"]
               },
               "jdonrefv4_codes_index" : {
                   "type" : "custom",
                   "tokenizer" : "standard",
                   "filter" : ["standard", "lowercase"]
               },
 ...

Le mapping du pays doit bien sûr être réalisé sur l'index du pays ...

 $ curl -XPUT 'http://localhost:9200/jdonref_pays/pays/_mapping' -d '{
   "pays": {
      "_type": {"store": true},
     "_source": {"excludes": ["geometrie"]},
     "properties" : { 
                          "code_pays" : { "type" : "string" , "term_vector" : "with_positions_offsets", "index_analyzer":"jdonrefv4_codes_index","search_analyzer":"jdonrefv4_search", "similarity":"jdonrefv4"},
                          "pays" : { "type" : "string" , "index": "no"},
                          "t0" : { "type" : "date", "format": "YYYY-MM-dd HH:mm:ss", "index":"not_analyzed"},
                          "t1" : { "type" : "date", "format": "YYYY-MM-dd HH:mm:ss", "index":"not_analyzed"},
                          "ligne7" : { "type" : "string", "term_vector" : "with_positions_offsets", "index_analyzer":"jdonrefv4_index","search_analyzer":"jdonrefv4_search", "similarity":"jdonrefv4"},
                          "pin" : { "properties" : { "centroide" : { "type" : "geo_point" , "fielddata" : { "format" : "compressed" , "precision" : "1cm"}}}},
                          "geometrie" : { "type" : "geo_shape", "precision": "1cm", "tree": "quadtree"},
                          "fullName" : {"type": "string", "term_vector" : "with_positions_offsets_payloads", "index_analyzer":"jdonrefv4_index_token_count","search_analyzer":"jdonrefv4_search", "similarity":"jdonrefv4"}
                     },
     "transform" : {
         "lang" : "groovy",
         "script" : "ctx._source['fullName'] = ; if (ctx._source['ligne7']!=null) { def tokens = ctx._source['ligne7'].split(' '); for(x in tokens) ctx._source['fullName'] += ' ' + x + '|9'; }; if (ctx._source['code_pays']!=null) { def tokens = ctx._source['code_pays'].split(' '); for(x in tokens) ctx._source['fullName'] += ' ' + x + '|10'; };"
     }
 }
}'

et enfin le pays peut être rattaché à l'alias jdonref :

 $ curl -XPOST 'http://localhost:9200/_aliases' -d '{
 {"actions":[{"add":{"index":"jdonref_pays","alias":"jdonref"}}]}'

Idem pour les autres types (n'oubliez pas d'ajouter des shards pour les voies, adresses et poizon).

Vous êtes alors prêt à utiliser une requête avec maxSizePerType comme ici.

Pour être clair, avec maxSizePerType défini à 10 000, d'après les statistiques de fréquence fournies par elasticsearch sur la base IGN 2013, les adresses composées exclusivement des 84 termes suivant nécessiteront la saisie du code postal ou du code insee (sauf 6 communes pour lesquels le code insee est trop fréquent, voir la liste). Chaque terme est présenté avec sa fréquence.

• france 18934777
• rue 12000419
• avenue 1520128
• saint 2726561
• chemin 1357589
• route 1289752
• bis 1068563
• mont 726556
• impasse 724520
• jean 557596
• boulevard 475745
• grand 430452
• chateau 409622
• place 399026
• arondi 284874
• pont 247505
• tour 223095
• paul 222773
• cour 217926
• moulin 215612
• fer 215394
• champ 212369
• ter 211768
• general 199648
• george 197359
• pari 194572
• loui 193026
• marti 176915
• mare 173454
• mars 168783
• eglis 163259
• bourg 162933
• fontain 157604
• petit 151460
• martin 148328
• gaul 140728
• marseil 132682
• henri 126197
• 75056 126166
• toulo 124260
• marechal 121251
• 13055 121706
• francoi 95722
• vileneuv 88587
• leclerc 86265
• michel 84657
• toulous 82922
• principal 79712
• cote 77054
• mauric 76601
• joseph 76017
• albert 75560
• rose 73350
• nation 72777
• national 70177
• germain 64366
• havr 63465
• 33063 63202
• foret 62521
• 76351 60353
• laure 60243
• verdun 60034
• robe 59093
• lauren 58637
• mine 58423
• provenc 58235
• claud 57540
• colomb 56648
• sabl 55834
• lyon 55469
• chatel 55437
• laurent 55078
• quai 53053
• 44109 52810
• epi 52666
• aube 52162
• august 51570
• guy 51558
• parc 51553
• roue 51505
• jardin 51078
• gambeta 50623
• 59350 50235
• roy 50131

Debug (inaccessible pour le moment, en attente du scoring et du mode bulk)

Pour les experts, un mode debug est disponible avec le paramètre debugDoc de la sorte :

 curl -XPOST 'http://localhost:9200/jdonref/_search' -d '{
   "query": {
     "jdonrefv4" : {
       "value" : "24 BOULEVARD DE L HOPITAL 75005 PARIS",
       "debugDoc": 2154
     }
   }
 }'

Cela permet d'afficher au niveau debug (niveau log4j), dans les logs d'elasticsearch, l'exécution détaillée du calcul de la note associée au document d'id "debugDoc". Il ne s'agit toutefois pas de l'id du document correspondant à _id, mais l'id du document relativement au shard considéré. Pour l'identifier, il suffit d'exécuter une requête dont le résultat inclus le document recherché, en mode explain (l'explication fait référence à l'id relatif au shard !).