Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Zugreifen auf Grafikdaten in Amazon Neptune
Sie können mit einem Amazon Neptune Neptune-DB-Cluster interagieren, nachdem Sie eine Verbindung hergestellt haben. Dies beinhaltet das Laden von Daten, das Ausführen von Abfragen und das Ausführen anderer Operationen. Die meisten Benutzer nutzen die `awscurl` Befehlszeilentools `curl` oder, um effektiv mit dem Neptune-DB-Cluster zu kommunizieren. Mit diesen Tools können Sie Anfragen senden, Daten laden und Ergebnisse aus der Graphdatenbank abrufen, was eine nahtlose Datenverwaltung und Abfragefunktionen ermöglicht.
## Einrichten von `curl` für die Kommunikation mit Ihrem Neptune-Endpunkt
Wie in vielen Beispielen in dieser Dokumentation gezeigt, ist das Befehlszeilen-Tool [curl](https://curl.haxx.se/) für die Kommunikation mit Ihrem Neptune-Endpunkt nützlich. Weitere Informationen zum Tool finden Sie auf der [curl-Hauptseite](https://curl.haxx.se/docs/manpage.html) und im Buch *[Everything curl](https://ec.haxx.se/)*.
Wenn Sie (wie von uns empfohlen und für Neptune in den meisten Regionen erforderlich) eine Verbindung über HTTPS herstellen, benötigt `curl` Zugriff auf entsprechende Zertifikate. Anweisungen, wie diese Zertifikate angefordert und ordnungsgemäß als CA-Speicher konfiguriert werden, der von `curl` genutzt werden kann, finden Sie unter [Verzierung des SSL-Zertifikats](https://curl.haxx.se/docs/sslcerts.html) in der `curl`-Dokumentation.
Sie können den Speicherort des CA-Zertifikatspeichers anschließend mittels der `CURL_CA_BUNDLE`-Umgebungsvariable speichern. Unter Windows sucht `curl` automatisch in einer Datei mit dem Namen `curl-ca-bundle.crt` danach. Es sucht zunächst in demselben Verzeichnis wie `curl.exe` und anschließend an anderer Stelle im Pfad. Weitere Informationen finden Sie unter [SSL Certificate Verification](https://curl.haxx.se/docs/sslcerts.html).
Solange `curl` die entsprechenden Zertifikate finden kann, werden HTTPS-Verbindungen wie HTTP-Verbindungen behandelt, ohne dass zusätzliche Parameter angegeben werden müssen. Die Beispiele in dieser Dokumentation basieren auf diesem Szenario.
## Verwenden einer Abfragesprache für den Zugriff auf Diagrammdaten in Ihrem Neptune-DB-Cluster
Wenn Sie eine Verbindung hergestellt haben, können Sie die Abfragesprachen Gremlin und openCypher verwenden, um ein Eigenschaftsdiagramm zu erstellen und abzufragen, oder die Abfragesprache SPARQL, um ein Diagramm mit RDF-Daten zu erstellen und abzufragen.
**Von Neptune unterstützte Diagrammabfragesprachen**
+ [Gremlin](access-graph-gremlin.md) ist eine Diagrammtraversierungssprache für Eigenschaftsdiagramme. Eine Abfrage in Gremlin ist eine Transversale, die aus verschiedenen Schritten besteht. Jeder Schritt folgt einem Edge zu einem Knoten. Weitere Informationen finden Sie in der Gremlin-Dokumentation TinkerPop bei [Apache](https://tinkerpop.apache.org/docs/current/reference/).
Die Neptune-Implementierung von Gremlin weist einige Unterschiede zu anderen Implementierungen auf, besonders, wenn Sie Gremlin-Groovy verwenden (Gremlin-Abfragen als serialisierter Text). Weitere Informationen finden Sie unter [Einhaltung der Gremlin-Standards in Amazon Neptune](access-graph-gremlin-differences.md).
+ [openCypher](access-graph-opencypher.md) [ist eine deklarative Abfragesprache für Eigenschaftsdiagramme. Ursprünglich von Neo4j entwickelt, wurde sie 2015 als Open-Source-Software veröffentlicht und ist unter einer Apache 2-Open-Source-Lizenz für das openCypher](http://www.opencypher.org/)-Projekt verfügbar. Die Syntax ist in der [Cypher Query Language Reference, Version 9](https://s3.amazonaws.com/artifacts.opencypher.org/openCypher9.pdf) dokumentiert.
+ [SPARQL](access-graph-sparql.md) ist eine deklarative Abfragesprache für [RDF](https://www.w3.org/2001/sw/wiki/RDF)-Daten, basierend auf dem durch das World Wide Web Consortium (W3C) standardisierten Diagrammmusterabgleich. Eine Beschreibung der Sprache finden Sie in [SPARQL 1.1 Übersicht](https://www.w3.org/TR/sparql11-overview/) and in der Spezifikation [SPARQL 1.1 Abfragesprache](https://www.w3.org/TR/sparql11-query/).
**Anmerkung**
Sie können mit Gremlin oder openCypher auf Eigenschaftsdiagrammdaten in Neptune zugreifen, nicht mit SPARQL. Sie können nur mit SPARQL auf RDF-Daten zugreifen, nicht mit Gremlin oder openCypher.
# Verwenden von Gremlin für den Zugriff auf Grafikdaten in Amazon Neptune
Du kannst die Gremlin Console verwenden, um mit Graphen und Abfragen in einer REPL-Umgebung (Loop) zu experimentieren TinkerPop . read-eval-print
Das folgende Tutorial führt Sie durch die Verwendung der Gremlin-Konsole und zeigt, wie Sie Eckpunkte, Kanten, Eigenschaften und mehr zu Graph-Diagrammen hinzufügen. Außerdem wird auch auf einige Besonderheiten bei der Neptune-spezifischen Gremlin-Implementierung hingewiesen.
**Anmerkung**
In diesem Beispiel wird davon ausgegangen, dass Sie Folgendes durchgeführt haben:
Sie haben über SSH eine Verbindung mit einer Amazon–EC2-Instance hergestellt.
Sie haben einen Neptune-Cluster wie in [Neptun-Cluster erstellen](get-started-create-cluster.md) beschrieben erstellt.
Sie haben die Gremlin-Konsole wie in [Installieren der Gremlin-Konsole](access-graph-gremlin-console.md) beschrieben installiert.
**Verwenden der Gremlin-Konsole**
1. Wechseln Sie in den Ordner, in dem die Dateien der Gremlin-Konsole extrahiert werden.
```
cd apache-tinkerpop-gremlin-console-3.7.2
```
1. Geben Sie den folgenden Befehl ein, um die Gremlin-Konsole auszuführen.
```
bin/gremlin.sh
```
Die Ausgabe sollte folgendermaßen aussehen:
```
\,,,/
(o o)
-----oOOo-(3)-oOOo-----
plugin activated: tinkerpop.server
plugin activated: tinkerpop.utilities
plugin activated: tinkerpop.tinkergraph
gremlin>
```
Sie sehen nun die `gremlin>`-Eingabeaufforderung. Die nächsten Schritte geben Sie über diese Eingabeaufforderung ein.
1. Geben Sie an der `gremlin>`-Eingabeaufforderung Folgendes ein, um eine Verbindung zur Neptune-DB-Instance herzustellen.
```
:remote connect tinkerpop.server conf/neptune-remote.yaml
```
1. Geben Sie an der `gremlin>`-Eingabeaufforderung Folgendes ein, um in den Remote-Modus zu wechseln. Dadurch werden alle Gremlin-Abfragen an die Remote-Verbindung gesendet.
```
:remote console
```
1. **Fügen Sie einen Eckpunkt mit Bezeichnung und Eigenschaft hinzu.**
```
g.addV('person').property('name', 'justin')
```
Dem Vertex wird eine `string`-ID mit einer GUID zugewiesen. Alle Scheitelpunkte IDs sind Zeichenketten in Neptune.
1. **Fügen Sie einen Eckpunkt mit einer benutzerdefinierter ID hinzu.**
```
g.addV('person').property(id, '1').property('name', 'martin')
```
Die `id`-Eigenschaft wird nicht in Anführungszeichen gesetzt. Es handelt sich um ein Schlüsselwort für die ID des Vertex. Die Vertex-ID ist eine Zeichenfolge mit der Zahl `1`.
Normale Eigenschaftsnamen müssen in Anführungszeichen eingeschlossen werden.
1. **Ändern Sie die Eigenschaft oder fügen Sie eine Eigenschaft hinzu, wenn keine vorhanden ist.**
```
g.V('1').property(single, 'name', 'marko')
```
Hier ändern Sie die `name`-Eigenschaft für den Vertex aus dem vorherigen Schritt. Dadurch werden alle vorhandenen Werte aus der `name`-Eigenschaft entfernt.
Wenn Sie `single` nicht angegeben haben, wird stattdessen der Wert der `name`-Eigenschaft angehängt, sofern dieser Vorgang noch nicht ausgeführt wurde.
1. **Hinzufügen einer Eigenschaft bzw. Anfügen der Eigenschaft, wenn die Eigenschaft bereits über einen Wert verfügt **
```
g.V('1').property('age', 29)
```
Neptune verwendet Set-Kardinalität als Standardaktion.
Dieser Befehl fügt die Eigenschaft `age` mit dem Wert `29` hinzu, ersetzt jedoch keine vorhandenen Werte.
Wenn die `age`-Eigenschaft bereits einen Wert enthält, fügt dieser Befehl der Eigenschaft `29` an. Beispiel: Wenn die `age`-Eigenschaft `27` lautet, ist der neue Wert `[ 27, 29 ]`.
1. **Fügen Sie mehrere Eckpunkte hinzu.**
```
g.addV('person').property(id, '2').property('name', 'vadas').property('age', 27).iterate()
g.addV('software').property(id, '3').property('name', 'lop').property('lang', 'java').iterate()
g.addV('person').property(id, '4').property('name', 'josh').property('age', 32).iterate()
g.addV('software').property(id, '5').property('name', 'ripple').property('lang', 'java').iterate()
g.addV('person').property(id, '6').property('name', 'peter').property('age', 35)
```
Sie können mehrere Anweisungen gleichzeitig an Neptune senden.
Anweisungen können durch Zeilenumbrüche (`'\n'`), Leerzeichen (`' '`), Semikolon (`'; '`) oder nichts (`g.addV(‘person’).iterate()g.V()` ist z. B. gültig) getrennt werden.
**Anmerkung**
Die Gremlin-Konsole sendet bei jedem Zeilenumbruch (`'\n'`) einen separaten Befehl, sodass in diesem Fall jeweils eine separate Transaktion stattfindet. Dieses Beispiel enthält alle Befehle in getrennten Zeilen, um die Lesbarkeit zu verbessern. Entfernen Sie die Zeilenumbruch-Zeichen (`'\n'`), um sie als einen einzelnen Befehl über die Gremlin-Konsole zu senden.
Alle Anweisungen mit Ausnahme der letzten müssen mit einem Beendigungsschritt wie `.next()` oder `.iterate()` enden. Andernfalls werden sie nicht ausgeführt. Die Gremlin-Konsole erfordert keinen Beendigungsschritt. Verwenden Sie `.iterate` immer dann, wenn die Ergebnisse nicht serialisiert werden müssen.
Alle Anweisungen, die zusammen gesendet werden, sind in einer einzigen Transaktion enthalten und sind entweder alle erfolgreich oder schlagen alle fehl.
1. **Fügen Sie Eckpunkte hinzu.**
```
g.V('1').addE('knows').to(__.V('2')).property('weight', 0.5).iterate()
g.addE('knows').from(__.V('1')).to(__.V('4')).property('weight', 1.0)
```
Nachfolgend sind zwei verschiedene Möglichkeiten zum Hinzufügen einer Edge aufgeführt.
1. **Fügen Sie den Rest des Graphs „Modern“ hinzu.**
```
g.V('1').addE('created').to(__.V('3')).property('weight', 0.4).iterate()
g.V('4').addE('created').to(__.V('5')).property('weight', 1.0).iterate()
g.V('4').addE('knows').to(__.V('3')).property('weight', 0.4).iterate()
g.V('6').addE('created').to(__.V('3')).property('weight', 0.2)
```
1. **Löschen Sie einen Eckpunkt.**
```
g.V().has('name', 'justin').drop()
```
Entfernt den Vertex mit der `name`-Eigenschaft gleich `justin`.
**Wichtig**
*Wenn Sie hier aufhören, haben Sie das vollständige Apache TinkerPop Modern-Diagramm. Die Beispiele im [Abschnitt Traversal](https://tinkerpop.apache.org/docs/current/reference/#graph-traversal-steps) der TinkerPop Dokumentation verwenden den Modern-Graphen.*
1. **Führen Sie einen Durchlauf aus.**
```
g.V().hasLabel('person')
```
Gibt alle `person`-Eckpunkte zurück.
1. **Führen Sie einen Durchlauf mit den Werten (valueMap()) aus.**
```
g.V().has('name', 'marko').out('knows').valueMap()
```
Gibt Schlüssel-Wert-Paare für alle Vertices zurück, die `marko` "kennt".
1. **Geben Sie mehrere Bezeichnungen an.**
```
g.addV("Label1::Label2::Label3")
```
Neptune unterstützt mehrere Bezeichnungen für einen Eckpunkt. Sie können mehrere Bezeichnungen angeben, indem Sie diese durch `::` trennen.
In diesem Beispiel wird ein Vertex mit drei verschiedenen Bezeichnungen hinzugefügt.
Der `hasLabel`-Schritt entspricht dem Knoten mit allen drei Bezeichnungen: `hasLabel("Label1")`, `hasLabel("Label2")` und `hasLabel("Label3")`.
Das `::`-Trennzeichen ist dieser Verwendung vorbehalten.
Sie können im `hasLabel`-Schritt nicht mehrere Bezeichnungen angeben. Beispiel: Für `hasLabel("Label1::Label2")` gibt es keine Übereinstimmung.
1. **Geben Sie Uhrzeit/Datum an**.
```
g.V().property(single, 'lastUpdate', datetime('2018-01-01T00:00:00'))
```
Neptune unterstützt kein Java-Datum. Verwenden Sie stattdessen die `datetime()` Funktion. `datetime()`akzeptiert eine ISO8061 -konforme `datetime` Zeichenfolge.
Unterstützt werden die folgenden Formate: `YYYY-MM-DD, YYYY-MM-DDTHH:mm`, `YYYY-MM-DDTHH:mm:SS` und `YYYY-MM-DDTHH:mm:SSZ`.
1. **Löschen Sie Eckpunkte, Eigenschaften oder Edges.**
```
g.V().hasLabel('person').properties('age').drop().iterate()
g.V('1').drop().iterate()
g.V().outE().hasLabel('created').drop()
```
Im Folgenden finden Sie einige "drop"-Beispiele.
**Anmerkung**
Der `.next()`-Schritt funktioniert nicht mit `.drop()`. Verwenden Sie stattdessen `.iterate()`.
1. Wenn Sie fertig sind, geben Sie den folgenden Befehl ein, um die Gremlin-Konsole zu beenden.
```
:exit
```
**Anmerkung**
Verwenden Sie ein Semikolon (`;`) oder ein Zeilenumbruchzeichen (`\n`), um die Anweisungen voneinander abzutrennen.
Jede Traversierung, die der letzten Traversierung vorausgeht, muss zum Ausführen mit `iterate()` enden. Es werden nur die Daten der letzten Traversierung zurückgegeben.
# Verwenden von OpenCypher für den Zugriff auf Grafikdaten in Amazon Neptune
[Informationen zu den ersten Schritten mit OpenCypher finden Sie unter [openCypher](access-graph-opencypher.md) oder verwenden Sie die OpenCypher-Notizbücher im Neptune Graph-Notebook-Repository. GitHub ](https://github.com/aws/graph-notebook/tree/main/src/graph_notebook/notebooks)
# Verwenden von SPARQL für den Zugriff auf Grafikdaten in Amazon Neptune
SPARQL ist eine Abfragesprache für das Resource Description Framework (RDF), ein für das Web entwickelts Datenformat für Diagramme. Amazon Neptune ist mit SPARQL 1.1 kompatibel. Das bedeutet, dass Sie eine Verbindung zu einer Neptune-DB-Instance herstellen und das Diagramm mittels der in der Spezifikation [SPARQL 1.1 Query Language](https://www.w3.org/TR/sparql11-query/) beschriebenen Abfragesprache abfragen können.
Eine Abfrage in SPARQL besteht aus einer `SELECT`-Klausel zur Angabe der Variablen, die zurückgegeben werden sollen, und einer `WHERE`-Klausel, um anzugeben, welche Daten im Diagramm abgeglichen werden sollen. Wenn Sie noch keine Erfahrungen mit SPARQL-Abfragen haben, lesen Sie den Abschnitt [Writing Simple Queries](https://www.w3.org/TR/sparql11-query/#WritingSimpleQueries) in [SPARQL 1.1 Query Language](https://www.w3.org/TR/sparql11-query/).
Der HTTP-Endpunkt für SPARQL-Abfragen an eine Neptune-DB-Instance ist `https://your-neptune-endpoint:port/sparql`.
**So stellen Sie eine Verbindung mit SPARQL her**
1. Sie können den SPARQL-Endpunkt für Ihren Neptune-Cluster aus dem **SparqlEndpoint**Element im Abschnitt **Outputs des Stacks** abrufen. CloudFormation
1. Geben Sie Folgendes ein, um ein SPARQL-**`UPDATE`** über HTTP `POST` und den **curl**-Befehl zu senden.
```
curl -X POST --data-binary 'update=INSERT DATA { . }' https://your-neptune-endpoint:port/sparql
```
Im vorherigen Beispiel wird das folgende Triple in das standardmäßige SPARQL-Diagramm eingefügt: ` `
1. Geben Sie Folgendes ein, um ein SPARQL-**`QUERY`** über HTTP `POST` und den **curl**-Befehl zu senden.
```
curl -X POST --data-binary 'query=select ?s ?p ?o where {?s ?p ?o} limit 10' https://your-neptune-endpoint:port/sparql
```
Das vorherige Beispiel gibt bis zu 10 der Triples (subject-predicate-object) im Diagramm zurück, wenn die `?s ?p ?o` Abfrage mit einem Limit von 10 verwendet wird. Um etwas anderes abzufragen, ersetzen Sie diese durch eine andere SPARQL-Abfrage.
**Anmerkung**
Der Standard-MIME-Typ einer Antwort ist `application/sparql-results+json` für `SELECT`- und `ASK`-Abfragen.
Der Standard-MIME-Typ einer Antwort ist `application/n-quads` für `CONSTRUCT`- und `DESCRIBE`-Abfragen.
Eine Liste der verfügbaren MIME-Typen finden Sie unter [SPARQL HTTP-API](sparql-api-reference.md).