Nachdem wir dir in unseren Tutorials zu den Themen MySQL Datenbank erstellen und löschen, PostgreSQL 10 auf Ubuntu 16.04 / 14.04 installieren, MongoDB auf Ubuntu installieren, Apache Cassandra auf Ubuntu installieren, Redis auf Ubuntu 16.04 LTS installieren und RethinkDB auf Ubuntu installieren eine unterstützende Anleitung zur Installation und Einrichtung einer Reihe von SQL- und NoSQL-Datenbanken unter Ubuntu bereitgestellt haben und sich unsere beiden Tutorials zu den Themen InfluxDB unter Ubuntu 16.04/18.04 installieren und einrichten sowie Neo4j unter Ubuntu 16.04/18.04 installieren und einrichten zwei weiteren NoSQL-Datenbank-Plattformen widmen, werde ich nun die Sammlung ergänzen und dir die NoSQL-Datenbank-Plattform ArangoDB vorstellen.
Zu ArangoDB
ArangoDB stellt Nutzern die Möglichkeit bereit, Dokumente im JSON-Format zu speichern und abzurufen. Ein Dokument ist ein Objekt. Innerhalb eines Dokuments befinden sich entweder keine oder eine Menge von Attributen mit Werten. Analog zum Konzept Datenbank werden auch bei ArangoDB solche Werte von Attributen durch Datentypen wie Zeichenketten, Zahlen oder Boolean transportiert. Im Unterschied zum konventionellen Modell einer Datenbank, existieren in ArangoDB nicht nur Werte im Sinne atomarer Typen, sondern auch zusammengesetzter Typen. Ein zusammengesetzter Typ kann ein Array oder ein eingebettetes Dokument sein. Es lassen sich somit pro Dokument verschachtelte Datenstrukturen konstruieren und abbilden.
Mit Hilfe von Connections können Dokumente gruppiert und somit voneinander differenziert werden. Eine Collection enthält entweder keins oder eine Menge von Dokumenten und kann somit als Sammlung von JSON-Objekten eines Clusters genutzt werden. Verglichen mit dem Modell der relationalen Datenbank, kann man eine Collection mit einer Tabelle gleichstellen und Dokumente kämen Zeilen innerhalb solch einer Tabelle nah. Wenn man in einer traditionellen Datenbank Datensätze in einer Tabelle hinzufügen möchte, ist die Voraussetzung hierfür, zuvor Spalten zu definieren. Das Konstrukt Tabelle in einer traditionellen Datenbank setzt sich sozusagen aus Schemen zusammen, die beim Anlegen einer Tabelle implementiert werden. In ArangoDB muss hingegen nicht definiert werden, welche Attribute ein Dokument haben kann. In ein und derselben Sammlung von Dokumenten können unterschiedliche Datenstrukturen herrschen.
Es ist aber nicht nur möglich Dokument-Collections zu erstellen, sondern auch Collections von Kanten, sogenannten Edges-Collections. Dokumente können dann in solch einer Sammlung von Kanten gespeichert werden. Diese Art von Collection enthält dann die beiden speziellen Attribute _from und _to, mit denen sich die Relationen zwischen Objekten – also den Dokumenten – herstellen lassen.
Genau genommen können Collections von Kanten zwischen Dokumenten in Dokument-Collections Zusammenhänge herstellen. Ein Dokument, das sich in einer Kanten-Collection befindet, bildet sozusagen die Schnittstelle zwischen zwei Dokumenten, die sich in Dokument-Collections befinden und bringt diese beiden sozusagen in eine Beziehung zueinander. Diese Relation folgt dem mathematischen Prinzip eines gerichteten, beschrifteten Graphen. Das die Relation definierende Dokument der Edge-Collection ist in diesem Graphen die beschriftete Kante.
Anwendungsszenario
ArangoDB ist ein natives Multi-Modell-Datenbanksystem, das von der triAGENS GmbH entwickelt und im Jahr 2011 released wurde. Es ist als Multi-Modell-Datenbanksystem zu verstehen, da ArangoDB drei wichtige Datenmodelle unterstützt, nämlich das Modell einer Schlüssel/Wert-Datenbank, sowie einer Dokumentendatenbank als auch einer Graph-Datenbank. ArangoDB vereint diese drei Modelle in einem Datenbankkern und einer einheitlichen Abfragesprache AQL (ArangoDB Query Language). Das bedeutet, dass Schlüssel-/Wert-, Dokument- und Graphendaten unter ein und derselben Sprache zusammen gespeichert und abgefragt werden können.
AQL ist SQL sehr ähnlich, obwohl ArangoDB eine NoSQL-Datenbank ist. AQL ist deklarativ und ermöglicht die Kombination verschiedener Zugriffsmuster von Daten in einer einzigen Abfrage.
Mit ArangoDB ist es möglich skalierbare, hocheffiziente Abfragen bei der Arbeit mit Graph-Daten durchzuführen. Als Standard-Speicherformat wird JSON verwendet.
Ich werde ArangoDB dazu nutzen, einen kleinen Ausschnitt einer Folksonomy durch einen Graphen abbildbar zu machen. Eine Folksonomy is gemeinschaftliches Tagging von Inhalten und findet im Internet statt. Flickr ist ein Beispiel für eine Folksonomy. Dort können Bilder von Nutzern mit Schlagwörtern versehen und somit indexiert und wiederauffindbar gemacht werden. Auch in meinem realisierten Anwendungsszenario soll es um eine digitale Foto-Sharing-Plattform gehen, wo Nutzer Bilder verschlagworten. Der Graph soll am Ende visuell transportieren welche Schlagworte von welchen Nutzern zu welchen Inhalten (Bildern/Fotos) vergeben wurden.
ArangoDB installieren
Zu Beginn solltest du sicherstellen, dass dein Server up-to-date ist.
apt-get update -y && apt-get upgrade -y
Dann musst du den Public-Key von der ArangoDB-Site downloaden, um im Anschluss das ArangoDB-Repository einrichten zu können. Führe den folgenden Befehl aus, um den Public-Key herunterzuladen.
wget https://www.arangodb.com/repositories/arangodb3/xUbuntu_16.04/Release.key
Füge den Key dann mittels dem folgenden Kommando hinzu.
apt-key add Release.key
Bei Ubuntu stehen die Repositories in /etc/apt/sources.list. Als nächstes musst du das Repository von ArangoDB zu sources.list hinzufügen und erneut ein Update des Servers durchführen.
apt-add-repository 'deb https://www.arangodb.com/repositories/arangodb3/xUbuntu_16.04/ /'
apt-get update
Die Installation von ArangoDB vollziehst du dann schließlich via dem folgenden Kommando.
apt-get install arangodb3
Nach dem Installationsprozess erscheint ein Widget, in dem du das root-Passwort festlegen kannst.
Überprüfe daraufhin den Status, indem du den untenstehenden Befehl ausführst.
systemctl status arangodb
Das Output sollte dann so aussehen, wobei server-X als Platzhalter für den Namen deines Servers zu interpretieren ist.
● arangodb3.service - LSB: arangodb
Loaded: loaded (/etc/init.d/arangodb3; bad; vendor preset: enabled)
Active: active (running) since Tue 2018-05-29 13:16:39 CEST; 2min 52s ago
Docs: man:systemd-sysv-generator(8)
CGroup: /system.slice/arangodb3.service
├─26207 /usr/sbin/arangod --uid arangodb --gid arangodb --pid-file /var/run/arangodb/arangod.pid --temp.path /var/tmp/arangod --log.foreground-tty false -
└─26208 /usr/sbin/arangod --uid arangodb --gid arangodb --pid-file /var/run/arangodb/arangod.pid --temp.path /var/tmp/arangod --log.foreground-tty false -
May 29 13:16:37 server-X systemd[1]: Starting LSB: arangodb...
May 29 13:16:37 server-X arangodb3[26150]: * Starting arango database server arangod
May 29 13:16:39 server-X arangodb3[26150]: {startup} starting up in daemon mode
May 29 13:16:39 server-X arangodb3[26150]: changed working directory for child process to '/var/tmp'
May 29 13:16:39 server-X arangodb3[26150]: ...done.
May 29 13:16:39 server-X systemd[1]: Started LSB: arangodb.
ArangoDB über die Shell einrichten
Mit dem Kommando arangosh bietet ArangoDB die Möglichkeit via Kommandozeilen-Shell mit der Datenbank zu interagieren. Du kannst mit diesem Client neue Datenbanken, Benutzer, Sammlungen, Dokumente erstellen und alle administrativen Aufgaben managen.
Du kannst diese Befehlszeilenschnittstelle starten, indem du den folgenden Befehl ausführst.
arangosh
Daraufhin wirst du bei erstmaligem Anmelden in der Datenbank nach dem root-Passwort gefragt, dass ich im vorherigen Kapitel bei der Installation erstellt habe. Denn zu dem Zeitpunkt existieren in der Datenbank noch keine Nutzer außer dem root-Nutzer. Nach erfolgreicher Verifizierung des Passworts, solltest du im Terminal das Output sehen, dass dir der Code-Snippet unten vor Augen führt.
_
__ _ _ __ __ _ _ __ __ _ ___ ___| |__
/ _` | '__/ _` | '_ / _` |/ _ / __| '_
| (_| | | | (_| | | | | (_| | (_) __ | | |
__,_|_| __,_|_| |_|__, |___/|___/_| |_|
|___/
arangosh (ArangoDB 3.0.12 [linux] 64bit, using VPack 0.1.30, ICU 54.1, V8 5.0.71.39, OpenSSL 1.0.2g-fips 1 Mar 2016)
Copyright (c) ArangoDB GmbH
Pretty printing values.
Connected to ArangoDB 'http+tcp://127.0.0.1:8529' version: 3.0.12 [server], database: '_system', username: 'root'
Please note that a new minor version '3.3.9' is available
Type 'tutorial' for a tutorial or 'help' to see common examples
Solltest du Hilfe benötigen, kann dich dieser Befehl jederzeit weiter bringen.
db._help()
Datenbanken und Nutzer erstellen, managen und löschen
Im Folgenden werde ich dir Kommandos zeigen, mit denen sich Datenbanken und Nutzer managen lassen. Alles, was sich in den abgebildeten Code-Snippets zwischen zwei Rauten befindet, ist als Platzhalter zu verstehen. Das folgende Kommando liefert die Datenbank zurück, in der man sich gerade befindet.
require("internal").db._name()
Der Befehl unten gibt aus, ob die Datenbank, in der man sich gerade befindet, die _system-Datenbank ist. Rückgabewert ist dann der Boolean-Wert true oder false.
db._isSystem()
Eine Datenbank anlegen kann man mit dem folgenden Kommando.
db._createDatabase(#"name"#)
Der unten eingeblendete Befehl dient dazu, in eine bestimmte Datenbank zu wechseln.
db._useDatabase(#"name"#)
Eine bestimmte Datenbank löschen. Allerdings muss man diesen Befehl aus der _system-Datenbank heraus ausführen. Wenn man sich nämlich während dem Ausführen des Kommandos in der Datenbank befindet, die gelöscht werden soll, wird eine Exception geworfen.
db._dropDatabase(#"name"#)
Auch für die Auflistung der existierenden Datenbanken gibt es ein Kommando, welches sich allerdings ab einer bestimmten Version geändert hat und je nach genutzter Version zu einer Exception führen kann, wenn der Befehl nicht mit dieser kompatibel ist. Vor ArangoDB 3.0, konnte man sich die Datenbanken anzeigen lassen, indem man das unten stehenden Kommando ausführte.
db._listDatabases()
Seit ArangoDB 3.0 lautet das Kommando aber so:
db._databases()
Den Nutzer einer Datenbank anlegen. Hierzu muss man sich in der betreffenden Datenbank befinden. Es ist in ArangoDB nicht möglich, ein und demselben Nutzernamen mehreren Datenbanken zuzuordnen. Der Versuch wird als Duplizierung interpretiert und führt zu einer Exception.
require("org/arangodb/users").save(#"testuser"#, #"password"#)
Die Tatsache, dass ein Nutzer in einer Datenbank angelegt wurde, bedeutet aber nicht, dass dieser Berechtigungen für den Zugriff auf die betreffende Datenbank hat. Zugriffsrechte müssen zunächst gewährt werden. Hierzu würdest du den folgenden Befehl ausführen müssen.
require("org/arangodb/users").grantDatabase(#"testuser"#, #"_system"#)
Du hast die Möglichkeit für einen Nutzer den Zugriff auf eine Datenbank mittels dem unten eingeblendeten Kommando auch wieder aufzuheben.
require("org/arangodb/users").revokeDatabase(#"testuser"#, #"_system"#)
Wenn du einen Nutzer in der Datenbank beibehalten, aber sein Passwort ändern möchtest, dann wird dir dies mit Hilfe des folgenden Befehls möglich sein.
require("org/arangodb/users").update(#"testuser"#, #"new_password"#)
In ArangoDB kannst du dir nicht nur die Liste verfügbarer Datenbanken anzeigen lassen, sondern auch die in einer Datenbank befindlichen Nutzer. Um dies zu tun, müsstest du den folgenden Befehl ausführen.
require("org/arangodb/users").all()
Letztlich kann es immer mal vorkommen, dass du einen Nutzer aus einer Datenbank löschen möchtest. Dies würdest du via dem unten gezeigten Kommando umsetzen.
require("org/arangodb/users").remove(#"testuser"#)
Du kannst die Datenbank jederzeit mit dem unten im Code-Snippet eingeblendeten Befehl verlassen.
exit
Sobald neben dem root-User weitere Nutzer in der Datenbank existieren, ist es möglich sich in Kombination mit dem arangosh-Befehl direkt als solcher- und nicht als root-User, in der Datenbank anzumelden. So würdest du z.B. nach Eingabe des unten präsentierten Kommandos und erfolgreicher Verifizierung des daraufhin auf Anfrage eingegebenen Passworts, per default in der default-Datenbank _system unter dem Nutzer testuser angemeldet werden.
arangosh testuser
Ebenfalls ist es möglich, dass du direkt beim Aufruf der arangosh-Befehlszeilenschnittstelle, explizit eine bestimmte Datenbank antriggerst, in der du dich dann nach der Anmeldung befindest und dir somit das db._useDatabase-Kommando zum Wechsel in die betreffende Datenbank ersparst. Der Code-Snippet unten zeigt, wie das Kommando hierzu aussehen würde.
arangosh --server.database testDatabase
Auch die Kombination beider oben gezeigten Code-Snippets ist beim Aufruf der arangosh-Befehlszeilenschnittstelle möglich.
arangosh --server.database testDatabase testuser
Mit dem unten eingeblendeten Kommando kannst du einer Datenbank eine Collection hinzufügen. Der Befehl enthält nicht die Zuordnung zur betreffenden Datenbank, in der die Collection implementiert werden soll. Denn die Zuordnung zwischen Collection(s) und Datenbank wird dadurch bestimmt, dass man, bevor man die Collection(s) anlegt, in die entsprechende Datenbank via dem im vorherigen Kapitel gezeigten db._useDatabase-Kommando wechseln muss. Der properties-Parameter, sowie der type– als auch der options-Parameter sind optional, müssen also nicht gesetzt werden. Sie sind im unten abgebildeten Code-Snippet daher in eckige Klammern gesetzt. Der properties-Parameter ist ein Objekt mit Attributen, hinter denen Werte stehen. Jeder der verfügbaren Werte enthält einen default-Wert, der automatisch zugewiesen wird, wenn man den properties-Parameter in der Anfrage nicht selbst bestimmt. Auch der type-Parameter wird per default gesetzt. Der default-Wert hierbei ist immer document. Der type-Parameter kann auch lediglich document oder edge sein. Wenn man eine Collection vom Typ Edge anlegen möchte, ohne den type-Parameter zu setzen, müsste der db._create-Befehl db._createEdgeCollection lauten, was ich in einem der folgenden Code-Snippets auch vorführe.
Eine Übersicht zu den Attributen des properties– und des options-Parameters, Erklärungen zu deren Werten, sowie Beispiele zu deren Einbindung in ein Kommando zur Implementierung einer Collection, findest du in der Dokumentation von ArangoDB.
db._create(#"collection-name"# [, #properties#, #type#, #options#])
Im Code-Block unten erkennst du, dass ich beispielhaft die Collection testCollection1 angelegt habe und daraufhin im Output u.a. die Information zum Identifier (siehe: 578657) angezeigt wird. Eine neu implementierte Collection ist immer vom Typ Dokument (siehe: type document). Ich habe zusätzlich die beiden weiteren Collections testCollection2 und testCollection3 implementiert. Diese drei Collections habe ich in der _system-Datenbank erzeugt.
_system> db._create("testCollection")
[ArangoCollection 578657, "testCollection1" (type document, status loaded)]
Das Abrufen einer Collection ist nun entweder über ihren Namen oder den zu ihr gehörenden Identifier möglich, wie in den beiden folgenden Code-Snippets präsentiert.
db._collection(#"collection-name"#)
db._collection(#collection-identifier#)
Der Befehl für das Anlegen einer neuen Edge-Collection, erfolgt analog dem für das Erzeugen einer Collection.
db._createEdgeCollection(#"edge-collection-name"#)
Im unten eingeblendeten Code-Snippet zeige ich, wie ich die Edge-Collection namens testEdgeCollectionA in der _system-Datenbank implementiere. Am Output des Befehls erkennst du, dass – wie im Fall der Erzeugung einer Collection – auch hier u.a. die Information zum Identifier (Identifier =585224) vorliegt. Anders als im Fall einer Collection, ist bei einer neu angelegten Edge-Collection der Typ kein Dokument, sondern eine Kante (siehe: type edge).
_system> db._createEdgeCollection("testEdgeCollectionA")
[ArangoCollection 585224, "testEdgeCollectionA" (type edge, status loaded)]
Alle Collections einer Datenbank kannst du dir via dem folgenden Befehl anzeigen lassen. Das Output hängt dann davon ab, in welcher Datenbank du dich während der Anfrage befindest.
db._collections()
Auf Basis der bisher in diesem Tutorial gezeigten Implementierungen, sähe das Output für die db._collections()-Anfrage – ausgehend aus der _system-Datenbank – folglich so aus, wie im Code-Block unten vorgeführt. Hier erkennst du, dass dort nun – neben den per default in der Datenbank existierenden Collections – die Collections testCollection1, testCollection2 und testCollection3, sowie die Edge-Collection testEdgeCollectionA verfügbar sind.
_system> db._collections()
[
[ArangoCollection 585224, "testEdgeCollectionA" (type edge, status loaded)],
[ArangoCollection 578706, "testCollection3" (type document, status loaded)],
[ArangoCollection 578704, "testCollection2" (type document, status loaded)],
[ArangoCollection 578657, "testCollection1" (type document, status loaded)],
[ArangoCollection 184143, "_fishbowl" (type document, status loaded)],
[ArangoCollection 50, "_statistics15" (type document, status loaded)],
[ArangoCollection 7, "_users" (type document, status loaded)],
[ArangoCollection 40, "_statisticsRaw" (type document, status loaded)],
[ArangoCollection 55, "_frontend" (type document, status loaded)],
[ArangoCollection 22, "_modules" (type document, status loaded)],
[ArangoCollection 45, "_statistics" (type document, status loaded)],
[ArangoCollection 59, "_jobs" (type document, status loaded)],
[ArangoCollection 57, "_queues" (type document, status loaded)],
[ArangoCollection 38, "_aqlfunctions" (type document, status unloaded)],
[ArangoCollection 61, "_apps" (type document, status loaded)],
[ArangoCollection 2, "_graphs" (type document, status loaded)],
[ArangoCollection 25, "_routing" (type document, status loaded)]
]
Würde man denselben Befehl in der im vorherigen Kapitel angelegten testDatabase-Datenbank ausführen, wären dem Output lediglich die per default integrierten Collections zu entnehmen.
testDatabase> db._collections()
[
[ArangoCollection 185255, "_apps" (type document, status loaded)],
[ArangoCollection 185253, "_jobs" (type document, status loaded)],
[ArangoCollection 185251, "_queues" (type document, status loaded)],
[ArangoCollection 185249, "_frontend" (type document, status loaded)],
[ArangoCollection 185230, "_graphs" (type document, status loaded)],
[ArangoCollection 185232, "_modules" (type document, status loaded)],
[ArangoCollection 185247, "_aqlfunctions" (type document, status loaded)],
[ArangoCollection 185234, "_routing" (type document, status loaded)]
]
Die Ausführung des folgenden Befehls sorgt dafür, dass eine Collection inklusive aller ihrer Indizes und Daten gelöscht wird.
db._drop(#"collection-name"#)
Analog dazu würde der Befehl für das Löschen einer Kanten-Collection so aussehen:
db._drop(#"edge-collection-name"#)
Jedes Dokument in einer Collection verfügt über einen eindeutig identifizierbaren Primärschlüssel. Der Primärschlüssel wird als String im Attribut _key gespeichert. Sobald ein Dokument erstellt wird, wird diesem automatisiert ein _key-Wert zugewiesen, wenn dieser nicht durch den Nutzer festgelegt wurde. Einmal erzeugt, ist der _key-Wert per default Eigenschaft einer Collection unveränderlich, wenn man nicht vorab beim Erstellen der Collection, im properties-Parameter das Attribut keyOptions entsprechend definiert hat, sodass das default-Verhalten für keyOptions nicht greift. Hierzu verweise ich erneut auf die Dokumentation von ArangoDB hin. Ebenfalls eindeutig ist der Alias eines Dokuments, der als String im Attribut _id gespeichert wird. Dieser String setzt sich aus dem Namen der Collection und dem Wert des _key-Attributs zusammen, wobei beide durch ein / voneinander separiert sind.
Schließlich verfügt jedes Dokument über ein _rev-Attribut, das Aufschluss über die Revision des Dokuments gibt. Auch der Wert dieses Attributs wird als Datentyp String gespeichert. Das _rev-Attribut wird von ArangoDB automatisiert gesetzt und geupdated. In ArangoDB ist es möglich, dass mehrere Revisionen ein und desselben Dokuments existieren. Dies wiederum führt dazu, dass mit Hilfe des _rev-Attributs via einer Anfrage an die Datenbank, Dokumente geupdated, ersetzt oder gelöscht werden können. Einer Collection ein Dokument hinzufügen kannst du, indem du im Terminal ein Kommando ausführst, dass der Syntax im unten präsentierten Code-Snippet entspricht. Die geschweiften {}-Klammern stehen für das Dokument. Wie bereits erwähnt ist ein Dokument in ArangoDB ein JSON-Objekt. Mit eckigen []-Klammer hervorgehoben ist hierbei, dass das _key-Attribut optional ist. Wenn du versuchst das _id-Attribut und/oder das _rev-Attribut in der Anfrage zu definieren, erscheint keine Fehlermeldung, aber die Definitionen für diese beiden Attribute werden dann beim Erzeugen des Dokuments trotzdem überschrieben, da sie immer automatisiert von der Datenbank generiert werden.
db.#collection-name#.save({[_key:#"key-name"#], #"attribute1"#:#"value1"#, #attribute2#:#"value2"# ...})
Der folgende Code-Snippet demonstriert wie die Syntax aussieht, wenn du ein Dokument in eine Edge-Collection einbindest. Hier spielen dann u.a. die mit _from und _to gelabelten Attribute eine Rolle. Dort wird jeweils das _id-Attribut der Dokumente angetriggert, zwischen denen die Relation hergestellt werden soll. Zusätzlich kann eine Reihe von Attributen definiert werden, mit deren Hilfe schließlich spezifiziert werden kann, um was für eine Art von Relation es sich konkreter handelt. Damit können auch jegliche Arten von Informationen gespeichert werden, die die Kante zwischen den zwei Dokumenten beschreibt. Später, wenn man den Graph zu einer Edge-Collection erstellt, kann man eines der angelegten Attribute auswählen, um es als Kantenbeschriftung im Graph zu setzen.
db.#collection-name#.save({"_from":#"_id1"#, "_to":#"_id2"#, #"attribute1"#:#"value1"#, #"attribute2"#:#"value2"# ...})
Ich werde nun beginnen das zu Beginn des Tutorials erwähnte Anwendungsszenario in ArangoDB zu implementieren. Hierzu lege ich zunächst eine neue Datenbank namens folksonomy an
_system> db._createDatabase("folksonomy")
und weise dem Nutzer testuser Rechte an dieser Datenbank zu.
_system> require("org/arangodb/users").grantDatabase("testuser", "folksonomy")
Um die Folksonomy einer Foto-Sharing-Plattform in ArangoDB als Graph umzusetzen, werde ich zwei Collections anlegen. In der Collection namens member werden die Nutzer der Plattform jeweils als Dokument angelegt und in einer weiteren Collection namens picture, werden die Fotos der Plattform jeweils als Dokument erzeugt. Es ist zudem eine Edge-Collection namens interaction notwendig. In dieser werden die Relationen zwischen Nutzern und den Fotos hergestellt.
Bevor ich mit der Implementierung beginne, wechsle ich mittels dem unten eingeblendeten Kommando in die folksonomy-Datenbank
_system> db._useDatabase("folksonomy")
und lege dort die member-Collection an.
folksonomy> db._create("member")
[ArangoCollection 125364, "member" (type document, status loaded)]
Den folgenden Code-Snippets entnimmst du die Kommandos, mit denen ich jeweils ein Dokument in der member-Collection gespeichert habe. Das dazugehörige Output in {}-Klammern ist das betreffende Dokument.
folksonomy> db.member.save({_key:"peter", "name":"Peter"})
{
"_id" : "member/peter",
"_key" : "peter",
"_rev" : "125394"
}
folksonomy> db.member.save({_key:"mia", "name":"Mia"})
{
"_id" : "member/mia",
"_key" : "mia",
"_rev" : "125416"
}
folksonomy> db.member.save({_key:"hanna", "name":"Hanna"})
{
"_id" : "member/hanna",
"_key" : "hanna",
"_rev" : "125438"
}
folksonomy> db.member.save({_key:"michael", "name":"Michael"})
{
"_id" : "member/michael",
"_key" : "michael",
"_rev" : "125460"
}
Du könntest dir nun eine bestimmte Menge an Dokumenten der member-Collection – limitiert auf die Anzahl von drei Stück – als Elemente eines Array ausgeben lassen, indem du ein solches Kommando ausführst.
db.#collection-name#.all().limit(#number#).toArray()
Das Output enthält entsprechend einen Array der Collection member, in dem drei Dokumente enthalten sind.
folksonomy> db.member.all().limit(3).toArray()
[
{
"_key" : "peter",
"_id" : "member/peter",
"_rev" : "125394",
"name" : "Peter"
},
{
"_key" : "michael",
"_id" : "member/michael",
"_rev" : "125460",
"name" : "Michael"
},
{
"_key" : "hanna",
"_id" : "member/hanna",
"_rev" : "125438",
"name" : "Hanna"
}
]
Es gibt eine Reihe weiterer Anfragen und Möglichkeiten diese zu modellieren. Eine konkrete und umfangreiche Vorstellung dieser findest du in der Dokumentation von ArangoDB.
Daraufhin lege ich die Collection picture an
folksonomy> db._create("picture")
[ArangoCollection 125533, "picture" (type document, status loaded)]
und binde mittels den folgenden Kommandos drei Dokumente in diese ein.
folksonomy> db.picture.save({_key:"pic1", "description":"joining the sun and the sea"})
{
"_id" : "picture/pic1",
"_key" : "pic1",
"_rev" : "125554"
}
folksonomy> db.picture.save({_key:"pic2", "description":"dancing as art"})
{
"_id" : "picture/pic2",
"_key" : "pic2",
"_rev" : "125576"
}
folksonomy> db.picture.save({_key:"pic3", "description":"celebrating_friendship"})
{
"_id" : "picture/pic3",
"_key" : "pic3",
"_rev" : "125607"
}
Letztlich erzeuge ich die Edge-Collection interaction, in der Verbindungen zwischen Nutzern und Fotos hergestellt werden sollen
folksonomy> db._createEdgeCollection("interaction")
[ArangoCollection 125664, "interaction" (type edge, status loaded)]
und befülle diese mit Dokumenten.
folksonomy> db.interaction.save({"_key":"mia_pic1", "_from":"member/mia", "_to":"picture/pic1", "type":"add_tag", "tag-name":"sun_and_sea"})
{
"_id" : "interaction/mia_pic1",
"_key" : "mia_pic1",
"_rev" : "126344"
}
folksonomy> db.interaction.save({"_key":"peter_pic1", "_from":"member/peter", "_to":"picture/pic1", "type":"add_tag", "tag-name":"holiday"})
{
"_id" : "interaction/peter_pic1",
"_key" : "peter_pic1",
"_rev" : "126819"
}
folksonomy> db.interaction.save({"_key":"hanna_pic1", "_from":"member/hanna", "_to":"picture/pic1", "type":"add_tag", "tag-name":"beach"})
{
"_id" : "interaction/hanna_pic1",
"_key" : "hanna_pic1",
"_rev" : "126841"
}
folksonomy> db.interaction.save({"_key":"michael_pic1", "_from":"member/michael", "_to":"picture/pic1", "type":"add_tag", "tag-name":"summer"})
{
"_id" : "interaction/michael_pic1",
"_key" : "michael_pic1",
"_rev" : "126872"
}
folksonomy> db.interaction.save({"_key":"mia_pic2", "_from":"member/mia", "_to":"picture/pic2", "type":"add_tag", "tag-name":"performance"})
{
"_id" : "interaction/mia_pic2",
"_key" : "mia_pic2",
"_rev" : "126939"
}
folksonomy> db.interaction.save({"_key":"michael_pic2", "_from":"member/michael", "_to":"picture/pic2", "type":"add_tag", "tag-name":"dance"})
{
"_id" : "interaction/michael_pic2",
"_key" : "michael_pic2",
"_rev" : "126976"
}
folksonomy> db.interaction.save({"_key":"mia_pic3", "_from":"member/mia", "_to":"picture/pic3", "type":"add_tag", "tag-name":"friendship"})
{
"_id" : "interaction/mia_pic3",
"_key" : "mia_pic3",
"_rev" : "127016"
}
folksonomy> db.interaction.save({"_key":"peter_pic3", "_from":"member/peter", "_to":"picture/pic3", "type":"add_tag", "tag-name":"friends"})
{
"_id" : "interaction/peter_pic3",
"_key" : "peter_pic3",
"_rev" : "127038"
}
folksonomy> db.interaction.save({"_key":"michael_pic3", "_from":"member/michael", "_to":"picture/pic3", "type":"add_tag", "tag-name":"friendship"})
{
"_id" : "interaction/michael_pic3",
"_key" : "michael_pic3",
"_rev" : "127105"
}
Im Anschluss an die Implementierung des Anwendungsszenarios, möchte ich mir hierzu einen Graph erstellen. Dies werde ich im ArangoDB-Web-Interface machen. Hierzu muss ich jedoch ein paar Einstellungen an der Konfiguration vornehmen, was ich dir im nächsten Kapitel zeige.
ArangoDB Web-Interface einrichten
ArangoDB verfügt über eine integrierte, benutzerfreundliche Weboberfläche, die für alle administrativen Aufgaben genutzt werden kann. Es können hierüber alle Aufgaben erledigt werden, die sich auch über die im vorherigen Kapitel eingeführte arangosh-Befehlszeilenschnittstelle ausführen lassen. Auch lassen sich darüber Datenbanken-Szenarien implementieren, sowie Anfragen auf diese ausführen und ein Monitoring durchführen.
Der Zugriff auf dieses Web-Interface ist per default nicht möglich, sondern erfordert ein paar Anpassungen, die du in den ArangoDB-Konfigurationsdateien vorgenommen müsstest.
Zunächst öffnest du mit dem folgenden Kommando die arangod-Konfigurationsdatei im nano-Editor.
nano /etc/arangodb3/arangod.conf
Dort scrollst du dich dann bis zu der Zeile, die ich im Screenshot farblich hervorgehoben habe und bindest in den im Screenshot gelb markierten Teil die IP-Adresse deines Servers ein. Im Anschluss daran betätigst du die Tastenkombination Strg+O, um das Speichern deiner Anpassung einzuleiten, bestätigst den daraufhin in einem weiß hinterlegten Balken eingeblendeten Namen der Konfigurationsdatei mit der Enter-Taste und verlässt den nano-Editor dann mit der Tastenkombination Strg+X.
Als nächstes öffnest du dann mit dem folgenden Kommando die arangosh-Konfigurationsdatei im nano-Editor.
nano /etc/arangodb3/arangosh.conf
Dort tauscht du die IP für die Kommunikation mit dem Endpunkt ebenfalls mit der IP-Adresse deines Servers aus. Die Stelle, an der du deine IP-Adresse implementieren musst, habe ich auch im folgenden Screenshot farblich kenntlich gemacht. Du verlässt den nano-Editor auf dieselbe Weise, wie ich dir im Beispiel für das Editieren der arangod-Konfigurationsdatei erklärt habe.
Um die Anpassungen in den beiden Konfigurationsdateien zu aktivieren, startest du den Service, indem du den folgenden Befehl im Terminal ausführst.
systemctl restart arangodb3
Getting started mit ArangoDB Web-Interface
Nachdem du – wie im vorherigen Kapitel gezeigt – das Web-Interface von ArangoDB konfiguriert hast, sollte es dir möglich sein, dieses via Aufruf der URL http://localhost:8529 in deinem Browser zu erreichen. Hierbei müsstest du dann localhost mit der IP-Adresse deines Servers austauschen. Wenn du neben dem root-User keine weiteren Nutzer in der Datenbank angelegt hast, ist es dir möglich, dich zunächst über den root-Nutzer im Web-Interface einzuloggen. Das Passwort entspräche dann dem Passwort, mit dem du dich auch bei der Nutzung der Befehlszeilenschnittstelle nach Eingabe des arangosh-Kommandos anmeldest und das du bei der Installation von ArangoDB als root-Passwort festgelegt hast. Andernfalls kannst du dich unter jedem x-beliebigen User anmelden, der in der Datenbank existiert. In meinem Beispiel werde ich mich unter dem Nutzer testuser einloggen. Nach erfolgreicher Authentifizierung durch Nutzername und Passwort kannst du, wie im Screenshot unten präsentiert, in der DropDown-Liste die für den betreffenden Nutzer verfügbaren Datenbanken einsehen und eine bestimmte wählen. In dieser DropDown-Liste sind quasi nur die Datenbanken gelistet, für die dem Nutzer Rechte zugeteilt worden sind.
Angemeldet in der _system-Datenbank kannst du im DASHBOARD-Menüpunkt die Prozesse der Datenbank grafisch aufbereitet einsehen.
Im USERS-Menüpunkt findest du eine Übersicht der angelegten Nutzer, wie du im Screenshot unten erkennst. Mit Klick auf eines der User-Items hast du die Möglichkeit, diesen zu löschen oder das Passwort zu ändern.
Zudem kannst du den Add User-Button nutzen, um einen neuen Nutzer anzulegen. Hierbei wird dann ein Interface eingeblendet, in dem du die notwendigen Informationen zum neuen User eintragen kannst.
Einen Überblick über alle Datenbanken bietet der DATABASES-Menüpunkt. Dort befindet sich in jedem Item oben rechts ein Zahnrad-Icon, mit dessen Betätigung du das Editieren des Items einleiten kannst. Das Editieren beschränkt sich hierbei dann aber auf das Löschen des betreffenden Items.
Wie im Fall der User hast du auch bei den Datenbanken die Möglichkeit via dem Button Add Database eine neue Datenbank zu erstellen. Im hierfür eingeblendeten Interface kannst du dann den Namen der Datenbank sowie den Nutzer bestimmen.
Der SUPPORT-Menüpunkt stellt dir eine Reihe von nützlichen Links zur Verfügung, mit denen du dir weiterführende Informationen zu ArangoDB und der Datenbanksprache AQL beschaffen kannst.
Für die Erstellung des Graphen zum Anwendungsszenario, das ich in die folksonomy-Datenbank implementiert habe, wechsle ich in die folksonomy-Datenbank. Dies tue ich, indem ich den switch-Icon-Button betätige, der sich in der Mitte von insgesamt drei Icon-Buttons ganz oben rechts in der ArangoDB-Web-Anwendung befindet. Nach dem Wechsel steht dort links neben dem switch-Icon-Button nicht mehr DB: _SYSTEM, sondern DB: FOLKSONOMY.
Unter dem COLLECTIONS-Menüpunkt findet man alle in der betreffenden Datenbank existieren Collections. Via dem Add Collection-Button kann man jederzeit eine neue Collection hinzufügen. Wie im Screenshot unten abgebildet, befinden sich dort nun nach meinen Implementierungen die Edge-Collection interaction, die Dokument-Collection member und die Dokument-Collection picture.
Wenn man nun auf ein Collection-Item klicken würde, würde man eine Übersicht aller darin befindlichen Dokumente erhalten und könnte den Inhalt sowohl der Collection als auch der Elemente der Collection (Dokumente) editieren. Ich dokumentiere dies kurz mittels Screenshots am Beispiel der Edge-Collection interaction. Nachdem ich diese Collection angeklickt habe, werden mir alle darin befindlichen Dokumente gelistet. Via dem (+)-Button kann ich weitere Dokumente zu dieser Collection hinzufügen oder gar Dokumente löschen, indem ich den jeweils hinter dem Dokument stehenden (–)-Button betätige.
Würde ich den (+)-Button betätigen, würde ein Interface eingeblendet, in das ich das _from-, sowie das _to-Attribut festlegen, sowie das _key-Attribut definieren kann.
Möchte ich ein bereits bestehendes oder ein gerade neu angelegtes Dokument um Attribute erweitern, klicke ich auf das betreffende Dokument. Wie du dem Screenshot unten entnimmst, ist es möglich via Klick auf den zur linken Seite befindlichen Button, Attribute anzuknüpfen, neu zu implementieren, zu duplizieren oder zu löschen.
Der QUERIES-Menüpunkt macht es über den eingebundenen Editor möglich- mittels AQL-konformen-Anfragen, Datenbankinhalte wiederzugeben, wie im folgenden Screenshot abgebildet. Für AQL-Anfragen verweise ich auf die online verfügbare
AQL-Dokumentation von ArangoDB.
Nun möchte ich den Graphen zu meinem implementierten Anwendungsszenario erstellen. Hierzu wechsle ich im Menü in den Punkt GRAPHS. Nachdem ich den Add Graph-Button betätigt habe, wird ein Interface eingeblendet, in dem ich im Create Graph-Tab die Formalitäten des Graphen sowie die Zusammenhänge der Collections im Graphen bestimmen kann. Wie dies für den Graphen zu den beiden Dokument-Collections member und picture sowie der Edge-Collection interaction aussieht, zeige ich dir im Screenshot unten im Tab. Im Example Graphs-Tab hast du die Möglichkeit, dir von der ArangoDB Web-Anwendung zur Verfügung gestellte Beispielgraphen generieren zu lassen, um so ein Gefühl für die Beschaffenheit von Graphen und dem Zusammenhang, der darin in Relationen stehenden Dokumente zu bekommen.
Nach Betätigung des Create-Button ist der Graph als abrufbares Item im GRAPHS-Menüpunkt verfügbar.
Via Klick auf das betreffende Graph-Item gelangst du in die Maske, in der du dir den Graph ansehen und diesen editieren kannst, wie dir der Screenshot unten verbildlicht.
Fazit
Es hat mir Spaß gemacht, dich durch die Installation und die ersten Schritte in der Anwendung von ArangoDB zu leiten, die du bei Interesse mit Hilfe der online verfügbaren Dokumentation von ArangoDB vertiefen kannst. Ich wünsche dir gutes Gelingen bei der Umsetzung deiner Ideen mit ArangoDB.