Solr: Der leis­tungs­star­ke Such-Server von Apache

Solr (ge­spro­chen: Solar) ist ein Open-Source-Un­ter­pro­jekt auf Grundlage der freien Software Lucene von Apache. Solr basiert auf Lucene Core und ist in Java ge­schrie­ben. Als Such-Server ist Apache Solr eines der be­lieb­tes­ten Werkzeuge für die In­te­gra­ti­on ver­ti­ka­ler Such­ma­schi­nen. Zu den Vorteilen Solrs gehört unter anderem der große Funk­ti­ons­um­fang (der bei­spiels­wei­se auch die Fa­cet­tie­rung von Such­ergeb­nis­sen umfasst) und die be­schleu­nig­te In­de­xie­rung. Zudem läuft es auf Server-Con­tai­nern wie Apaches Tomcat. Wir erklären Ihnen zunächst die Funk­ti­ons­wei­se von Apache Solr und erläutern danach in einem Solr-Tutorial, was bei der ersten Nutzung der Software zu beachten ist.

Der Such-Server Solr wurde auf Basis von Lucene gebaut. Apaches Lucene Core hatte der Software-Designer Doug Cutting im Jahr 1997 ent­wi­ckelt. Zunächst bot er es über den Fi­le­hos­ting-Dienst SourceF­or­ge an. 1999 startete dann die Apache Software Foun­da­ti­on das Jakarta-Projekt, das die Ent­wick­lung freier Java-Software un­ter­stüt­zen und vor­an­trei­ben sollte. 2001 wurde auch Lucene Teil dieses Projekts – war es doch auch in Java ge­schrie­ben. Seit 2005 gehört es zu den Apache-Haupt­pro­jek­ten und läuft unter einer freien Apache-Lizenz. Aus Lucene ent­stan­den einige Un­ter­pro­jek­te wie bei­spiels­wei­se Lucy (Lucene, ge­schrie­ben in C) und Lucene.NET (Lucene in C#). Der beliebte Such-Server Ela­s­tic­se­arch basiert – wie Solr – ebenfalls auf Lucene.

Auf Basis von Lucene entstand 2004 auch Solr: Zu dieser Zeit wurde das Servlet al­ler­dings noch Solar genannt und von CNET Networks ver­trie­ben. „Solar“ stand dabei für „Search on Lucene and Resin“.

2006 übergab CNET das Projekt an die Apache Foun­da­ti­on, wo es zunächst eine weitere Ent­wick­lungs­pe­ri­ode durchlief. Als Solr 2007 als eigenes Projekt für die Öf­fent­lich­keit zu­gäng­lich gemacht wurde, zog es in der Community schnell Auf­merk­sam­keit auf sich. 2010 in­te­grier­te die Apache-Community das Servlet in das Lucene-Projekt. Diese ge­mein­sa­me Ent­wick­lung ga­ran­tiert eine gute Kom­pa­ti­bi­li­tät. Das Paket wird durch Solr-Cloud und den Solr-Parser Tika kom­plet­tiert.

Apache Solr ist als Servlet in Lucene in­te­griert. Da es somit die Lucene-Software-Bi­blio­thek ergänzt, erklären wir kurz deren Funk­ti­ons­wei­se. Zudem nutzen viele Webseiten Solr als Grundlage für ihre vertikale Such­ma­schi­ne (Netflix und Ebay sind bekannte Beispiele). Was das genau ist, erläutern wir im dar­auf­fol­gen­den Abschnitt.

Die freie Software Lucene ist eine kos­ten­lo­se Open-Source-Java-Bi­blio­thek, die Sie platt­form­un­ab­hän­gig einsetzen können. Lucene ist bekannt als ska­lier­ba­re und leis­tungs­star­ke NoSQL-Bi­blio­thek. Die Archiv-Software eignet sich ins­be­son­de­re für den Einsatz von In­ter­net­such­ma­schi­nen – sowohl bei Suchen im gesamten World Wide Web als auch für do­main­wei­te Suche und lokale Anfragen.

Da die Bi­blio­thek Dokumente in Text­fel­der aufteilt und logisch klas­si­fi­ziert, funk­tio­niert die Voll­text­su­che über Lucene sehr genau. Auch relevante Treffer für ähnliche Texte/Dokumente findet Lucene sicher. Deshalb eignet sich die Bi­blio­thek bei­spiels­wei­se auch für Be­wer­tungs­sei­ten wie Yelp. Solange es Text erkennt, spielt das Format (Klartext, PDF, HTML oder andere) keine Rolle. Denn statt Dateien zu in­de­xie­ren, arbeitet Lucene mit Text und Metadaten. Trotzdem müssen aber Dateien aus der Bi­blio­thek aus­ge­le­sen werden.

Zu diesem Zweck ent­wi­ckel­te das Lucene-Team das in­zwi­schen selbst­stän­di­ge Apache-Projekt Tika. Apache Tika ist ein prak­ti­sches Werkzeug zur Text­ana­ly­se, Über­set­zung oder In­de­xie­rung. Aus über tausend Da­tei­ty­pen liest das Werkzeug Text sowie Metadaten aus. An­schlie­ßend ex­tra­hiert es den Text und stellt ihn für die weitere Be­ar­bei­tung bereit. Tika besteht aus einem Parser und einem Detektor. Der Parser ana­ly­siert Texte und struk­tu­riert den Inhalt in einer ge­ord­ne­ten Hier­ar­chie. Der Detektor typisiert Inhalte. Er erkennt bei­spiels­wei­se den Da­tei­ty­pen aber auch die Art des Inhalts aus den Metadaten.

Die wich­tigs­ten Funk­tio­nen und Features von Lucene:

• Schnelle In­di­zie­rung, sowohl stu­fen­wei­se als auch sta­pel­wei­se (laut eigenen Angaben bis zu 150 GB pro Stunde)
• Sparsame Nutzung von RAM
• Durch­ge­hend in Java ge­schrie­ben, daher platt­form­über­grei­fend (Varianten in al­ter­na­ti­ven Pro­gram­mier­spra­chen sind Apache Lucy und Lucene.NET)
• Schnitt­stel­le für Plugins
• Suche nach Text­fel­dern (Ka­te­go­rien wie Inhalt, Titel, Autor, Schlag­wort) – auch nach mehreren gleich­zei­tig
• Sor­tie­rung nach Text­fel­dern
• Nach Ähn­lich­keit/Relevanz ge­glie­der­te Auf­lis­tung der Such­ergeb­nis­se

Lucene un­ter­teilt Dokumente in Text­fel­der wie Titel („title“), Autor („author“) und Text­kör­per („text“). Innerhalb dieser Felder sucht die Software mit dem Query-Parser (An­fra­ge­ana­ly­sie­rer). Dieser gilt als besonders ef­fi­zi­en­tes Werkzeug für Such­an­fra­gen mit manueller Text­ein­ga­be. Die einfache Syntax besteht aus einem Such­ter­mi­nus und einem Modifier. Such­ter­mi­ni können einzelne Wörter oder Wort­grup­pen sein. Diese justieren Sie mit einem Modifier oder Sie ver­knüp­fen mehrere Termini mit Boole­schen Variablen zu einer komplexen Anfrage. In der Apache-Anleitung zur Syntax des Query-Parsers finden Sie die genauen Befehle.

Lucene un­ter­stützt auch unscharfe Suche auf Basis der Le­vensht­ein-Distanz. Letztere erfasst die Anzahl von Zei­chen­än­de­run­gen (also Ersetzen, Einfügen oder Löschen), um von einer sinn­be­haf­te­ten Zei­chen­ket­te zu einer anderen zu gelangen. Ein Beispiel: „Lupe“ (ersetze p durch k) zu „Luke“ hat eine Distanz von 1, weil nur eine Um­wand­lungs­ope­ra­ti­on nötig war.

Sie selbst können einen Wert festlegen, der bestimmt, wie groß Ab­wei­chun­gen zum Ori­gi­nal­such­be­griff sein dürfen, damit der be­tref­fen­de Begriff noch in den Such­tref­fern be­rück­sich­tigt wird. Dieser Wert liegt zwischen 0 und 1 – je näher er an 1 liegt, desto stärker muss der Such­tref­fer dem Aus­gangs­wort ähneln. Geben Sie keinen Wert an, liegt dieser au­to­ma­tisch bei 0,5. Ent­spre­chen­der Befehl sieht dann so aus.

Wollen Sie einen be­stimm­ten Wert festlegen (Im Beispiel 0,9), dann geben Sie folgenden Befehl ein:

Ähnlich aufgebaut ist die Um­ge­bungs­su­che, mit der Sie Wörter suchen und außerdem festlegen, wie weit Such­be­grif­fe im Text von­ein­an­der entfernt stehen dürfen, um relevant zu bleiben. Suchen Sie bei­spiels­wei­se nach der Phrase „Alice im Wun­der­land“, können Sie festlegen, dass die Wörter „Alice“ und „Wun­der­land“ in einem 3-Wort-Radius liegen müssen:

Lucene er­mög­licht die Suche im World Wide Web und innerhalb von Domains. Such­ma­schi­nen, die eine große Band­brei­te von Seiten abdecken, nennt man ho­ri­zon­ta­le Such­ma­schi­nen. Dazu gehören die bekannten Anbieter Google, Bing, Yahoo oder auch Duck­Duck­Go und Startpage. Eine vertikale Such­ma­schi­ne be­schränkt sich hingegen entweder auf eine Domain, ein be­stimm­tes Thema oder eine Ziel­grup­pe. Eine do­main­spe­zi­fi­sche Such­ma­schi­ne hilft den Besuchern Ihrer Website, spe­zi­fi­sche Texte oder Angebote auf Ihrer Web­prä­senz zu finden. Beispiele für the­ma­tisch aus­ge­rich­te­te Such­ma­schi­nen sind Emp­feh­lungs­por­ta­le wie Tri­p­Ad­vi­sor oder Yelp – aber auch Job­such­ma­schi­nen. Ziel­grup­pen­ge­naue Such­ma­schi­nen richten sich bei­spiels­wei­se an Kinder und Ju­gend­li­che oder Wis­sen­schaft­ler, die nach Quellen suchen.

Durch fo­kus­sier­te Crawler (anstelle von Web­craw­lern) finden vertikale Such­ma­schi­nen genauere Treffer. Eine Bi­blio­thek wie Lucene, die ihren Index durch Taxonomie-Prin­zi­pi­en in Klassen einteilt und diese durch Ontologie logisch verbindet, er­mög­licht erst diese genaue Voll­text­su­che. Vertikale Such­ma­schi­nen nutzen zudem the­ma­tisch passende Filter, die die Anzahl der Er­geb­nis­se be­schrän­ken.

Der Index von Lucene stellt ein prak­ti­sches, ska­lier­ba­res Archiv für schnelle Suchen dar. Doch gibt es einige es­sen­zi­el­le Ar­beits­schrit­te, die Sie häufig wie­der­ho­len müssen, die aber nicht au­to­ma­tisch statt­fin­den. Für die vertikale Suche benötigen Sie schließ­lich einen weit ver­zweig­ten Index. An dieser Stelle kommt Apache Solr ins Spiel. Der Such-Server ergänzt die Funk­tio­nen der Bi­blio­thek. Und Solr lässt sich mit den richtigen Befehlen schnell und einfach ein­rich­ten – selbst von Java-Ein­stei­gern. Das Servlet bietet Ihnen viele prak­ti­sche Tools, mit denen Sie in kürzester Zeit eine vertikale Such­ma­schi­nen für Ihre In­ter­net­prä­senz ein­rich­ten und auf die Be­dürf­nis­se Ihrer Besucher abstimmen können.

Da Sie nun grund­le­gen­de In­for­ma­tio­nen zum Fundament Lucene und zum An­wen­dungs­be­reich von Solr haben, erklären wir nach­fol­gend, wie der Such-Server überhaupt funk­tio­niert, wie er Lucene erweitert und wie Sie damit arbeiten.

Solr ist in Java ge­schrie­ben, sodass Sie das Servlet platt­form­un­ab­hän­gig nutzen können. Befehle schreiben Sie nor­ma­ler­wei­se in HTTP (Hypertext Transfer Protocol), für zu spei­chern­de Dateien nutzen Sie XML (Ex­ten­si­ble Markup Language). Über ein API (ap­pli­ca­ti­on pro­gramming interface) bietet Apache Solr auch Python- und Ruby-Ent­wick­lern ihre gewohnte Pro­gram­mier­spra­che. Den­je­ni­gen, die nor­ma­ler­wei­se mit der Ja­va­Script Object Notation (kurz: JSON) arbeiten, bietet hingegen Ela­s­tic­Se­arch die optimale Umgebung. Über ein API kann Solr aber auch mit diesem Format arbeiten.

Zwar basiert der Such-Server auf Lucene und fügt sich auch nahtlos in dessen Ar­chi­tek­tur ein, doch funk­tio­niert Solr auch allein. Es ist kom­pa­ti­bel mit Server-Con­tai­nern wie Apache Tomcat.

In­de­xie­rung für genaue Such­ergeb­nis­se – in Se­kun­den­bruch­tei­len

Struk­tu­rell gesehen liegt dem Servlet eine in­ver­tier­te Datei (Englisch: inverted index) zugrunde. Dafür nutzt Solr klas­si­scher­wei­se die Bi­blio­thek von Lucene. In­ver­tier­te Dateien sind eine Unterart des Da­ten­bank­in­dex. Sie sollen den Aufruf von In­for­ma­tio­nen be­schleu­ni­gen. Innerhalb der Bi­blio­thek speichert der Index Inhalte ab. Das können Wörter oder Zahlen sein. Sucht ein Nutzer auf einer Web­prä­senz nach be­stimm­ten Inhalten, gibt die Person meist ein oder zwei the­men­re­le­van­te Such­be­grif­fe ein. Anstatt die gesamte Website mit Crawlern nach diesen Wörtern ab­zu­su­chen, nutzt Solr dann die Bi­blio­thek.

Diese indiziert alle wichtigen Schlag­wör­ter nahezu in Echtzeit und verbindet sie mit Do­ku­men­ten der Website, in denen die gesuchten Wörter vorkommen. Die Suche durch­läuft dabei lediglich den Index, um einen Begriff zu finden. Die Er­geb­nis­lis­te zeigt alle Dokumente an, die laut Index min­des­tens einmal dieses Wort enthalten. Diese Art der Suche ent­spricht der analogen Suche innerhalb eines Fachbuchs: Suchen Sie am Ende des Buches im Register nach einem Schlag­wort, finden Sie dort die Angabe, auf welchen Seiten innerhalb des gesamten Textes Sie den Begriff finden. Dort blättern Sie einfach hin. Die vertikale Websuche zeigt dem­entspre­chend eine Er­geb­nis­lis­te mit Ver­lin­kun­gen zu den je­wei­li­gen Do­ku­men­ten.

Damit dieser Prozess rei­bungs­los funk­tio­niert, muss man theo­re­tisch jedes Mal, wenn ein neues Dokument in das Portfolio der Website eingeht, sämtliche Schlag­wör­ter und Metadaten (zum Beispiel zum Autor oder Er­schei­nungs­jahr) in die Bi­blio­thek eintragen. Dadurch ist bei Lucene die Arbeit im Backend mitunter etwas mühselig. Doch durch Solr lassen sich solche Ar­beits­schrit­te au­to­ma­ti­sie­ren.

Relevanz und Filter

Apache Solr nutzt die Ontologie und Taxonomie von Lucene, um besonders genaue Such­ergeb­nis­se aus­zu­ge­ben. Dabei helfen die Boole­schen Variablen und Trun­kie­run­gen, die bereits aus Lucene bekannt sind. Dem Cache von Lucene fügt Solr einen Higher-Level-Cache hinzu. Das heißt, das Servlet merkt sich häufig gestellte Such­an­fra­gen, auch wenn diese aus komplexen Variablen bestehen. So optimiert es die Such­ge­schwin­dig­keit.

Wollen Sie Nutzer auf Ihrer Webseite halten, sollten Sie ihnen eine gute User Ex­pe­ri­ence bieten. Dazu gehört ins­be­son­de­re, die richtigen Angebote zu machen. Suchen Ihre Besucher bei­spiels­wei­se nach In­for­ma­tio­nen über Hüh­ner­hal­tung, sollten Texte über deren Aufzucht und Fress­ver­hal­ten als erste Such­ergeb­nis­se oben in der Liste er­schei­nen. Rezepte mit Huhn oder gar Filme über Hühner sollten hingegen nicht zu den Such­ergeb­nis­sen gehören oder zumindest weiter unten er­schei­nen.

Un­ab­hän­gig davon, ob User nach einem be­stimm­ten Begriff suchen oder ob sie am Ende eines span­nen­den Artikels in­ter­es­san­te The­men­vor­schlä­ge mit internen Ver­lin­kun­gen angezeigt bekommen sollen: In beiden Fällen ist die Relevanz der Er­geb­nis­se das A und O. Und damit dem Suchenden auch tat­säch­lich nur für ihn relevante Such­ergeb­nis­se angezeigt werden, nutzt Solr das Tf-idf-Maß.

Apache Solr sammelt und indiziert Daten nahezu in Echtzeit, gestützt durch Lucene Core. Daten stehen dabei für Dokumente. Sowohl bei der Suche als auch im Index ist das Dokument die aus­schlag­ge­ben­de Maß­ein­heit. Der Index besteht aus mehreren Do­ku­men­ten, diese wiederum aus mehreren Text­fel­dern. In der Datenbank steht ein Dokument in einer Ta­bel­len­rei­he. Ein Feld steht in der Ta­bel­len­spal­te.

Gekoppelt über ein API mit Apache Zookeper verfügt Solr über eine zentrale An­lauf­stel­le, die sowohl Syn­chro­ni­sie­rung, Na­mens­re­gis­ter und die Ver­tei­lung der Kon­fi­gu­ra­ti­on be­reit­stellt. Dazu gehört bei­spiels­wei­se ein Ring­al­go­rith­mus, der Prozessen innerhalb eines ver­teil­ten Systems einen Ko­or­di­na­tor (auch: Leader) zuweist. Der erprobte Trouble-Shooter Zookeeper stößt zudem Abläufe wieder an, wenn Token verloren gehen, und findet Knoten (Computer im System) mittels Node-Discovery. All diese Funk­tio­nen stellen sicher, dass Ihr Projekt immer frei ska­lier­bar bleibt.

Dazu gehört auch, dass die Such­ma­schi­ne selbst unter härtesten Be­din­gun­gen arbeitet. Wie bereits erwähnt, nutzen auch traffic-intensive Websites, die täglich riesige Mengen an Daten speichern und verwalten, Apache Solr.

Falls ein einzelner Solr-Server nicht ausreicht, verbinden Sie einfach mehrere Server über die Solr-Cloud. Dann können Sie Ihre Da­ten­sät­ze ho­ri­zon­tal frag­men­tie­ren – auch Sharding genannt. Dafür un­ter­tei­len Sie Ihre Bi­blio­thek in logisch ver­knüpf­te Fragmente. So erweitern Sie Ihre Bi­blio­thek über den sonst möglichen Spei­cher­platz hinaus. Apache empfiehlt zudem, mehrere Kopien Ihrer Bi­blio­thek auf ver­schie­de­ne Server zu laden. So erhöhen Sie Ihren Re­pli­ka­ti­ons­fak­tor. Kommen viele Anfragen gleich­zei­tig rein, werden diese auf die un­ter­schied­li­chen Server verteilt.

Die Voll­text­su­che, mit der Lucene bereits aufwartet, baut Solr mit weiteren Funk­tio­nen aus. Diese Such-Features umfassen unter anderem:

• Be­griffs­an­pas­sung auch für Wort­grup­pen: Das System erkennt Recht­schreib­feh­ler in der Such­ein­ga­be und bietet Er­geb­nis­se für eine kor­ri­gier­te Al­ter­na­ti­ve.
   
• Joins: Eine Mischung aus dem kar­te­si­schen Produkt (mehrere Begriffe werden bei der Suche in jedweder Rei­hen­fol­ge beachtet) und Selektion (Nur Begriffe, die eine bestimmte Vor­aus­set­zung erfüllen, werden angezeigt), also eine komplexe Boolesche Va­ria­blen­Syn­tax
   
• Grup­pie­rung von the­ma­tisch ver­wand­ten Begriffen.
   
• Fa­cet­ten­klas­si­fi­ka­ti­on: Das System ordnet jedes einzelne In­for­ma­ti­ons­ele­ment anhand mehrerer Di­men­sio­nen ein. Zum Beispiel verknüpft es einen Text mit Stich­wör­tern wie dem Au­toren­na­men, der Sprache und der Textlänge. Dazu kommen Themen, die der Text behandelt, sowie eine zeitliche Ein­ord­nung. Die Fa­cet­ten­su­che erlaubt dem Nutzer, mehrere Filter ein­zu­set­zen und so eine in­di­vi­du­el­le Er­geb­nis­lis­te zu erhalten.
   
• Wild­card­Su­che: Ein Zeichen steht für ein un­de­fi­nier­tes Element oder gleich mehrere solcher Elemente in einer Zei­chen­ket­te? Für ein Zeichen verwenden Sie dann „?“, für mehrere nehmen Sie „*“. Sie können bei­spiels­wei­se ein Wort­frag­ment plus den Platz­hal­ter eingeben (zum Beispiel: Lehr*). Die Er­geb­nis­lis­te bezieht dann alle Begriffe mit diesem Wortstamm ein (zum Beispiel: Lehre, Lehrerin, lehren, lehrreich). So erhalten Nutzer Treffer zu diesem The­men­feld. Die nötige Relevanz ergibt sich aus der The­men­ein­gren­zung Ihrer Bi­blio­thek oder weiteren Such­Ein­gren­zun­gen. Suchen Nutzer bei­spiels­wei­se nach „B?nd“, erhalten sie Er­geb­nis­se wie Band, Bond, Bund. Wörter wie „binden“ oder „ver­bind­lich“ erfasst die Suche jedoch nicht, da das „?“ nur einen Buch­sta­ben ersetzt.
   
• Erkennt Text in vielen Formaten, von Microsoft Word über Text­edi­to­ren bis PDF und in­di­zier­te Rich­In­hal­te.
   
• Erkennt un­ter­schied­li­che Sprachen.

Außerdem kann das Servlet mehrere Kerne (English: Cores) einbinden. Diese Kerne bestehen aus Lucene-Indizes. Der Kern sammelt also sämtliche In­for­ma­tio­nen in einer Bi­blio­thek. Auch Kon­fi­gu­ra­ti­ons­da­tei­en und Schemata finden Sie dort. Damit legen Sie das Verhalten von Apache Solr fest. Wollen Sie Er­wei­te­run­gen nutzen, in­te­grie­ren Sie einfach eigene Skripte oder Plug-ins aus Community-Beiträgen in die Kon­fi­gu­ra­ti­ons­da­tei.

Die Sys­tem­vor­aus­set­zun­gen für Solr sind nicht son­der­lich hoch. Sie benötigen lediglich ein Java SE Runtime En­vi­ron­ment ab Version 1.8.0. Die Ent­wick­ler testeten das Servlet auf Linux/Unix, macOS und Windows in ver­schie­de­nen Versionen. Laden Sie einfach das ent­spre­chen­de In­stal­la­ti­ons­pa­ket herunter und entpacken Sie die .zip-Datei (Windows-Paket) oder die .tgz-Datei (Unix-, Linux- und OSX-Paket) in einem Ver­zeich­nis Ihrer Wahl.

3. Im oberen Bild sehen Sie die ver­schie­de­nen Download-Pakete, die zur Auswahl stehen – in diesem Fall für die Solr-Version 7.3.

• solr7.3.0-src.tgz ist das Paket für Ent­wick­ler. Es enthält den Quellcode, sodass Sie auch außerhalb der GitHub-Community daran arbeiten können.
• solr7.3.0.tgz ist die Version für Mac- und Linux- be­zie­hungs­wei­se Unix-User.
• solr7.3.0.zip enthält das win­dows­kom­pa­ti­ble Solr-Paket.
• im Ordner changes/ finden Sie die Do­ku­men­ta­ti­on für ent­spre­chen­de Version.

Nachdem Sie die für Ihre Ansprüche optimale Version per Mausklick aus­ge­wählt haben, erscheint ein Download-Fenster. Speichern Sie die Datei. Ist der Download dann ab­ge­schlos­sen, klicken Sie auf den Download-Button in Ihrem Browser oder öffnen Sie Ihren Download-Ordner.

4. Entpacken Sie die zip-Datei be­zie­hungs­wei­se die .tgz-Datei. Wollen Sie sich zuerst mit Solr vertraut machen, wählen Sie zunächst ein be­lie­bi­ges Ver­zeich­nis. Dort speichern Sie die ent­pack­ten Dateien ab. Wissen Sie bereits, in welchem Umfang Sie Solr nutzen wollen, wählen Sie den dafür vor­ge­se­he­nen Server. Oder bauen Sie eine ge­clus­ter­te Solr-Cloud-Umgebung, wenn Sie nach oben skalieren wollen. (Mehr zur Cloud im nächsten Kapitel)

Geben Sie „cd /[Quellpfad]“ in die Kom­man­do­zei­le ein, um das Solr-Ver­zeich­nis zu öffnen und starten Sie das Programm. In unserem Beispiel sieht das so aus:

Der Solr-Server läuft nun auf Port 8983. Eventuell fragt Ihre Firewall, ob Sie das ge­neh­mi­gen. Be­stä­ti­gen Sie das.

Wollen Sie Solr anhalten, geben Sie folgenden Befehl ein:

Funk­tio­niert Solr, machen Sie sich mit der Software vertraut. Mit der Solr-Demo starten Sie das Programm al­ter­na­tiv in einem von vier Modi:

• SolrCloud (Befehl: cloud)
• Da­ten­im­port­Hand­ler (Befehl: dih)
• Ohne Schema (Befehl: sche­maless)
• Aus­führ­li­ches Beispiel mit Kit­chen­Sink (Befehl: tech­pro­ducts)

Die Beispiele verfügen über ein jeweils an­ge­pass­tes Schema. Dieses be­ar­bei­ten Sie über die Schema-Schnitt­stel­le. Dafür geben Sie diesen Befehl ein (der Platz­hal­ter [beispiel] steht jeweils für eines der oben an­ge­ge­be­nen Schlag­wör­ter):

6. Damit läuft Solr in dem ent­spre­chen­den Modus. Wollen Sie si­cher­ge­hen, rufen Sie den Sta­tus­re­port ab:

7. Die Beispiele enthalten vor­kon­fi­gu­rier­te Grund­ein­stel­lun­gen. Starten Sie ohne Beispiel, müssen Sie Schema und Kern selbst festlegen. Der Kern speichert Ihre Daten. Ohne ihn können Sie weder Dateien in­de­xie­ren noch suchen. Um einen Kern zu erstellen, geben Sie folgenden Befehl ein:

9. Ab­schlie­ßend stoppen Sie Solr mit diesem Befehl wieder:

Solr stellt Ihnen ein einfaches Kommando-Tool zur Verfügung. Mit dem so­ge­nann­ten Post-Tool können Sie Inhalte auf Ihren Server laden. Das können sowohl Dokumente für den Index sein als auch Schema-Kon­fi­gu­ra­tio­nen. Das Tool greift zu diesem Zweck auf Ihre Sammlung zu. Deshalb müssen Sie immer den Kern be­zie­hungs­wei­se die Sammlung angeben, bevor Sie damit arbeiten.

Im folgenden Code-Beispiel geben wir zuerst die all­ge­mei­ne Form an. <sammlung> ersetzen Sie durch den Namen Ihres Kerns/Ihrer Sammlung. „-c“ ist der Befehl „create“. Damit erstellen Sie Kern oder Sammlung. Dahinter legen Sie zu­sätz­li­che Optionen fest oder führen Befehle aus. Zum Beispiel wählen Sie mit „-p“ einen Port aus und mit „*.xml“ oder „*.csv“ laden Sie alle Dateien mit dem je­wei­li­gen Format in Ihre Sammlung hoch (Zeile zwei und drei). Das Kommando „-d“ löscht Dokumente Ihrer Sammlung (Zeile vier).

Nun kennen Sie einige der grund­le­gen­den Befehle für Solr. Wie genau Sie vorgehen, wenn Sie Apache Solr ein­rich­ten, zeigen wir am Beispiel der Demo-Version Kitchen-Sink.

1. Starten Sie Solr mit der Demo-Version. Für die Kitchen-Sink-Demo nutzen Sie den Befehl tech­pro­ducts. Folgendes geben Sie in das Terminal ein:

Solr startet stan­dard­mä­ßig auf Port 8983. Das Terminal zeigt Ihnen an, dass es einen neuen Kern für Ihre Sammlung anlegt und es indiziert einige Beispiel-Dateien für Ihren Katalog. In der Kitchen-Sink-Demo sollten Sie folgende Angaben sehen:

2. Solr läuft nun und hat bereits einige XML-Dateien in den Index geladen. Damit können Sie später arbeiten. Im nächsten Schritte sollten Sie selbst versuchen, einige Dateien in den Index zu speisen. Über die Solr-Admin-Nut­zer­ober­flä­che geht das recht einfach. Rufen Sie den Solr-Server in Ihrem Browser auf. In unserer Tech­pro­ducts-Demo gibt Solr den Server und den Port bereits vor. Demnach geben Sie folgende Adresse in Ihren Browser ein: "http://localhost:8983/solr/".
   Wenn Sie bereits selbst einen Server-Namen und einen Port fest­ge­legt haben, nutzen Sie folgende Form und setzen jeweils den Server-Namen und die Port-Nummer an der ent­spre­chen­den Stelle ein: "http://[Ser­ver­na­me]:[Port-Nummer]/solr".
   
   Dort steuern Sie den Ordner example/ex­am­ple­docs an. Darin befinden sich Beispiel-Dateien sowie die Datei post.jar. Wählen Sie eine Datei, die Sie in den Katalog aufnehmen wollen und nutzen Sie post.jar, um die Datei zuzufügen. Für unser Beispiel nehmen wir more_books.jsonl.
   
   Dafür geben Sie folgendes in das Terminal ein:

Hat Solr Ihre Datei er­folg­reich in den Index geladen, erhalten Sie diese Nachricht:

3. Wenn Sie den Apache-Solr-Such-Server aufsetzen, sollten Sie direkt die Kon­fi­gu­ra­ti­ons­da­tei­en und das Schema mit­ein­stel­len. In den Demo-Bei­spie­len sind diese gleich vor­ge­ge­ben. Arbeiten Sie an einem neuen Server, müssen Sie das Config-Set und das Schema selbst bestimmen.
   
   Das Schema (schema.xml) legt Anzahl, Art und Aufbau der Felder fest. Wie bereits erwähnt, besteht ein Dokument in Lucene aus Feldern. Diese Un­ter­tei­lung er­leich­tert die ziel­ge­rich­te­te Voll­text­su­che. Solr arbeitet mit diesen Feldern. Ein be­stimm­ter Feldtyp ak­zep­tiert bestimmte Inhalte (bei­spiels­wei­se <date> nur Da­tums­an­ga­ben der Form Jahr-Monat-Tag-Uhrzeit). Mit dem Schema legen Sie fest, welche Feldtypen der Index später erkennt und wie er sie zuordnet. Tun Sie das nicht, geben die ein­ge­speis­ten Dokumente Feldtypen vor. In der Testphase ist das praktisch, da Sie einfach anfangen, den Katalog zu füllen. Später kann solch ein Vorgehen al­ler­dings zu Problemen führen.
   
   Das sind einige grund­le­gen­de Solr-Feldtypen:

• Da­teR­an­ge­Field (indexiert Zeit­span­nen und Zeit­punk­te bis zur Mil­li­se­kun­de)
   
• Ex­ter­nal­Fi­le­Field (zieht Werte aus einem externen Ordner)
   
• TextField (all­ge­mei­nes Feld für Text­ein­ga­be)
   
• Bi­na­ry­Field (für binäre Daten)
   
• Cur­ren­cy­Field indexiert zwei Werte separat, aber zeigt sie dem Endnutzer als einen Wert an. Cur­ren­cy­Field speichert einen Zah­len­wert (zum Beispiel 4,50) und eine Währung (zum Beispiel €) jeweils in einem Feld. Der Endnutzer sieht beide Werte zusammen (also 4,50€).
   
• StrField (UTF8 sowie Unicode-String in einem kleinen Feld. Sie werden nicht ana­ly­siert oder durch ein Token ersetzt.)

Eine aus­führ­li­che Liste von Solr-Feldtypen sowie weiteren Befehlen für Schema-Ein­stel­lun­gen finden Sie im Solr-Wiki.

Um Feldtypen fest­zu­le­gen, rufen Sie die schema.xml unter "http://localhost:8983/solr/tech­pro­ducts/schema" auf. Tech­pro­ducts hat bereits Feldtypen fest­ge­legt. Eine Kom­man­do­zei­le in der XML-Datei be­schreibt die Ei­gen­schaf­ten eines Feldes anhand von At­tri­bu­ten näher. Laut Do­ku­men­ta­ti­on erlaubt Apache Solr folgende Attribute für ein Feld:

• field name (Darf nicht leer sein. Enthält den Namen des Feldes.)
   
• type (Hier tragen Sie einen gültigen Feldtypen ein. Darf nicht leer sein.)
   
• indexed (Steht für „im Index ein­ge­tra­gen“. Wenn der Wert „true“ ist, kann man nach dem Feld suchen oder es sortieren.)
   
• stored (Be­schreibt, ob ein Feld ein­ge­la­gert wird, steht der Wert auf „true“, ist das Feld aufrufbar.)
   
• mul­tiVa­lued (Be­inhal­tet ein Feld mehrere Werte für ein Dokument, tragen Sie hier den Wert „true“ ein.)
   
• default (Hier tragen Sie einen Stan­dard­wert ein, der erscheint, wenn für ein neues Dokument kein Wert fest­ge­legt ist.)
   
• com­pres­sed (Selten, da nur bei gzip­kom­pri­mier­ba­ren Feldern anwendbar, stan­dard­mä­ßig auf „false“ ein­ge­stellt. Muss auf „true“ stehen, um zu kom­pri­mie­ren.)
   
• omitNorms (Stan­dard­mä­ßig auf „true“ ein­ge­stellt. Spart Normen für ein Feld aus und spart so auch Speicher.)
   
• ter­m­Off­sets (Benötigt mehr Spei­cher­platz. Speichert Vektoren zusammen mit Off­set­In­for­ma­tio­nen – also Speicher-Adress­zu­sät­ze.)
   
• term­Po­si­ti­ons (Benötigt mehr Spei­cher­platz, da es die Position von Termen zusammen mit dem Vektor speichert.)
   
• term­Vec­tors (Steht stan­dard­mä­ßig auf „false“, speichert Vek­tor­Ter­men, wenn „true“.)

Feld­ei­gen­schaf­ten tragen Sie entweder direkt in der Schema-xml-Datei ein, oder Sie nutzen ein Kommando im Terminal. So sieht ein simpler Feldtyp in der Schema-xml-Datei aus:

Al­ter­na­tiv können Sie wieder das Eingabe-Terminal nutzen. Dort geben Sie einfach einen Curl-Befehl ein, legen die Feld­ei­gen­schaf­ten fest und senden es über die Schema-Schnitt­stel­le, indem Sie die Da­tei­adres­se angeben:

4. Nachdem Sie das Schema angepasst haben, ist die Solr-Kon­fi­gu­ra­ti­on an der Reihe. Über diese legen Sie die Such­ein­stel­lun­gen fest. Das sind wichtige Be­stand­tei­le:

• An­fra­ge­Cache-Parameter
• An­fra­ge­Hand­ler (auch: Request-Handler)
• Standort des Da­ten­ver­zeich­nis­ses
• Such­kom­po­nen­te

Die Anfrage-Cache-Parameter er­mög­li­chen drei Arten von Caching: LRUCache, LFUCache und FastL­RU­Cache. LRUCache nutzt eine verlinkte Hash-Map, FastL­RU­Cache sammelt Daten über eine gleich­zei­ti­ge Hash-Map. Diese Hash-Map be­ar­bei­tet Anfragen gleich­zei­tig. So pro­du­ziert der Such-Server schneller Antworten, falls viele Such­an­fra­gen parallel ein­tref­fen. Der FastL­RU­Cache liest Daten schneller als der LRUCache aus und fügt langsamer ein.

Der Anfrage-Handler ver­ar­bei­tet Anfragen. Er liest das HTTP-Protokoll aus, sucht im Index und gibt die Antworten aus. Die Tech­pro­ducts-Beispiel-Kon­fi­gu­ra­ti­on be­inhal­tet den Standard-Handler für Solr. Die Such­kom­po­nen­ten finden Sie als Liste im Anfrage-Handler. Diese Elemente führen die Suche durch. Stan­dard­mä­ßig enthält der Handler folgende Such­kom­po­nen­ten:

• query (Anfrage)
• facet (Fa­cet­tie­rung)
• mlt (More Like This)
• highlight (Beste)
• stats (Statistik)
• debug (Fehler ausmerzen)
• expand (Suche ausweiten)

Für die Such­kom­po­nen­te More Like This (mlt) geben Sie bei­spiels­wei­se diesen Befehl ein:

More Like This findet Dokumente, die sich in Inhalt und Aufbau ähneln. Es besteht als Klasse innerhalb von Lucene. Die Anfrage findet Inhalte für Ihre Web­sei­ten­be­su­cher, indem sie den String und die in­di­zier­ten Felder ver­gleicht.

Um die Liste zu kon­fi­gu­rie­ren, öffnen Sie zunächst den Anfrage-Handler:

Fügen Sie der Liste im Request-Handler selbst fest­ge­leg­te Kom­po­nen­ten hinzu oder ändern Sie be­stehen­de Such­kom­po­nen­ten. Diese Kom­po­nen­ten übernimmt die Suche, wenn später ein Web­sei­ten­be­su­cher auf Ihrer Domain eine Such­an­fra­ge eingibt. Folgender Befehl fügt eine selbst gebaute Kom­po­nen­te vor den Standard-Kom­po­nen­ten ein:

So fügen Sie die Kom­po­nen­te nach den Standard-Kom­po­nen­ten ein:

So benennen Sie be­stehen­de Kom­po­nen­ten um:

Das Standard-Da­ten­ver­zeich­nis finden Sie im Kern-Instanzen-Ver­zeich­nis „in­s­tance­Dir“ unter dem Namen „/data“. Wollen Sie ein anderes Ver­zeich­nis nutzen, ändern Sie den Standort über die solrcon­fig.xml. Dafür geben Sie einen festen Pfad an oder binden Sie den Ver­zeich­nis­na­men an den Kern (SolrCore) oder das Instanzen-Ver­zeich­nis (in­s­tance­Dir). Für die Bindung an den Kern schreiben Sie:

Apache Solr stellt eine Cloud-Demo zur Verfügung, anhand derer wir Ihnen die Ein­rich­tung eines Cloud-Clusters erklären. Sie können parallel dazu natürlich auch selber das Beispiel durch­spie­len.

1. Starten Sie zuerst die Kom­man­do­zei­len-Be­dien­ober­flä­che. Um Solr im Cloud-Mode zu starten, geben Sie Folgendes im Tool ein:

Die Demo startet.

2. Geben Sie an, wie viele Server (hier: nodes) über die Cloud verbunden werden sollen. Die Zahl kann zwischen [1] und [4] liegen (Im Beispiel sind es [2]). Die Demo arbeitet auf einer Maschine, nutzt aber für jeden Server einen anderen Port, den Sie als nächstes angeben. (Die Demo gibt die Port-Nummern vor)

Haben Sie alle Ports zugeteilt, setzt sich das Skript in Bewegung und zeigt Ihnen (wie oben zu sehen) die Kommandos zum Server-Start.

3. Wenn alle Server laufen, wählen Sie einen Namen für Ihre Daten-Sammlung (eckige Klammern si­gna­li­sie­ren Platz­hal­ter und er­schei­nen nicht im Code).

4. Aus dieser Kol­lek­ti­on erstellen Sie mit SPLIT­SHARD ein Fragment. Das können Sie später erneut in Par­ti­tio­nen spalten. So be­schleu­ni­gen Sie die Suche, falls gleich­zei­tig mehrere Anfragen eingehen.

Nachdem Sie mit SPLIT­SHARD Fragmente erstellt haben, können Sie Ihre Daten mithilfe eines Routers verteilen. Solr in­te­griert den com­po­si­teID-Router (router.key=com­po­si­teId) stan­dard­mä­ßig.

Über die Schnitt­stel­le teilen Sie das Fragment in zwei Teile. Beide Par­ti­tio­nen enthalten die gleiche Kopie der Ori­gi­nal­da­ten. Der Index un­ter­teilt sie lediglich entlang der neu ent­stan­de­nen Un­ter­be­rei­che.

5. Im letzten Schritt legen Sie den Namen Ihres Kon­fi­gua­ti­ons­ver­zeich­nis­ses fest. Die Vorlagen sample-tech­pro­ducts-configs und _default stehen zur Auswahl. Letzteres legt kein Schema fest, sodass ein Sie Ihr eigenes Schema noch anpassen können. Mit folgendem Befehl schalten Sie die sche­ma­lo­se Funktion von _default für die Solr-Cloud-Schnitt­stel­le ab:

Damit ver­hin­dern Sie, dass die Felder in An­be­tracht der ersten Inhalte selbst Schemata anlegen, die mit den rest­li­chen Dateien nicht kom­pa­ti­bel sind. Da Sie für diese Ein­stel­lung die HTTP-Methode POST brauchen, können Sie nicht einfach die Browser-Adress­zei­le dafür nutzen. localhost:8983 steht für den ersten Server. Falls Sie eine andere Port-Nummer gewählt haben, müssen Sie diese dort einfügen. [_name_der_sammlung] ersetzen Sie durch den von Ihnen gewählten Namen.

Damit haben Sie die Solr-Cloud ein­ge­rich­tet. Um zu sehen, ob Ihre neue Sammlung richtig angezeigt wird, fragen Sie wieder den Status ab:

Einen genaueren Überblick über die Ver­tei­lung Ihrer Fragmente erhalten Sie über die Admin-Be­nut­zer­ober­flä­che. Die Adresse besteht aus Ihrem Server-Namen mit Port-Nummer und der Ver­bin­dung zur Solr-Cloud in dieser Form: "http://ser­ver­na­me:port­num­mer/solr/#/~cloud"

Apache Solr verfügt bereits über einige Er­wei­te­run­gen. Das sind die so­ge­nann­ten Handler. Den Anfrage-Handler haben wir bereits vor­ge­stellt. Lucene (und somit auch Solr) un­ter­stützt zudem einige prak­ti­sche native Skripte wie die Solr-Analyzer-Klasse und die Si­mi­la­ri­ty-Klasse. Plug-ins in­te­grie­ren Sie in Solr über eine JAR-Datei. Bauen Sie eigene Plug-ins und in­ter­agie­ren diese mit Lucene-Schnitt­stel­len, sollten Sie die lucene-*.jars aus Ihrer Bi­blio­thek (solr/lib/) zu dem Klas­sen­weg hin­zu­fü­gen, mit dem Sie Ihren Plug-in-Quellcode zu­sam­men­tra­gen.

Diese Methode funk­tio­niert, wenn Sie nur einen Kern nutzen. Nutzen Sie die Solr-Cloud, erstellen Sie eine ge­mein­sa­me Bi­blio­thek für die JAR-Dateien. Dafür legen Sie ein Ver­zeich­nis mit dem Attribut „sharedLib“ in der solr.xml-Datei auf Ihrem Servlet an. Das ist eine einfache Methode, um Plug-ins auf einzelne Kerne zu laden:

Wenn Sie einen eigenen Kern gebaut haben, erstellen Sie ein Ver­zeich­nis für die Bi­blio­thek mit dem Befehl „mkdir“ (unter Windows: „md“) in dieser Form:

Machen Sie sich noch mit Solr vertraut und probieren eines der mit­ge­lie­fer­ten Demos aus, steuern Sie statt­des­sen „example/solr/lib“ an. In beiden Fällen befinden Sie sich nun im Bi­blio­theks­ver­zeich­nis Ihres In­stan­zen­ver­zeich­nis­ses. Dort speichern Sie Ihre Plug-in-JAR-Dateien.

Al­ter­na­tiv nutzen Sie die alte Methode aus früheren Solr-Versionen, wenn Sie bei­spiels­wei­se auf Ihrem Servlet-Container mit der ersten Variante keinen Erfolg haben.

• Dazu entpacken Sie die solr.warDatei.
• Fügen Sie dem WEBINF/libVer­zeich­nis dann die JARDatei mit Ihren selbst­ge­bau­ten Klassen hinzu. Sie finden das Ver­zeich­nis über die WebApp auf diesem Pfad: server/solrweb­app/webapp/WEB-INF/lib.
• Kom­pri­mie­ren Sie die ab­ge­än­der­te WARDatei wieder.
• Nutzen Sie Ihre maß­ge­schnei­der­te solr.war.

Erweitern Sie die Bi­blio­thek um eine „dir“-Option, fügt diese alle Dateien innerhalb des je­wei­li­gen Ver­zeich­nis­ses (Englisch: directory) dem Klas­sen­pfad zu. Mit „regex=“ schließen Sie Dateien aus, die nicht den „regex“-Vorgaben ent­spre­chen.

Bauen Sie selber ein Plug-in-Skript, empfiehlt sich für die Java Runtime unter anderem der Lisp-Dialekt Clojure. Diese Pro­gram­mier­spra­che un­ter­stützt in­ter­ak­ti­ve Pro­gramm­ent­wick­lung. Andere Sprachen in­te­grie­ren ihre nativen Ei­gen­schaf­ten. Clojure stellt sie über die Bi­blio­thek bereit. Diese Ar­beits­wei­se eignet sich gut für die Nutzung des Solr-Servlets.

Die Pro­gram­mier- und Skript­spra­che Groovy un­ter­stützt dy­na­mi­sche und statische Ty­pi­sie­rung auf der Java-Virtual-Machine. Die Sprache basiert auf Ruby und Python und wird in Java-Byte-Code kom­pi­liert. Dann kann man sie in einem Skript ausführen. Groovy bringt einige Features mit, die die Fä­hig­kei­ten von Java erweitern. Zum Beispiel in­te­griert Groovy eine simple Vorlage, mit der Sie Code in SQL oder HTML erstellen. Außerdem stellt Groovy Syntax out of the box einige häufige Ausdrücke oder Da­ten­fel­der für Listen bereit. Ver­ar­bei­ten Sie JSON oder XML für Ihren Solr-Such-Server, hilft Groovy, die Syntax sauber und ver­ständ­lich zu halten.

Geht es um Open-Source-Such­ma­schi­nen, liegen Solr und Ela­s­tic­se­arch in Tests und Umfragen immer wieder auf den vor­ders­ten Plätzen. Und beide Such-Server bauen auf der Apache-Java-Bi­blio­thek Lucene auf. Lucene ist of­fen­sicht­lich eine stabile Grundlage. Die Bi­blio­thek indexiert In­for­ma­tio­nen flexibel und liefert schnell Antworten auf komplexe Such­an­fra­gen. Auf dieser Basis erbringen beide Such­ma­schi­nen über­zeu­gen­de Leis­tun­gen. Jedes der Projekte wird zudem durch eine aktive Community getragen.

Das Ent­wick­ler-Team um Ela­s­tic­se­arch arbeitet jedoch mit GitHub, während Solr bei der Apache Foun­da­ti­on be­hei­ma­tet ist. Im Vergleich kann das Apache-Projekt zudem auf eine längere Ge­schich­te zu­rück­bli­cken. Und do­ku­men­tiert die rege Community bereits seit 2007 alle Än­de­run­gen, Features und Bugs. Die Ela­s­tic­se­arch-Do­ku­men­ta­ti­on ist bei Weitem nicht so umfassend, was durchaus auch kri­ti­siert wird. Dennoch steht Ela­s­tic­se­arch in Sachen Nut­zer­freund­lich­keit nicht unbedingt hinter Apache Solr zurück.

Mit Ela­s­tic­se­arch bauen Sie Ihre Bi­blio­thek in wenigen Schritten. Für zu­sätz­li­che Funk­tio­nen benötigen Sie Premium-Plug-ins. Damit verwalten Sie die Si­cher­heits­ein­stel­lun­gen, über­wa­chen den Such-Server oder ana­ly­sie­ren Metriken. Der Such-Server ver­sam­melt zudem eine gut auf­ein­an­der ab­ge­stimm­te Pro­dukt­fa­mi­lie um sich. Unter dem Label Elastic-Stack und X-Pack erhalten Sie einige Ba­sis­funk­tio­nen kostenlos. Die Premium-Pakete stehen Ihnen jedoch nur bei einem mo­nat­li­chen Abon­ne­ment zur Verfügung – mit einer Lizenz pro Knoten. Solr ist hingegen immer kostenlos – inklusive Er­wei­te­run­gen wie Tika und Zookeeper.

Am stärksten un­ter­schei­den sich die beiden Such­ma­schi­nen hin­sicht­lich der Schwer­punkt­set­zung. Sowohl Solr als auch Ela­s­tic­se­arch können Sie für kleine Da­ten­sät­ze wie auch für Big-Data nutzen, die sich über mehrere Um­ge­bun­gen verteilen. Aber Solr kon­zen­triert sich auf Textsuche. Das Konzept von Ela­s­tic­se­arch verbindet hingegen die Suche mit der Analyse. Metriken und Logs ver­ar­bei­tet das Servlet von Anfang an. Ent­spre­chen­de Mengen an Daten bewältigt Ela­s­tic­se­arch spielend. Denn der Server bindet Kerne und Fragmente dynamisch ein – schon seit der ersten Version.

Das hatte Ela­s­tic­se­arch dem Kon­kur­ren­ten Solr einst voraus, doch seit einigen Jahren er­mög­licht die Solr-Cloud ebenso Fa­cet­ten­klas­si­fi­zie­rung. Bei dy­na­mi­schen Daten hat Ela­s­tic­se­arch die Nase weiterhin leicht vorn. Dafür punktet der Kon­kur­rent bei sta­ti­schen Daten. Er gibt ziel­ge­naue Er­geb­nis­se bei der Voll­text­su­che aus und berechnet Daten exakt.

Die ver­schie­de­nen Grund­kon­zep­te spiegeln sich auch im Caching wider. Beide Anbieter er­mög­li­chen grund­sätz­lich Anfrage-Caching. Wenn eine Anfrage komplexe Boolesche Variablen verwendet, speichern beide die auf­ge­ru­fe­nen Index-Elemente in Segmenten. Diese können zu größeren Segmenten ver­schmel­zen. Ändert sich al­ler­dings nur ein Segment, muss Apache Solr den ganzen globalen Cache ungültig machen und neu laden. Ela­s­tic­se­arch begrenzt diesen Prozess auf das be­trof­fe­ne Teil­seg­ment. Das spart Spei­cher­platz und Zeit.

Wer re­gel­mä­ßig mit XML, HTTP und Ruby arbeitet, der wird sich auch in Solr pro­blem­los ein­ar­bei­ten. JSON hingegen kam erst später über eine Schnitt­stel­le dazu. Deswegen passen die Sprache und das Servlet noch nicht ideal zusammen. Ela­s­tic­se­arch hingegen kom­mu­ni­ziert nativ über JSON. Andere Sprachen wie Python, Java, .NET, Ruby und PHP bindet der Such-Server mit einer REST-ähnlichen Schnitt­stel­le ein.