# Solr: Der leistungsstarke Such-Server von Apache Solr (gesprochen: Solar) ist ein Open-Source-Unterprojekt auf Grundlage der freien Software [Lucene von Apache](https://lucene.apache.org/ "Lucene – eine Software-Bibliothek"). Solr basiert auf **Lucene Core** und ist in Java geschrieben. Als Such-Server ist **Apache Solr** eines der beliebtesten Werkzeuge **für die Integration vertikaler Suchmaschinen**. Zu den Vorteilen Solrs gehört unter anderem der große Funktionsumfang (der beispielsweise auch die Facettierung von Suchergebnissen umfasst) und die beschleunigte [Indexierung](https://www.ionos.at/digitalguide/online-marketing/suchmaschinenmarketing/indexierung/ "Indexierung"). Zudem läuft es auf Server-Containern wie Apaches Tomcat. Wir erklären Ihnen zunächst die Funktionsweise von Apache Solr und erläutern danach in einem Solr-Tutorial, was bei der ersten Nutzung der Software zu beachten ist. ## Die Entstehung von Apache Solr Der Such-Server Solr wurde auf Basis von Lucene gebaut. Apaches Lucene Core hatte der Software-Designer Doug Cutting im Jahr 1997 entwickelt. Zunächst bot er es über den Filehosting-Dienst [SourceForge](https://sourceforge.net/ "Website von SourceForge") an. 1999 startete dann die Apache Software Foundation das **Jakarta-Projekt**, das die Entwicklung freier Java-Software unterstützen und vorantreiben sollte. 2001 wurde auch Lucene Teil dieses Projekts – war es doch auch in Java geschrieben. Seit 2005 gehört es zu den Apache-Hauptprojekten und läuft unter einer freien Apache-Lizenz. Aus Lucene entstanden einige Unterprojekte wie beispielsweise **Lucy** (Lucene, geschrieben in C) und **Lucene.NET** (Lucene in C#). Der beliebte Such-Server **[Elasticsearch](https://www.ionos.at/digitalguide/server/konfiguration/elasticsearch/)** basiert – wie Solr – ebenfalls auf Lucene. Auf Basis von Lucene entstand 2004 auch Solr: Zu dieser Zeit wurde das Servlet allerdings noch **Solar genannt und von CNET Networks vertrieben**. „Solar“ stand dabei für „*Search on Lucene and Resin*“. 2006 übergab CNET das Projekt an die Apache Foundation, wo es zunächst eine weitere Entwicklungsperiode durchlief. Als Solr 2007 als eigenes Projekt für die Öffentlichkeit zugänglich gemacht wurde, zog es in der Community schnell Aufmerksamkeit auf sich. 2010 integrierte die Apache-Community das Servlet in das Lucene-Projekt. Diese gemeinsame Entwicklung garantiert eine gute Kompatibilität. Das Paket wird durch **Solr-Cloud** und den Solr-Parser **Tika** komplettiert. Definition Apache Solr ist ein plattformunabhängiger Such-Server für Webprojekte auf Java-Basis. Das Open-Source-Projekt baut auf der Java-Bibliothek Lucene auf. Es integriert Dokumente automatisch in Echtzeit und bildet dynamische Cluster. Solr ist kompatibel zu PHP, Python, XML und JSON. Das Servlet verfügt über eine Web-Nutzeroberfläche – Befehle werden in HTTP ausgetauscht. Solr ermöglicht Anwendern eine differenzierte Volltextsuche für Rich-Text-Dokumente. Es eignet sich insbesondere für vertikale Suchmaschinen auf statischen Webseiten. Die Erweiterung über Solr-Cloud ermöglicht zusätzliche Kerne und eine erweiterte Fragmentklassifizierung. ## Einführung in Solr: Erklärung der Grundbegriffe Apache Solr ist als Servlet in Lucene integriert. Da es somit die **Lucene-Software-Bibliothek** ergänzt, erklären wir kurz deren Funktionsweise. Zudem nutzen viele Webseiten Solr als Grundlage für ihre **vertikale Suchmaschine** (Netflix und Ebay sind bekannte Beispiele). Was das genau ist, erläutern wir im darauffolgenden Abschnitt. ### Was ist Apache Lucene? Die freie Software [Lucene](https://www.ionos.at/digitalguide/server/konfiguration/apache-lucene/ "Apache Lucene") ist eine kostenlose Open-Source-Java-Bibliothek, die Sie plattformunabhängig einsetzen können. Lucene ist bekannt als skalierbare und leistungsstarke [NoSQL-Bibliothek](https://www.ionos.at/digitalguide/hosting/hosting-technik/nosql/ "NoSQL"). Die Archiv-Software eignet sich insbesondere für den Einsatz von **Internetsuchmaschinen** – sowohl bei Suchen im gesamten World Wide Web als auch für domainweite Suche und lokale Anfragen. Fakt Lucene Core ist eine Software-Bibliothek (auch einfach „Bibliothek“, oder Komponentenbibliothek) für die Programmiersprache Java. Bibliotheken dienen lediglich als **geordnete Sammlung von Unterprogrammen**. Entwickler nutzen diese Sammlungen, um Programme über eine Schnittstelle mit Hilfsmodulen zu verknüpfen. Während ein Programm läuft, kann es in der Bibliothek auf die benötigte Komponente zugreifen. Da die Bibliothek **Dokumente in Textfelder aufteilt und logisch klassifiziert**, funktioniert die **Volltextsuche** über Lucene sehr genau. Auch relevante Treffer für ähnliche Texte/Dokumente findet Lucene sicher. Deshalb eignet sich die Bibliothek beispielsweise auch für Bewertungsseiten wie Yelp. **Solange es Text erkennt, spielt das Format (Klartext, PDF, HTML oder andere) keine Rolle**. Denn statt Dateien zu indexieren, arbeitet Lucene mit Text und Metadaten. Trotzdem müssen aber Dateien aus der Bibliothek ausgelesen werden. Zu diesem Zweck entwickelte das Lucene-Team das inzwischen selbstständige **Apache-Projekt Tika**. [Apache Tika](https://tika.apache.org/index.html "Tika: Text erkennen und extrahieren") ist ein praktisches Werkzeug zur Textanalyse, Übersetzung oder Indexierung. Aus über tausend Dateitypen liest das Werkzeug **Text sowie Metadaten** aus. Anschließend extrahiert es den Text und stellt ihn für die weitere Bearbeitung bereit. Tika besteht aus einem Parser und einem Detektor. Der **Parser** analysiert Texte und strukturiert den Inhalt in einer geordneten Hierarchie. Der **Detektor** typisiert Inhalte. Er erkennt beispielsweise den Dateitypen aber auch die Art des Inhalts aus den Metadaten. **Die wichtigsten Funktionen und Features von Lucene**: - Schnelle Indizierung, sowohl stufenweise als auch stapelweise (laut eigenen Angaben bis zu 150 GB pro Stunde) - Sparsame Nutzung von RAM - Durchgehend in Java geschrieben, daher plattformübergreifend (Varianten in alternativen Programmiersprachen sind Apache Lucy und Lucene.NET) - Schnittstelle für Plugins - Suche nach Textfeldern (Kategorien wie Inhalt, Titel, Autor, Schlagwort) – auch nach mehreren gleichzeitig - Sortierung nach Textfeldern - Nach Ähnlichkeit/Relevanz gegliederte Auflistung der Suchergebnisse Lucene unterteilt Dokumente in **Textfelder** wie Titel („title“), Autor („author“) und Textkörper („text“). Innerhalb dieser Felder sucht die Software mit dem **Query-Parser** (Anfrageanalysierer). Dieser gilt als besonders effizientes Werkzeug für Suchanfragen mit manueller Texteingabe. Die einfache **Syntax** besteht aus einem Suchterminus und einem Modifier. Suchtermini können einzelne Wörter oder Wortgruppen sein. Diese justieren Sie mit einem Modifier oder Sie verknüpfen mehrere Termini mit Booleschen Variablen zu einer komplexen Anfrage. In der Apache-Anleitung zur [Syntax des Query-Parsers](https://lucene.apache.org/core/3_5_0/queryparsersyntax.html#Term%20Modifiers "Apache Lucene Query-Parser: Befehle") finden Sie die genauen Befehle. Lucene unterstützt auch **unscharfe Suche** auf Basis der **Levenshtein-Distanz**. Letztere erfasst die Anzahl von Zeichenänderungen (also **Ersetzen, Einfügen oder Löschen)**, um von einer sinnbehafteten Zeichenkette zu einer anderen zu gelangen. Ein Beispiel: „Lupe“ (ersetze p durch k) zu „Luke“ hat eine Distanz von 1, weil nur eine **Umwandlungsoperation** nötig war. Sie selbst können einen Wert festlegen, der bestimmt, wie groß Abweichungen zum Originalsuchbegriff sein dürfen, damit der betreffende Begriff noch in den Suchtreffern berücksichtigt wird. Dieser Wert liegt zwischen 0 und 1 – je näher er an 1 liegt, desto stärker muss der Suchtreffer dem Ausgangswort ähneln. Geben Sie keinen Wert an, liegt dieser automatisch bei 0,5. Entsprechender Befehl sieht dann so aus. ```none lupe~ ``` Wollen Sie einen bestimmten Wert festlegen (Im Beispiel 0,9), dann geben Sie folgenden Befehl ein: ```none lupe~0.9 ``` Ähnlich aufgebaut ist die **Umgebungssuche**, mit der Sie Wörter suchen und außerdem festlegen, wie weit Suchbegriffe im Text voneinander entfernt stehen dürfen, um relevant zu bleiben. Suchen Sie beispielsweise nach der Phrase „Alice im Wunderland“, können Sie festlegen, dass die Wörter „Alice“ und „Wunderland“ in einem 3-Wort-Radius liegen müssen: ```none "alice wunderland"~3 ``` ### Was ist eine vertikale Suchmaschine? Lucene ermöglicht die Suche im World Wide Web und innerhalb von Domains. Suchmaschinen, die eine große Bandbreite von Seiten abdecken, nennt man horizontale Suchmaschinen. Dazu gehören die bekannten Anbieter **Google**, **Bing**, **Yahoo** oder auch DuckDuckGo und Startpage. **Eine vertikale Suchmaschine beschränkt sich hingegen entweder auf eine Domain, ein bestimmtes Thema oder eine Zielgruppe**. Eine domainspezifische Suchmaschine hilft den Besuchern Ihrer Website, spezifische Texte oder Angebote auf Ihrer Webpräsenz zu finden. Beispiele für thematisch ausgerichtete Suchmaschinen sind Empfehlungsportale wie **TripAdvisor** oder **Yelp** – aber auch Jobsuchmaschinen. Zielgruppengenaue Suchmaschinen richten sich beispielsweise an Kinder und Jugendliche oder Wissenschaftler, die nach Quellen suchen. Durch **fokussierte Crawler** (anstelle von Webcrawlern) finden vertikale Suchmaschinen genauere Treffer. Eine Bibliothek wie Lucene, die ihren Index durch **Taxonomie-Prinzipien** in Klassen einteilt und diese durch **Ontologie** logisch verbindet, ermöglicht erst diese genaue Volltextsuche. Vertikale Suchmaschinen nutzen zudem thematisch passende Filter, die die Anzahl der Ergebnisse beschränken. Fakt Ontologie und Taxonomie sind zwei Prinzipien innerhalb der Informatik, die für die zweckgemäße Archivierung wichtig sind. **Taxonomie** beschäftigt sich mit der Aufteilung von Begriffen in **Klassen**. Diese gliedert sie in eine **Hierarchie**, ähnlich einem Baumdiagramm. Die **Ontologie** geht noch einen Schritt weiter und setzt Begriffe in eine logische Beziehung zueinander. Begriffsgruppen sammeln sich in Clustern, die eine enge Beziehung signalisieren. Darüber hinaus verbindet man verwandte Begriffsgruppen miteinander, sodass ein **Netzwerk aus Beziehungen** entsteht. Der Index von Lucene stellt ein praktisches, skalierbares Archiv für schnelle Suchen dar. Doch gibt es einige essenzielle Arbeitsschritte, die Sie häufig wiederholen müssen, die aber nicht automatisch stattfinden. Für die vertikale Suche benötigen Sie schließlich einen weit verzweigten Index. An dieser Stelle kommt Apache Solr ins Spiel. **Der Such-Server ergänzt die Funktionen der Bibliothek**. Und Solr lässt sich mit den richtigen Befehlen schnell und einfach einrichten – selbst von Java-Einsteigern. Das Servlet bietet Ihnen viele praktische Tools, mit denen Sie in kürzester Zeit eine **vertikale Suchmaschinen für Ihre Internetpräsenz einrichten und auf die Bedürfnisse Ihrer Besucher abstimmen können**. ## Was ist Solr? Funktionsweise des Such-Servers Da Sie nun grundlegende Informationen zum Fundament Lucene und zum Anwendungsbereich von Solr haben, erklären wir nachfolgend, wie der Such-Server überhaupt funktioniert, wie er Lucene erweitert und wie Sie damit arbeiten. ### Solr: Grundlegende Elemente **Solr** ist in Java geschrieben, sodass Sie das Servlet plattformunabhängig nutzen können. Befehle schreiben Sie normalerweise in **HTTP** (Hypertext Transfer Protocol), für zu speichernde Dateien nutzen Sie **XML** (Extensible Markup Language). Über ein [API (application programming interface)](https://www.ionos.at/digitalguide/websites/web-entwicklung/was-ist-eine-api/ "Was ist eine API?") bietet Apache Solr auch **Python- und Ruby-Entwicklern** ihre gewohnte Programmiersprache. Denjenigen, die normalerweise mit der JavaScript Object Notation (kurz: JSON) arbeiten, bietet hingegen ElasticSearch 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 Architektur ein, doch funktioniert Solr auch allein. Es ist kompatibel mit Server-Containern wie **Apache Tomcat.** **Indexierung für genaue Suchergebnisse – in Sekundenbruchteilen** Strukturell gesehen liegt dem Servlet eine **invertierte Datei** (Englisch: inverted index) zugrunde. Dafür nutzt Solr klassischerweise die Bibliothek von Lucene. Invertierte Dateien sind eine Unterart des Datenbankindex. Sie sollen den **Aufruf von Informationen beschleunigen**. Innerhalb der Bibliothek speichert der Index Inhalte ab. Das können Wörter oder Zahlen sein. Sucht ein Nutzer auf einer Webpräsenz nach bestimmten Inhalten, gibt die Person meist ein oder zwei themenrelevante Suchbegriffe ein. Anstatt die gesamte Website mit Crawlern nach diesen Wörtern abzusuchen, nutzt Solr dann die **Bibliothek**. Diese **indiziert alle wichtigen Schlagwörter** nahezu in Echtzeit und verbindet sie mit Dokumenten der Website, in denen die gesuchten Wörter vorkommen. **Die Suche durchläuft dabei lediglich den Index, um einen Begriff zu finden**. Die Ergebnisliste zeigt alle Dokumente an, die laut Index mindestens einmal dieses Wort enthalten. Diese Art der Suche entspricht der analogen Suche innerhalb eines Fachbuchs: Suchen Sie am Ende des Buches im Register nach einem Schlagwort, 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 dementsprechend eine Ergebnisliste mit Verlinkungen zu den jeweiligen Dokumenten. Damit dieser Prozess reibungslos funktioniert, muss man theoretisch jedes Mal, wenn ein neues Dokument in das Portfolio der Website eingeht, **sämtliche Schlagwörter und Metadaten (zum Beispiel zum Autor oder Erscheinungsjahr) in die Bibliothek eintragen**. Dadurch ist bei Lucene die Arbeit im Backend mitunter etwas mühselig. Doch durch Solr lassen sich solche Arbeitsschritte automatisieren. **Relevanz und Filter** Apache Solr nutzt die Ontologie und Taxonomie von Lucene, um besonders genaue Suchergebnisse auszugeben. Dabei helfen die **Booleschen Variablen** und **[Trunkierungen](https://www.ub.hu-berlin.de/de/bibliotheksglossar/trunkierung "Definition von Trunkierung der Humbold-Universität Berlin")**, 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 Suchanfragen, auch wenn diese aus komplexen Variablen bestehen. So optimiert es die Suchgeschwindigkeit. Wollen Sie Nutzer auf Ihrer Webseite halten, sollten Sie ihnen eine gute User Experience bieten. Dazu gehört insbesondere, die richtigen Angebote zu machen. Suchen Ihre Besucher beispielsweise nach Informationen über Hühnerhaltung, sollten Texte über deren Aufzucht und Fressverhalten als erste Suchergebnisse oben in der Liste erscheinen. Rezepte mit Huhn oder gar Filme über Hühner sollten hingegen nicht zu den Suchergebnissen gehören oder zumindest weiter unten erscheinen. Unabhängig davon, ob User nach einem bestimmten Begriff suchen oder ob sie am Ende eines spannenden Artikels interessante Themenvorschläge mit internen Verlinkungen angezeigt bekommen sollen: In beiden Fällen ist die **Relevanz der Ergebnisse das A und O**. Und damit dem Suchenden auch tatsächlich nur für ihn relevante Suchergebnisse angezeigt werden, nutzt Solr das **Tf-idf-Maß.** Fakt Der Begriff **Term-Frequency-Inverse-Document-Frequency oder tf-idf** (Deutsch: Begriffshäufigkeit zur inversen Dokumenthäufigkeit) steht für eine numerische Statistik. Dabei wird die Suchwortdichte in einem Dokument (also die Zahl, wie oft ein einzelner Begriff im Text vorkommt) der Zahl an Dokumenten im gesamten Such-Pool gegenübergestellt, die den Begriff enthalten. So sehen Sie, ob ein Suchbegriff im Kontext eines Dokumentes wirklich häufiger auftritt als in der Gesamtheit der Texte. ### Solr: Die wichtigsten Funktionen **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 ausschlaggebende Maßeinheit. Der Index besteht aus mehreren Dokumenten, diese wiederum aus mehreren Textfeldern. In der Datenbank steht ein Dokument in einer Tabellenreihe. Ein Feld steht in der Tabellenspalte. Gekoppelt über ein API mit **Apache Zookeper** verfügt Solr über eine zentrale Anlaufstelle, die sowohl Synchronisierung, Namensregister und die Verteilung der Konfiguration bereitstellt. Dazu gehört beispielsweise ein **Ringalgorithmus**, der Prozessen innerhalb eines verteilten Systems einen **Koordinator** (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 Funktionen stellen sicher, dass Ihr Projekt immer frei skalierbar bleibt. Dazu gehört auch, dass die Suchmaschine selbst unter härtesten Bedingungen 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 Datensätze horizontal fragmentieren – auch Sharding genannt. Dafür unterteilen Sie Ihre Bibliothek in logisch verknüpfte Fragmente. So **erweitern Sie Ihre Bibliothek** über den sonst möglichen Speicherplatz hinaus. Apache empfiehlt zudem, mehrere Kopien Ihrer Bibliothek auf verschiedene Server zu laden. So erhöhen Sie Ihren Replikationsfaktor. Kommen viele Anfragen gleichzeitig rein, werden diese auf die unterschiedlichen Server verteilt. Die Volltextsuche, mit der Lucene bereits aufwartet, baut Solr mit weiteren Funktionen aus. Diese **Such-Features** umfassen unter anderem: - **Begriffsanpassung** auch für Wortgruppen: Das System erkennt Rechtschreibfehler in der Sucheingabe und bietet Ergebnisse für eine korrigierte Alternative. - **Joins**: Eine Mischung aus dem kartesischen Produkt (mehrere Begriffe werden bei der Suche in jedweder Reihenfolge beachtet) und Selektion (Nur Begriffe, die eine bestimmte Voraussetzung erfüllen, werden angezeigt), also eine komplexe Boolesche VariablenSyntax - **Gruppierung** von thematisch verwandten Begriffen. - **Facettenklassifikation**: Das System ordnet jedes einzelne Informationselement anhand mehrerer Dimensionen ein. Zum Beispiel verknüpft es einen Text mit Stichwörtern wie dem Autorennamen, der Sprache und der Textlänge. Dazu kommen Themen, die der Text behandelt, sowie eine zeitliche Einordnung. Die Facettensuche erlaubt dem Nutzer, mehrere Filter einzusetzen und so eine individuelle Ergebnisliste zu erhalten. - **WildcardSuche**: Ein Zeichen steht für ein undefiniertes Element oder gleich mehrere solcher Elemente in einer Zeichenkette? Für ein Zeichen verwenden Sie dann „?“, für mehrere nehmen Sie „\*“. Sie können beispielsweise ein Wortfragment plus den Platzhalter eingeben (zum Beispiel: Lehr\*). Die Ergebnisliste bezieht dann alle Begriffe mit diesem Wortstamm ein (zum Beispiel: Lehre, Lehrerin, lehren, lehrreich). So erhalten Nutzer Treffer zu diesem Themenfeld. Die nötige Relevanz ergibt sich aus der Themeneingrenzung Ihrer Bibliothek oder weiteren SuchEingrenzungen. Suchen Nutzer beispielsweise nach „B?nd“, erhalten sie Ergebnisse wie Band, Bond, Bund. Wörter wie „binden“ oder „verbindlich“ erfasst die Suche jedoch nicht, da das „?“ nur einen Buchstaben ersetzt. - **Erkennt Text in vielen Formaten**, von Microsoft Word über Texteditoren bis PDF und indizierte RichInhalte. - **Erkennt unterschiedliche Sprachen.** Außerdem kann das Servlet mehrere **Kerne** (English: Cores) einbinden. Diese Kerne bestehen aus Lucene-Indizes. Der Kern sammelt also sämtliche Informationen in einer **Bibliothek**. Auch **Konfigurationsdateien und Schemata** finden Sie dort. Damit legen Sie das Verhalten von Apache Solr fest. Wollen Sie Erweiterungen nutzen, integrieren Sie einfach eigene Skripte oder Plug-ins aus Community-Beiträgen in die Konfigurationsdatei.
Vorteile Nachteile
Erweitert Lucene um praktische Features Weniger geeignet für dynamische Daten und Objekte
Automatische Echtzeit-Indexierung Kerne hinzufügen und Fragmente aufspalten nur manuell möglich
Volltextsuche Globaler Cache kann im Vergleich zum segmentierten Cache Zeit und Speicherplatz kosten
Facettierung und Gruppierung von Schlagwörtern
Erleichtert horizontale Skalierung von Suchservern
Volle Kontrolle über Fragmente
Leicht in eigene Website integrierbar
## Tutorial: Apache Solr herunterladen und einrichten Die Systemvoraussetzungen für Solr sind nicht sonderlich hoch. Sie benötigen lediglich ein Java SE [Runtime Environment](https://www.ionos.at/digitalguide/websites/web-entwicklung/was-ist-eine-laufzeitumgebung/ "Was ist eine Laufzeitumgebung?") ab Version 1.8.0. Die Entwickler testeten das Servlet auf Linux/Unix, macOS und Windows in verschiedenen Versionen. Laden Sie einfach das entsprechende Installationspaket herunter und entpacken Sie die .zip-Datei (Windows-Paket) oder die .tgz-Datei (Unix-, Linux- und OSX-Paket) in einem Verzeichnis Ihrer Wahl. ## Solr-Tutorial: Schritt 1 – Herunterladen und starten 1. Dafür besuchen Sie die [Solr-Projektseite](https://lucene.apache.org/solr/ "das Solr-Projekt") im Apache-Lucene-Hauptprojekt. Oben im Fenster sehen Sie die **Menüleiste**. Unter „Features“ informiert Apache kurz über die Solr-Funktionen. Unter „Resources“ finden Sie Tutorials und die Dokumentation. Unter „Community“ hilft Ihnen die Solr-Anhängerschaft bei Fragen weiter. In diesem Bereich können Sie auch eigene Builds einbringen. 2. Für die Installation klicken Sie auf den **Download-Button**. Über diesen erreichen Sie die Download-Seite mit einer Liste von Mirror-Downloads. Die aktuelle Solr-Version (7.3, Stand: Mai 2018) über einen geprüften Anbieter sollte ganz oben stehen. Alternativ wählen Sie aus **HTTP-Links und FTP-Download**. Klicken Sie auf einen Link, gelangen Sie zur Mirror-Seite des jeweiligen Anbieters. [![Bild: Index der Solr-Download-Pakete auf Mirror-Service](https://www.ionos.at/digitalguide/fileadmin/_processed_/d/2/csm_Solr0_46f275cf45.webp "Index der Solr-Download-Pakete auf Mirror-Service")](https://www.ionos.at/digitalguide/fileadmin/DigitalGuide/Screenshots_2018/Solr0.jpg) Index der Solr-Download-Pakete auf Mirror-Service 3. Im oberen Bild sehen Sie die verschiedenen **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 Entwickler. 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- beziehungsweise Unix-User. - solr7.3.0.zip enthält das windowskompatible Solr-Paket. - im Ordner changes/ finden Sie die Dokumentation für entsprechende Version. Nachdem Sie die für Ihre Ansprüche optimale Version per Mausklick ausgewählt haben, erscheint ein Download-Fenster. Speichern Sie die Datei. Ist der Download dann abgeschlossen, klicken Sie auf den Download-Button in Ihrem Browser oder öffnen Sie Ihren Download-Ordner. 4. **Entpacken** Sie die zip-Datei beziehungsweise die .tgz-Datei. Wollen Sie sich zuerst mit Solr vertraut machen, wählen Sie zunächst ein **beliebiges Verzeichnis**. Dort speichern Sie die entpackten Dateien ab. Wissen Sie bereits, in welchem Umfang Sie Solr nutzen wollen, wählen Sie den dafür vorgesehenen **Server**. Oder bauen Sie eine **geclusterte Solr-Cloud-Umgebung**, wenn Sie nach oben skalieren wollen. (Mehr zur Cloud im nächsten Kapitel) Hinweis Theoretisch kann eine einzelne Lucene-Bibliothek etwa 2.14 Milliarden Dokumente indexieren. Diese Zahl erreichen Sie aber in der Praxis generell nicht, bevor die Anzahl der Dokumente die Performance beeinflusst. Bei einer entsprechend hohen Zahl an Dokumenten ist es daher ratsam, von vornherein mit einer Solr-Cloud zu planen. 5. In unserem Linux-Beispiel liegt Solr auf Home. Wir arbeiten mit Solr 7.3.0. Der Code in diesem Tutorial wurde in Ubuntu getestet. Die Beispiele können Sie also auch für macOS nutzen. Die Befehle funktionieren prinzipiell auch unter Windows, aber mit Backslashes statt normalen Slashes. [![Bild: Kommandozeile unter Ubuntu 17. “bin/solr –e techproducts” startet eine Demo mit vorgegebenen Daten und Konfigurationen](https://www.ionos.at/digitalguide/fileadmin/_processed_/3/0/csm_Solr_082e5133fa.webp "Kommandozeile unter Ubuntu 17. “bin/solr –e techproducts” startet eine Demo mit vorgegebenen Daten und Konfigurationen")](https://www.ionos.at/digitalguide/fileadmin/DigitalGuide/Screenshots_2018/Solr.jpg) Kommandozeile unter Ubuntu 17. 'bin/solr –e techproducts' startet eine Demo mit vorgegebenen Daten und Konfigurationen Geben Sie „cd /\[Quellpfad\]“ in die Kommandozeile ein, um das Solr-Verzeichnis zu öffnen und starten Sie das Programm. In unserem Beispiel sieht das so aus: ```none cd /home/test/Solr/solr-7.3.0 bin/solr start ``` Der Solr-Server läuft nun auf Port 8983. Eventuell fragt Ihre Firewall, ob Sie das genehmigen. Bestätigen Sie das. Wollen Sie Solr anhalten, geben Sie folgenden Befehl ein: ```none bin/solr stop -all ``` Funktioniert Solr, machen Sie sich mit der Software vertraut. Mit der Solr-Demo starten Sie das Programm alternativ in einem von vier Modi: - SolrCloud (Befehl: cloud) - DatenimportHandler (Befehl: dih) - Ohne Schema (Befehl: schemaless) - Ausführliches Beispiel mit KitchenSink (Befehl: techproducts) Die Beispiele verfügen über ein jeweils angepasstes Schema. Dieses bearbeiten Sie über die Schema-Schnittstelle. Dafür geben Sie diesen Befehl ein (der Platzhalter \[beispiel\] steht jeweils für eines der oben angegebenen Schlagwörter): ```none bin/solr -e [beispiel] ``` 6. Damit läuft Solr in dem entsprechenden Modus. Wollen Sie sichergehen, rufen Sie den **Statusreport** ab: ```none bin/solr status Found 1 Solr nodes: Solr process xxxxx running on port 8983 ``` 7. Die Beispiele enthalten vorkonfigurierte Grundeinstellungen. Starten Sie ohne Beispiel, müssen Sie **Schema und Kern selbst festlegen**. Der Kern speichert Ihre Daten. Ohne ihn können Sie weder Dateien indexieren noch suchen. Um einen Kern zu erstellen, geben Sie folgenden Befehl ein: ```none bin/solr create –c ``` 8. Apache Solr verfügt über eine **webbasierte Benutzeroberfläche**. Wenn Sie das Programm erfolgreich gestartet haben, finden Sie die **Solr-Admin-Webapp** in Ihrem Browser unter der Adresse *“http://localhost:8983/solr/”*. [![Bild: Übersichtsseite der Solr-Web-App mit Angaben zum physischen Speicher, Auslagerungsspeicher, Datei-Index-Zähler und JVM-Speicher](https://www.ionos.at/digitalguide/fileadmin/_processed_/b/4/csm_Solr2_7b2208cfb0.webp "Übersichtsseite der Solr-Web-App mit Angaben zum physischen Speicher, Auslagerungsspeicher, Datei-Index-Zähler und JVM-Speicher")](https://www.ionos.at/digitalguide/fileadmin/DigitalGuide/Screenshots_2018/Solr2.jpg) Übersichtsseite der Solr-Web-App mit Angaben zum physischen Speicher, Auslagerungsspeicher, Datei-Index-Zähler und JVM-Speicher 9. Abschließend stoppen Sie Solr mit diesem Befehl wieder: ```none bin/solr stop -all ``` ### Solr-Tutorial: Teil 2: erste Schritte Solr stellt Ihnen ein einfaches Kommando-Tool zur Verfügung. Mit dem sogenannten **Post-Tool** können Sie Inhalte auf Ihren Server laden. Das können sowohl Dokumente für den Index sein als auch Schema-Konfigurationen. Das Tool greift zu diesem Zweck auf Ihre Sammlung zu. Deshalb müssen Sie immer den **Kern** beziehungsweise die **Sammlung angeben**, bevor Sie damit arbeiten. Im folgenden Code-Beispiel geben wir zuerst die allgemeine 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 zusätzliche 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 jeweiligen Format in Ihre Sammlung hoch (Zeile zwei und drei). Das Kommando „-d“ löscht Dokumente Ihrer Sammlung (Zeile vier). ```none bin/post –c [Optionen] bin/post –c -p 8983 *.xml bin/post –c *.csv bin/post –c -d '42' ``` Nun kennen Sie einige der grundlegenden Befehle für Solr. Wie genau Sie vorgehen, wenn Sie Apache Solr einrichten, 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 techproducts. Folgendes geben Sie in das Terminal ein: ```none bin/solr –e techproducts ``` Solr startet standardmäß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: ```none Creating Solr home directory /tmp/solrt/solr-7.3.1/example/techproducts/solr Starting up Solr on port 8983 using command: bin/solr start -p 8983 -s "example/techproducts/solr" Waiting up to 30 seconds to see Solr running on port 8983 [/] Started Solr server on port 8983 (pid=12281). Happy searching! Setup new core instance directory: /tmp/solrt/solr-7.3.1/example/techproducts/solr/techproducts Creating new core 'techproducts' using command: http://localhost:8983/solr/admin/cores?action=CREATE&name=techproducts&instanceDir=techproducts {"responseHeader": {"status":0, "QTime":2060}, "core":"techproducts"} Indexing tech product example docs from /tmp/solrt/solr-7.4.0/example/exampledocs SimplePostTool version 5.0.0 Posting files to [base] url http://localhost:8983/solr/techproducts/update… using content-type application/xml... POSTing file money.xml to [base] POSTing file manufacturers.xml to [base] POSTing file hd.xml to [base] POSTing file sd500.xml to [base] POSTing file solr.xml to [base] POSTing file utf8-example.xml to [base] POSTing file mp500.xml to [base] POSTing file monitor2.xml to [base] POSTing file vidcard.xml to [base] POSTing file ipod_video.xml to [base] POSTing file monitor.xml to [base] POSTing file mem.xml to [base] POSTing file ipod_other.xml to [base] POSTing file gb18030-example.xml to [base] 14 files indexed. COMMITting Solr index changes to http://localhost:8983/solr/techproducts/update... Time spent: 0:00:00.486 Solr techproducts example launched successfully. Direct your Web browser to http://localhost:8983/solr to visit the Solr Admin UI ``` 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-Nutzeroberfläche** geht das recht einfach. Rufen Sie den Solr-Server in Ihrem Browser auf. In unserer Techproducts-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 festgelegt haben, nutzen Sie folgende Form und setzen jeweils den Server-Namen und die Port-Nummer an der entsprechenden Stelle ein: “http://\[Servername\]:\[Port-Nummer\]/solr”. Dort steuern Sie den Ordner **example/exampledocs** 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: ```none cd example/exampledocs Java -Dc=techproducts –jar post.jar more_books.jsonl ``` Hat Solr Ihre Datei erfolgreich in den Index geladen, erhalten Sie diese Nachricht: ```none SimplePostTool version 5.0.0 Posting files to [base] url http://localhost:8983/solr/techproducts/update POSTing file more_books.jsonl to [base] 1 files indexed. COMMITting Solr index changes to http://localhost:8983/solr/techproducts/update... Time spent: 0:00:00.162 ``` 3. Wenn Sie den Apache-Solr-Such-Server aufsetzen, sollten Sie direkt die **Konfigurationsdateien und das Schema** miteinstellen. In den Demo-Beispielen sind diese gleich vorgegeben. 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 Unterteilung erleichtert die zielgerichtete Volltextsuche. Solr arbeitet mit diesen Feldern. Ein bestimmter Feldtyp akzeptiert bestimmte Inhalte (beispielsweise <date> nur Datumsangaben 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 eingespeisten Dokumente Feldtypen vor. In der Testphase ist das praktisch, da Sie einfach anfangen, den Katalog zu füllen. Später kann solch ein Vorgehen allerdings zu Problemen führen. Das sind einige grundlegende Solr-**Feldtypen**: - DateRangeField (indexiert Zeitspannen und Zeitpunkte bis zur Millisekunde) - ExternalFileField (zieht Werte aus einem externen Ordner) - TextField (allgemeines Feld für Texteingabe) - BinaryField (für binäre Daten) - CurrencyField indexiert zwei Werte separat, aber zeigt sie dem Endnutzer als einen Wert an. CurrencyField speichert einen Zahlenwert (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 analysiert oder durch ein Token ersetzt.) Eine ausführliche Liste von **Solr-Feldtypen** sowie weiteren Befehlen für **Schema-Einstellungen** finden Sie im [Solr-Wiki](https://wiki.apache.org/solr/SchemaXml "Solr-Wiki SchemaXML"). Um Feldtypen festzulegen, rufen Sie die schema.xml unter *“http://localhost:8983/solr/techproducts/schema”* auf. Techproducts hat bereits Feldtypen festgelegt. Eine **Kommandozeile** in der XML-Datei beschreibt die Eigenschaften eines Feldes anhand von **Attributen** näher. Laut Dokumentation 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 eingetragen“. Wenn der Wert „true“ ist, kann man nach dem Feld suchen oder es sortieren.) - stored (Beschreibt, ob ein Feld eingelagert wird, steht der Wert auf „true“, ist das Feld aufrufbar.) - multiValued (Beinhaltet ein Feld mehrere Werte für ein Dokument, tragen Sie hier den Wert „true“ ein.) - default (Hier tragen Sie einen Standardwert ein, der erscheint, wenn für ein neues Dokument kein Wert festgelegt ist.) - compressed (Selten, da nur bei gzipkomprimierbaren Feldern anwendbar, standardmäßig auf „false“ eingestellt. Muss auf „true“ stehen, um zu komprimieren.) - omitNorms (Standardmäßig auf „true“ eingestellt. Spart Normen für ein Feld aus und spart so auch Speicher.) - termOffsets (Benötigt mehr Speicherplatz. Speichert Vektoren zusammen mit OffsetInformationen – also Speicher-Adresszusätze.) - termPositions (Benötigt mehr Speicherplatz, da es die Position von Termen zusammen mit dem Vektor speichert.) - termVectors (Steht standardmäßig auf „false“, speichert VektorTermen, wenn „true“.) Feldeigenschaften 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: ```none ``` Alternativ können Sie wieder das Eingabe-Terminal nutzen. Dort geben Sie einfach einen [Curl-Befehl](https://www.ionos.at/digitalguide/server/tools/einstieg-in-curl-in-linux/ "Einstieg in cURL in Linux") ein, legen die Feldeigenschaften fest und senden es über die Schema-Schnittstelle, indem Sie die Dateiadresse angeben: ```none curl -X POST -H 'Content-type:application/json' --data-binary '{"add-field": {"name":"name", "type":"text_general", "multiValued":false, "stored":true}}' http://localhost:8983/solr/techproducts/schema ``` 4. Nachdem Sie das Schema angepasst haben, ist die Solr-Konfiguration an der Reihe. Über diese legen Sie die Sucheinstellungen fest. Das sind wichtige Bestandteile: - AnfrageCache-Parameter - AnfrageHandler (auch: Request-Handler) - Standort des Datenverzeichnisses - Suchkomponente Die **Anfrage-Cache-Parameter** ermöglichen drei Arten von Caching: **LRUCache**, **LFUCache** und **FastLRUCache**. LRUCache nutzt eine verlinkte Hash-Map, FastLRUCache sammelt Daten über eine gleichzeitige Hash-Map. Diese Hash-Map bearbeitet Anfragen gleichzeitig. So produziert der Such-Server schneller Antworten, falls viele Suchanfragen parallel eintreffen. Der FastLRUCache liest Daten schneller als der LRUCache aus und fügt langsamer ein. Fakt Eine HashMap (auch: Hash-Map) ordnet **Werte** einem **Schlüssel** zu. Der Schlüssel ist eindeutig – pro Schlüssel existiert nur ein Wert. Solch ein Schlüssel ist ein beliebiges Objekt. Daraus berechnet man den **Hash-Wert**. Dieser ist praktisch die „Adresse“, also die genaue Position im Index. Über ihn findet man die Schlüsselwerte innerhalb einer Tabelle. Der **Anfrage-Handler** verarbeitet Anfragen. Er liest das HTTP-Protokoll aus, sucht im Index und gibt die Antworten aus. Die Techproducts-Beispiel-Konfiguration beinhaltet den Standard-Handler für Solr. Die Suchkomponenten finden Sie als Liste im Anfrage-Handler. Diese Elemente führen die Suche durch. **Standardmäßig enthält der Handler folgende Suchkomponenten:** - query (Anfrage) - facet (Facettierung) - mlt (More Like This) - highlight (Beste) - stats (Statistik) - debug (Fehler ausmerzen) - expand (Suche ausweiten) Für die Suchkomponente More Like This (mlt) geben Sie beispielsweise diesen Befehl ein: ```none ``` **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 Webseitenbesucher, indem sie den String und die indizierten Felder vergleicht. Um die Liste zu konfigurieren, **öffnen Sie zunächst den Anfrage-Handler**: ```none explicit ``` Fügen Sie der Liste im Request-Handler selbst festgelegte Komponenten hinzu oder ändern Sie bestehende **Suchkomponenten**. Diese Komponenten **übernimmt die Suche**, wenn später ein Webseitenbesucher auf Ihrer Domain eine Suchanfrage eingibt. Folgender Befehl fügt eine selbst gebaute Komponente vor den Standard-Komponenten ein: ```none NameDerEigenenKomponente ``` So fügen Sie die Komponente nach den Standard-Komponenten ein: ```none NameDerEigenenKomponente ``` So benennen Sie bestehende Komponenten um: ```none facet NameDerEigenenKomponente ``` Das **Standard-Datenverzeichnis** finden Sie im Kern-Instanzen-Verzeichnis „instanceDir“ unter dem Namen „/data“. Wollen Sie ein anderes Verzeichnis nutzen, ändern Sie den Standort über die solrconfig.xml. Dafür geben Sie einen festen Pfad an oder binden Sie den Verzeichnisnamen an den Kern (SolrCore) oder das Instanzen-Verzeichnis (instanceDir). Für die Bindung an den Kern schreiben Sie: ```none /solr/data/$(solr.core.name) ``` ### Solr Tutorial Teil 3: Ein Solr-Cloud-Cluster bauen Apache Solr stellt eine Cloud-Demo zur Verfügung, anhand derer wir Ihnen die Einrichtung eines Cloud-Clusters erklären. Sie können parallel dazu natürlich auch selber das Beispiel durchspielen. 1. Starten Sie zuerst die Kommandozeilen-Bedienoberfläche. Um Solr im Cloud-Mode zu starten, geben Sie Folgendes im Tool ein: ```none bin/solr -e cloud ``` 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) ```none Welcome to the SolrCloud example! This interactive session will help you launch a SolrCloud cluster on your local workstation. To begin, how many Solr nodes would you like to run in your local cluster? (specify 1-4 nodes) [2] Please enter the port for node1 [8983] Please enter the port for node2 [7574] solr start –cloud -s example/cloud/node1/solr -p 8983 solr start –cloud -s example/cloud/node2/solr -p 7574 ``` 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 signalisieren Platzhalter und erscheinen nicht im Code). ```none Please provide a name for your new collection: [Namen_hier_eingeben] ``` 4. Aus dieser Kollektion **erstellen Sie mit SPLITSHARD ein Fragment.** Das können Sie später erneut in Partitionen spalten. So beschleunigen Sie die Suche, falls gleichzeitig mehrere Anfragen eingehen. ```none http://localhost:8983/solr/admin/collections?action=CREATESHARD&shard=[NeuesFragment]&collection[NameDerSammlung] ``` Nachdem Sie mit SPLITSHARD Fragmente erstellt haben, können Sie Ihre Daten mithilfe eines Routers verteilen. Solr integriert den compositeID-Router (router.key=compositeId) standardmäßig. Fakt Ein Router legt fest, wie Daten auf die Fragmente aufgeteilt werden und wie viele Bits der Router-Schlüssel verwendet. Nutzt man beispielsweise 2 Bits, indexiert der Router Daten auf jeweils einem Viertel Speicherplatz pro Fragment. Das verhindert, dass große Datensätze auf einem einzigen Fragment den gesamten Speicher einnehmen. Denn das würde die Suche verlangsamen. Um den Router zu nutzen, geben Sie einen Router-Wert (zum Beispiel einen User-Namen wie MaxMuster1), die Bit-Zahl und die Dokumentidentifikation in dieser Form an: \[Nutzername\] / \[Bit-Zahl\]! \[Dokumentidentifikation\] (zum Beispiel: MaxMuster1/2!1234) Über die Schnittstelle teilen Sie das Fragment in zwei Teile. Beide Partitionen enthalten die gleiche Kopie der Originaldaten. Der Index unterteilt sie lediglich entlang der neu entstandenen Unterbereiche. ```none /admin/collections?action=SPLITSHARD&collection=[NameDerSammlung]&shard=[Fragmentnummer] ``` 5. Im letzten Schritt legen Sie den Namen Ihres **Konfiguationsverzeichnisses** fest. Die Vorlagen **sample-techproducts-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 schemalose Funktion von \_default für die Solr-Cloud-Schnittstelle ab**: ```none curl http://localhost:8983/api/collections/[_name_der_sammlung]/config -d '{"set-user-property": {"update.autoCreateFields":"false"}}' ``` Damit verhindern Sie, dass die Felder in Anbetracht der ersten Inhalte selbst Schemata anlegen, die mit den restlichen Dateien nicht kompatibel sind. Da Sie für diese Einstellung die HTTP-Methode POST brauchen, können Sie nicht einfach die Browser-Adresszeile 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 eingerichtet. Um zu sehen, ob Ihre **neue Sammlung** richtig angezeigt wird, fragen Sie wieder den Status ab: ```none bin/solr status ``` Einen genaueren Überblick über die Verteilung Ihrer Fragmente erhalten Sie über die **Admin-Benutzeroberfläche**. Die Adresse besteht aus Ihrem **Server-Namen mit Port-Nummer** und der Verbindung zur Solr-Cloud in dieser Form: *“http://servername:portnummer/solr/#/~cloud”* ## Apache Solr mit Plug-ins erweitern Apache Solr verfügt bereits über einige Erweiterungen. Das sind die sogenannten **Handler**. Den Anfrage-Handler haben wir bereits vorgestellt. Lucene (und somit auch Solr) unterstützt zudem einige praktische native Skripte wie die **Solr-Analyzer-Klasse** und die **Similarity-Klasse**. Plug-ins integrieren Sie in Solr über eine [JAR-Datei](https://www.ionos.at/digitalguide/server/knowhow/jar-format/ ".jar-Format"). Bauen Sie eigene Plug-ins und interagieren diese mit Lucene-Schnittstellen, sollten Sie die lucene-\*.jars aus Ihrer Bibliothek (solr/lib/) zu dem Klassenweg hinzufügen, mit dem Sie Ihren Plug-in-Quellcode zusammentragen. Diese Methode funktioniert, wenn Sie nur einen Kern nutzen. Nutzen Sie die Solr-Cloud, erstellen Sie eine **gemeinsame Bibliothek** für die JAR-Dateien. Dafür legen Sie ein Verzeichnis 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 Verzeichnis für die **Bibliothek** mit dem Befehl „mkdir“ (unter Windows: „md“) in dieser Form: ```none mkdir solr/[beispiel]/solr/SammlungA/lib ``` Machen Sie sich noch mit Solr vertraut und probieren eines der mitgelieferten **Demos** aus, steuern Sie stattdessen „example/solr/lib“ an. In beiden Fällen befinden Sie sich nun im Bibliotheksverzeichnis Ihres Instanzenverzeichnisses. Dort speichern Sie Ihre **Plug-in-JAR-Dateien**. Alternativ nutzen Sie die alte Methode aus früheren Solr-Versionen, wenn Sie beispielsweise auf Ihrem Servlet-Container mit der ersten Variante keinen Erfolg haben. - Dazu entpacken Sie die solr.warDatei. - Fügen Sie dem **WEBINF/lib**Verzeichnis dann die **JARDatei** mit Ihren selbstgebauten Klassen hinzu. Sie finden das Verzeichnis über die WebApp auf diesem Pfad: *server/solrwebapp/webapp/WEB-INF/lib.* - Komprimieren Sie die abgeänderte WARDatei wieder. - Nutzen Sie Ihre maßgeschneiderte solr.war. Erweitern Sie die Bibliothek um eine „dir“-Option, fügt diese alle Dateien innerhalb des jeweiligen Verzeichnisses (Englisch: directory) dem Klassenpfad zu. Mit „regex=“ schließen Sie Dateien aus, die nicht den „regex“-Vorgaben entsprechen. ```none ``` Bauen Sie selber ein Plug-in-Skript, empfiehlt sich für die Java Runtime unter anderem der Lisp-Dialekt **Clojure**. Diese Programmiersprache unterstützt interaktive Programmentwicklung. Andere Sprachen integrieren ihre nativen Eigenschaften. Clojure stellt sie über die Bibliothek bereit. Diese Arbeitsweise eignet sich gut für die Nutzung des Solr-Servlets. Die Programmier- und Skriptsprache **Groovy** unterstützt dynamische und statische Typisierung auf der **Java-Virtual-Machine**. Die Sprache basiert auf Ruby und Python und wird in Java-Byte-Code kompiliert. Dann kann man sie in einem Skript ausführen. Groovy bringt einige Features mit, die die Fähigkeiten von Java erweitern. Zum Beispiel integriert 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 Datenfelder für Listen bereit. Verarbeiten Sie JSON oder XML für Ihren Solr-Such-Server, hilft Groovy, die Syntax sauber und verständlich zu halten. ## Solr vs. Elasticsearch Geht es um Open-Source-Suchmaschinen, liegen Solr und Elasticsearch in Tests und Umfragen immer wieder auf den vordersten Plätzen. Und beide Such-Server bauen auf der Apache-Java-Bibliothek Lucene auf. Lucene ist offensichtlich eine stabile Grundlage. Die Bibliothek indexiert Informationen flexibel und liefert schnell Antworten auf komplexe Suchanfragen. Auf dieser Basis erbringen beide Suchmaschinen überzeugende Leistungen. Jedes der Projekte wird zudem durch eine aktive Community getragen. Das Entwickler-Team um Elasticsearch arbeitet jedoch mit **GitHub**, während Solr bei **der Apache Foundation** beheimatet ist. Im Vergleich kann das Apache-Projekt zudem auf eine längere Geschichte zurückblicken. Und dokumentiert die rege Community bereits seit 2007 alle Änderungen, Features und Bugs. Die Elasticsearch-Dokumentation ist bei Weitem nicht so umfassend, was durchaus auch kritisiert wird. Dennoch steht Elasticsearch in Sachen Nutzerfreundlichkeit nicht unbedingt hinter Apache Solr zurück. Mit Elasticsearch bauen Sie Ihre Bibliothek in wenigen Schritten. Für zusätzliche Funktionen benötigen Sie **Premium-Plug-ins**. Damit verwalten Sie die Sicherheitseinstellungen, überwachen den Such-Server oder analysieren Metriken. Der Such-Server versammelt zudem eine gut aufeinander abgestimmte Produktfamilie um sich. Unter dem Label [Elastic-Stack und X-Pack](https://www.elastic.co/de/subscriptions#request-info "Elasticsearch Preisliste und Funktionen|") erhalten Sie einige Basisfunktionen kostenlos. Die Premium-Pakete stehen Ihnen jedoch nur bei einem monatlichen Abonnement zur Verfügung – mit einer Lizenz pro Knoten. Solr ist hingegen immer kostenlos – inklusive Erweiterungen wie Tika und Zookeeper. Am stärksten unterscheiden sich die beiden Suchmaschinen hinsichtlich der Schwerpunktsetzung. Sowohl Solr als auch Elasticsearch können Sie für kleine Datensätze wie auch für Big-Data nutzen, die sich über mehrere Umgebungen verteilen. Aber Solr konzentriert sich auf Textsuche. Das Konzept von Elasticsearch **verbindet hingegen die Suche mit der Analyse**. Metriken und Logs verarbeitet das Servlet von Anfang an. Entsprechende Mengen an Daten bewältigt Elasticsearch spielend. Denn der Server bindet Kerne und Fragmente dynamisch ein – schon seit der ersten Version. Das hatte Elasticsearch dem Konkurrenten Solr einst voraus, doch seit einigen Jahren ermöglicht die Solr-Cloud ebenso Facettenklassifizierung. Bei **dynamischen Daten** hat Elasticsearch die Nase weiterhin leicht vorn. Dafür punktet der Konkurrent bei **statischen Daten**. Er gibt **zielgenaue Ergebnisse** bei der Volltextsuche aus und berechnet Daten exakt. Die verschiedenen Grundkonzepte spiegeln sich auch im **Caching** wider. Beide Anbieter ermöglichen grundsätzlich Anfrage-Caching. Wenn eine Anfrage komplexe Boolesche Variablen verwendet, speichern beide die aufgerufenen Index-Elemente in **Segmenten**. Diese können zu größeren Segmenten verschmelzen. Ändert sich allerdings nur ein Segment, muss Apache Solr den **ganzen globalen Cache ungültig** machen und neu laden. Elasticsearch **begrenzt diesen Prozess auf das betroffene Teilsegment**. Das spart Speicherplatz und Zeit. Wer regelmäßig mit XML, HTTP und Ruby arbeitet, der wird sich auch in Solr problemlos einarbeiten. JSON hingegen kam erst später über eine Schnittstelle dazu. Deswegen passen die Sprache und das Servlet noch nicht ideal zusammen. Elasticsearch hingegen kommuniziert nativ über JSON. Andere Sprachen wie Python, Java, .NET, Ruby und PHP bindet der Such-Server mit einer REST-ähnlichen Schnittstelle ein. Fazit Apaches Solr und Elastics Elasticsearch sind zwei leistungsstarke Such-Server, die wir fast uneingeschränkt empfehlen können. Wer mehr Wert auf Datenanalyse legt und eine dynamische Webseite betreibt, ist mit Elasticsearch gut beraten. Von Solr profitieren Sie hingegen stärker, wenn Sie für Ihre Domain eine punktgenaue Volltextsuche brauchen. Mit komplexen Variablen und anpassbaren Filtern schneiden Sie Ihre vertikale Suchmaschine genau auf Ihre Ansprüche zu.
Solr Elasticsearch
Typ Freier Open-Source-Such-Server Such-Server auf freier Open-Source-Basis mit proprietären Versionen (kostenlos und Abonnement)
Unterstützte Sprachen Nativ: Java, XML, HTTP API: JSON, PHP, Ruby, Groovy, Clojure Nativ: JSON API: Java, .NET, Python, Ruby, PHP
Datenbank Java-Bibliotheken, NoSQL, mit Ontologie und Taxonomie, besonders Lucene Java-Bibliotheken, NoSQL, besonders Lucene sowie [Hadoop](https://www.ionos.at/digitalguide/server/knowhow/apache-hadoop-das-framework-fuer-big-data/)
Knoten & Fragmentklassifizierung - Eher statisch - Knoten mit Solr-Cloud und Fragmente mit SPLITSHARD lassen sich manuell hinzufügen - Ab Solr7: automatische Skalierung über Schnittstelle - Kontrolle über Fragmente durch Ringalgorithmus - Node Discovery mit Zookeeper-API - Dynamisch - Fügt Knoten und Fragmente über internes Tool zu, weniger Kontrolle über Leader - Node Discovery mit integriertem Zen-Tool
Cache Globaler Cache (gilt für alle Untersegmente in einem Segment) Segmentierter Cache
Volltextsuche - Viele Funktionen im Quellcode enthalten – bietet zudem Lucene-Funktionen - Anfrage-Parser - Vorschlag-Anwendungen - Ähnlichkeitssuche - Rechtschreibprüfung in verschiedenen Sprachen - Kompatibel mit vielen Rich-Text-Formaten - Hervorhebungen - Suche baut hauptsächlich auf Lucene-Funktionen auf - Schnittstelle für Suchvorschläge räumt die Suchmaske für Endnutzer auf, ist aber weniger anpassbar - Rechtschreibprüfung, Matching über API - Hervorhebungen weniger anpassbar
This is a markdown version of: [https://www.ionos.at/digitalguide/server/konfiguration/solr/](https://www.ionos.at/digitalguide/server/konfiguration/solr/) for AI/LLM consumption.