Neo4j Graph Datenbank unter Ubuntu 22.04 installieren
Neo4j ist eine Graphdatenbank, mit der Datenbeziehungen hergestellt werden können. In herkömmlichen Datenbanken werden die Daten in einer tabellenartigen Struktur gespeichert. In einer grafischen Datenbank werden Beziehungen zwischen Datenknoten gespeichert. Jeder Knotenpunkt speichert Verweise auf alle anderen Knotenpunkte, mit denen er verbunden ist. Herkömmliche Datenbanken speichern Beziehungsdaten nicht direkt, aber sie können Verbindungen herausfinden, indem sie die Datenstrukturen mit Hilfe von Indizierungen durchsuchen, was teuer und zeitaufwändig ist. Eine grafische Datenbank wie Neo4j vermeidet diesen Overhead und kann komplexe Beziehungen kodieren und abfragen.
Neo4j wird von Neo Technology entwickelt. Es ist in Java und Scala geschrieben und sowohl in einer kostenlosen Community-Version als auch in einer Enterprise-Version erhältlich. Neo4j verwendet seine eigene Abfragesprache namens Cypher, aber Abfragen können auch in anderen Stilen geschrieben werden.
In diesem Lernprogramm lernst du, wie du Neo4j auf einem Ubuntu 22.04 Server installierst und konfigurierst.
Voraussetzungen
- Ein Server mit Ubuntu 22.04 mit mindestens 1 CPU-Kern und 2 GB Speicher. Du musst den Server entsprechend den Anforderungen aufrüsten.
- Ein Nicht-Root-Benutzer mit sudo-Rechten.
- Stelle sicher, dass alles auf dem neuesten Stand ist.
-
$ sudo apt update
- Installiere grundlegende Hilfspakete. Einige von ihnen sind vielleicht schon installiert.
$ sudo apt install wget curl nano software-properties-common dirmngr apt-transport-https gnupg gnupg2 ca-certificates lsb-release ubuntu-keyring unzip -y
Schritt 1 – Neo4j installieren
Der erste Schritt zur Installation von Neo4j ist das Hinzufügen des GPG-Schlüssels.
$ curl -fsSL https://debian.neo4j.com/neotechnology.gpg.key | sudo gpg --dearmor -o /usr/share/keyrings/neo4j.gpg
Füge das Neo4j-Repository zum Quellenverzeichnis deines Systems APT hinzu.
$ echo "deb [signed-by=/usr/share/keyrings/neo4j.gpg] https://debian.neo4j.com stable latest" | sudo tee -a /etc/apt/sources.list.d/neo4j.list
Um das Risiko eines Upgrades auf die nächste Hauptversion zu vermeiden, kannst du im obigen Befehl die gewünschte Haupt- und Nebenversion anstelle von latest angeben.
Der folgende Befehl fügt das Neo4j 5.x Repository hinzu, so dass du nicht auf die 6.x Version upgraden musst, sobald diese erscheint.
$ echo "deb [signed-by=/usr/share/keyrings/neo4j.gpg] https://debian.neo4j.com stable 5" | sudo tee -a /etc/apt/sources.list.d/neo4j.list
Aktualisiere die Liste der System-Repositories.
$ sudo apt update
Liste der für die Installation verfügbaren Neo4j-Versionen.
$ apt list -a neo4j Listing... Done neo4j/stable 1:5.3.0 all neo4j/stable 1:5.2.0 all neo4j/stable 1:5.1.0 all
Installiere Neo4j Community Edition.
$ sudo apt install neo4j
Du kannst eine bestimmte Version mit dem folgenden Befehl installieren.
$ sudo apt install neo4j=1:5.3.0
Beachte, dass die Version in Übereinstimmung mit den Debian-Richtlinien zur Versionskontrolle eine Epochenkomponente (1:) enthält.
Neo4j installiert automatisch die erforderliche JDK-Version mit.
Aktiviere den Neo4j-Dienst.
$ sudo systemctl enable neo4j
Starte den Neo4j-Dienst.
$ sudo systemctl start neo4j
Überprüfe den Status des Neo4j-Dienstes.
$ sudo systemctl status neo4j
? neo4j.service - Neo4j Graph Database
Loaded: loaded (/lib/systemd/system/neo4j.service; enabled; vendor preset: enabled)
Active: active (running) since Sat 2023-01-21 20:50:52 UTC; 33s ago
Main PID: 5241 (java)
Tasks: 72 (limit: 1030)
Memory: 399.3M
CPU: 20.350s
CGroup: /system.slice/neo4j.service
Schritt 2 – Verbindung testen
Neo4j verwendet die Cypher Shell für die Arbeit mit Daten.
Verbinde dich mit der Cypher Shell.
$ cypher-shell
Du wirst zur Eingabe eines Benutzernamens und eines Passworts aufgefordert. Der Standard-Benutzername und das Standard-Passwort sind neo4j. Du wirst aufgefordert, ein neues Passwort zu wählen.
username: neo4j password: Password change required new password: confirm password: Connected to Neo4j using Bolt protocol version 5.0 at neo4j://localhost:7687 as user neo4j. Type :help for a list of available commands or :exit to exit the shell. Note that Cypher queries must end with a semicolon. neo4j@neo4j>
Dies bestätigt die erfolgreiche Verbindung zum Neo4j DBMS.
Gib :exit ein, um die Shell zu verlassen.
neo4j@neo4j> :exit Bye!
Schritt 3 – Neo4j für den Fernzugriff konfigurieren
Für Produktionsumgebungen musst du Neo4j möglicherweise bestätigen, dass es Verbindungen von entfernten Hosts akzeptiert. In der Standardeinstellung akzeptiert Neo4j nur Verbindungen von localhost.
Wir können Neo4j so konfigurieren, dass es Verbindungen von entfernten Hosts akzeptiert, indem wir seine Konfigurationsdatei bearbeiten. Neo4j speichert seine Einstellungen in der Datei /etc/neo4j/neo4j.conf. Öffne sie zum Bearbeiten.
$ sudo nano /etc/neo4j/neo4j.conf
Finde die auskommentierte Zeile #dbms.default_listen_address=0.0.0.0 und entferne das führende Rautezeichen.
. . . #***************************************************************** # Network connector configuration #***************************************************************** # With default configuration Neo4j only accepts local connections. # To accept non-local connections, uncomment this line: server.default_listen_address=0.0.0.0 . . .
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Standardmäßig bindet der Wert 0.0.0.0 Neo4j an alle verfügbaren IPv4-Schnittstellen auf deinem System, einschließlich localhost. Wenn du Neo4j auf eine bestimmte IP-Adresse beschränken möchtest, z. B. auf eine private Netzwerk-IP, gib hier die IP-Adresse an, die der privaten Netzwerkschnittstelle deines Servers zugewiesen ist.
Du kannst Neo4j auch für die Verwendung von IPv6-Schnittstellen konfigurieren. Wie bei IPv4 kannst du den Wert default_listen_address auf eine bestimmte IPv6-Adresse setzen, die du für die Kommunikation mit Neo4j verwenden wirst. Wenn du möchtest, dass Neo4j nur die lokale IPv6-Adresse deines Servers verwendet, gib ::1 an, was in IPv6-Notation localhost entspricht.
Wenn du Neo4j mit einer IPv6-Adresse konfigurierst, kannst du dich mit der cypher-shell nicht direkt über die IPv6-Adresse verbinden. Stattdessen musst du entweder einen DNS-Namen konfigurieren, der zu der IPv6-Adresse aufgelöst wird, oder einen Eintrag in der /etc/hosts Datei des entfernten Systems hinzufügen, der die Adresse auf einen Namen abbildet. Dann kannst du den DNS-Namen oder den Namen in der Hosts-Datei verwenden, um dich mit Neo4j über IPv6 von deinem entfernten System aus zu verbinden.
Für einen Neo4j-Server mit einer IPv6-Adresse wie 2001:db8::1 müsste das entfernte System, das die Verbindung herstellt, einen /etc/hosts -Eintrag haben (siehe unten).
2001:db8::1 your_hostname
Du kannst dich dann vom entfernten System aus mit dem Server verbinden, indem du den Namen verwendest, den du wie unten gezeigt angegeben hast.
$ cypher-shell -a 'neo4j://your_hostname:7687'
Wenn du Neo4j so einschränkst, dass es die IPv6-Localhost-Adresse ::1 verwendet, kannst du dich lokal auf dem Neo4j-Server selbst mit dem vorkonfigurierten ip6-localhost-Namen aus deiner /etc/hosts -Datei verbinden (siehe unten).
$ cypher-shell -a 'neo4j://ip6-localhost:7687'
Sobald du cypher-shell mit der Verbindungs-URI aufrufst, wirst du wie gewohnt nach deinem Benutzernamen und Passwort gefragt.
Schritt 4 – Firewall-Zugang konfigurieren (UFW)
Sobald du die Remote-Verbindungen aktiviert hast, kannst du die Firewall nutzen, um Neo4j so einzuschränken, dass es nur von vertrauenswürdigen Systemen aus Verbindungen herstellen kann.
Neo4j erstellt zwei Netzwerk-Sockets, einen auf Port 7474 für die eingebaute HTTP-Schnittstelle und das Haupt-Bolt-Protokoll auf Port 7687.
Ubuntu 22.04 verwendet standardmäßig die Uncomplicated Firewall(UFW).
Konfiguriere die Firewall mit folgendem Befehl so, dass ein vertrauenswürdiger Remote-Host über IPv4 auf die Schnittstelle bolt zugreifen kann.
$ sudo ufw allow from 203.0.113.1 to any port 7687 proto tcp
Ersetze die IP-Adresse des vertrauenswürdigen entfernten Systems anstelle des Wertes 203.0.113.1. Ebenso kannst du mit dem folgenden Befehl einen ganzen Netzwerkbereich zulassen.
$ sudo ufw allow from 192.0.2.0/24 to any port 7687 proto tcp
Ersetze das tatsächliche Netzwerk anstelle des 192.0.2.0/24 Wertes.
Um den Zugriff auf einen entfernten Host mit IPv6 zu erlauben, kannst du den folgenden Befehl verwenden.
$ sudo ufw allow from 2001:DB8::1/128 to any port 7687 proto tcp
Ersetze die IPv6-Adresse deines vertrauenswürdigen Systems anstelle des Wertes 2001:DB8::1/128.
Wie bei IPv4 kannst du mit dem folgenden Befehl einen Bereich von IPv6-Adressen zulassen.
$ ufw allow from 192.0.2.0/24 to any port 7687 proto tcp
Ersetze auch hier den Bereich deines vertrauenswürdigen Netzwerks anstelle des hervorgehobenen Netzwerkbereichs 2001:DB8::/32.
Lade die Firewall neu, um die Änderungen zu übernehmen.
$ sudo ufw reload
Überprüfe den Status der Firewall.
$ sudo ufw status Status: active To Action From -- ------ ---- 22/tcp ALLOW Anywhere 22/tcp (v6) ALLOW Anywhere (v6) 7687/tcp ALLOW 203.0.113.1
Schritt 5 – Neo4j verwenden
Stelle mit dem Tool cypher-shell eine Verbindung zu Neo4j her. Du wirst aufgefordert, deinen Benutzernamen und dein Passwort einzugeben.
$ cypher-shell
Wenn du Neo4j für den Fernzugriff konfiguriert hast, dann benutze den folgenden Befehl, um dich mit Neo4j vom entfernten System aus zu verbinden.
$ cypher-shell -a 'neo4j://203.0.113.1:7687'
Dabei ist 203.0.113.1 die IP-Adresse des Neo4j-Servers.
Wenn du IPv6 verwendest, stelle sicher, dass du einen /etc/hosts Eintrag mit dem in Schritt 3 beschriebenen Namen hast. Verbinde dich dann wie folgt mit dem Neo4j-Server.
$ cypher-shell -a 'neo4j://your_hostname:7687'
Vergewissere dich, dass your_hostname auf die IPv6-Adresse deines Neo4j-Servers in der Datei /etc/hosts des entfernten Systems abgebildet ist.
Fügen wir einen Knoten namens Slite und die Namen der Autoren zu Neo4j hinzu. Mit dem folgenden Befehl wird ein Knoten vom Typ Slite mit dem Namen Navjot Singh erstellt.
neo4j@neo4j> CREATE (:Slite {name: 'Navjot Singh'});
Du erhältst die folgende Ausgabe.
0 rows ready to start consuming query after 124 ms, results consumed after another 0 ms Added 1 nodes, Set 1 properties, Added 1 labels
Als Nächstes fügen wir weitere Mitarbeiter hinzu und verknüpfen sie über eine Beziehung namens COLLEAGUE. Du kannst Knoten mit beliebig benannten Beziehungen verknüpfen.
Füge drei weitere Angestellte hinzu und verknüpfe sie mit der Beziehung COLLEAGUE.
neo4j@neo4j> CREATE
(:Slite {name: 'Sammy'})-[:COLLEAGUE]->
(:Slite {name: 'Peter Jack'})-[:COLLEAGUE]->
(:Slite {name: 'Chris Rock'});
Du wirst ein ähnliches Ergebnis erhalten.
0 rows ready to start consuming query after 72 ms, results consumed after another 0 ms Added 3 nodes, Created 2 relationships, Set 3 properties, Added 3 labels
Lass uns nun einige Beziehungen erstellen.
Da Peter und Chris in der gleichen Abteilung arbeiten und die gleichen Eigenschaften als Knoten haben, erstellen wir eine Beziehung mit der Namensspalte.
neo4j@neo4j> MATCH (a:Slite),(b:Slite)
WHERE a.name = 'Peter Jack' AND b.name = 'Chris Rock'
CREATE (a)-[r:DEPARTMENT { name: 'Designers' }]->(b)
RETURN type(r), r.name;
+----------------------------+
| type(r) | r.name |
+----------------------------+
| "DEPARTMENT" | "Designers" |
+----------------------------+
1 row
ready to start consuming query after 60 ms, results consumed after another 17 ms
Created 1 relationships, Set 1 properties
Nun erstellen wir eine weitere Beziehung zwischen Sammy und Peter, da sie am selben Projekt arbeiten.
neo4j@neo4j> MATCH (a:Slite), (b:Slite)
WHERE a.name = 'Peter Jack' AND b.name = 'Sammy' CREATE (a)-[r:PROJECT { name: 'Test Project 1' }]->(b) RETURN type(r), r.name;
+------------------------------+
| type(r) | r.name |
+------------------------------+
| "PROJECT" | "Test Project 1" |
+------------------------------+
1 row
ready to start consuming query after 132 ms, results consumed after another 12 ms
Created 1 relationships, Set 1 properties
Lass uns all diese Daten mit der folgenden Abfrage anzeigen.
neo4j@neo4j> MATCH (a)-[r]->(b)
RETURN a.name,r,b.name
ORDER BY r;
+-------------------------------------------------------------------+
| a.name | r | b.name |
+-------------------------------------------------------------------+
| "Sammy" | [:COLLEAGUE] | "Peter Jack" |
| "Peter Jack" | [:COLLEAGUE] | "Chris Rock" |
| "Peter Jack" | [:DEPARTMENT {name: "Designers"}] | "Chris Rock" |
| "Peter Jack" | [:PROJECT {name: "Test Project 1"}] | "Sammy" |
+-------------------------------------------------------------------+
4 rows
ready to start consuming query after 99 ms, results consumed after another 5 ms
Fazit
Damit ist unser Tutorial zur Installation und Konfiguration von Neo4j auf einem Ubuntu 22.04 Server abgeschlossen. Wenn du Fragen hast, schreibe sie unten in die Kommentare.