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. # Amazon Neptune Neptune-Hilfsprogramm für GraphQL Das Amazon Neptune Neptune-Hilfsprogramm für [GraphQL](https://graphql.org/) ist ein Open-Source-Befehlszeilentool Node.js, mit dem Sie eine GraphQL-API für eine Neptune-Property-Graph-Datenbank erstellen und verwalten können (es funktioniert noch nicht mit RDF-Daten). Es ist eine Methode ohne Code, einen GraphQL-Resolver für GraphQL-Abfragen zu erstellen, die eine variable Anzahl von Eingabeparametern haben und eine variable Anzahl verschachtelter Felder zurückgeben. Es wurde als Open-Source-Projekt veröffentlicht und befindet sich unter. [https://github.com/aws/amazon-neptune-for-graphql](https://github.com/aws/amazon-neptune-for-graphql) Sie können das Hilfsprogramm mit NPM wie folgt installieren (weitere Informationen finden Sie unter [Installation und Einrichtung](tools-graphql-setup.md)): ``` npm i @aws/neptune-for-graphql -g ``` Das Hilfsprogramm kann das Graphschema eines vorhandenen Neptun-Eigenschaftsgraphen ermitteln, einschließlich Knoten, Edges, Eigenschaften und Edge-Kardinalität. Anschließend generiert es ein GraphQL-Schema mit den Anweisungen, die benötigt werden, um die GraphQL-Typen den Knoten und Edges der Datenbank zuzuordnen, und generiert automatisch Resolver-Code. Der Resolver-Code wurde entwickelt, um die Latenz zu minimieren, indem nur die von der GraphQL-Abfrage angeforderten Daten ausgegeben werden. Sie können auch mit einem vorhandenen GraphQL-Schema und einer leeren Neptune-Datenbank beginnen und das Hilfsprogramm die Anweisungen ableiten lassen, die erforderlich sind, um dieses GraphQL-Schema den Knoten und Edges von Daten zuzuordnen, die in die Datenbank geladen werden sollen. Oder Sie können mit einem GraphQL-Schema und Anweisungen beginnen, die Sie bereits erstellt oder geändert haben. Das Hilfsprogramm ist in der Lage, alle AWS Ressourcen zu erstellen, die es für seine Pipeline benötigt, einschließlich der AWS AppSync API, der IAM-Rollen, der Datenquelle, des Schemas und des Resolvers sowie der AWS Lambda-Funktion, die Neptune abfragt. **Anmerkung** Bei den Befehlszeilenbeispielen wird hier von einer Linux-Konsole ausgegangen. Wenn Sie Windows verwenden, ersetzen Sie die umgekehrten Schrägstriche (‚\$1’) am Ende der Zeilen durch Carets (‚^’). **Topics** + [Installation und Einrichtung des Amazon Neptune Neptune-Dienstprogramms für GraphQL](tools-graphql-setup.md) + [Daten in einer bestehenden Neptune-Datenbank scannen](tools-graphql-scan-existing.md) + [Ausgehend von einem GraphQL-Schema ohne Direktiven](tools-graphql-start-from-schema.md) + [Arbeiten mit Direktiven für ein GraphQL-Schema](tools-graphql-schema-with-directives.md) + [Befehlszeilenargumente für das GraphQL-Hilfsprogramm](tools-graphql-cmd-line-args.md) # Installation und Einrichtung des Amazon Neptune Neptune-Dienstprogramms für GraphQL Wenn Sie das Hilfsprogramm mit einer vorhandenen Neptune-Datenbank verwenden möchten, benötigen Sie es, um eine Verbindung zum Datenbank-Endpunkt herstellen zu können. Standardmäßig ist eine Neptune-Datenbank nur von der VPC aus zugänglich, in der sie sich befindet. Da es sich bei dem Hilfsprogramm um ein Befehlszeilentool von Node.js handelt, muss Node.js (Version 18 oder höher) installiert sein, damit das Hilfsprogramm ausgeführt werden kann. Folgen Sie den [Anweisungen hier](https://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/setting-up-node-on-ec2-instance.html), um Node.js auf einer EC2-Instance in derselben VPC wie Ihre Neptune-Datenbank zu installieren. Die Mindestgröße für die Instance zum Ausführen des Dienstprogramms ist t2.micro. Wählen Sie bei der Erstellung der Instance die Neptune-Datenbank-VPC aus dem Pulldown-Menü **Common Security Groups** aus. Verwenden Sie NPM, um das Hilfsprogramm selbst auf einer EC2-Instance oder Ihrem lokalen Computer zu installieren: ``` npm i @aws/neptune-for-graphql -g ``` Anschließend können Sie den Hilfebefehl des Dienstprogramms ausführen, um zu überprüfen, ob es ordnungsgemäß installiert wurde: ``` neptune-for-graphql --help ``` Möglicherweise möchten Sie das auch [installieren](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html), um Ressourcen zu verwalten. AWS CLI AWS # Daten in einer bestehenden Neptune-Datenbank scannen Unabhängig davon, ob Sie mit GraphQL vertraut sind oder nicht, der folgende Befehl ist der schnellste Weg, eine GraphQL-API zu erstellen. Dies setzt voraus, dass Sie das Neptune-Hilfsprogramm für GraphQL wie im [Installationsabschnitt](tools-graphql-setup.md) beschrieben installiert und konfiguriert haben, sodass es mit dem Endpunkt Ihrer Neptune-Datenbank verbunden ist. ``` neptune-for-graphql \ --input-graphdb-schema-neptune-endpoint (your neptune database endpoint):(port number) \ --create-update-aws-pipeline \ --create-update-aws-pipeline-name (your new GraphQL API name) \ --output-resolver-query-https ``` Das Hilfsprogramm analysiert die Datenbank, um das Schema der darin enthaltenen Knoten, Edges und Eigenschaften zu ermitteln. Basierend auf diesem Schema leitet es ein GraphQL-Schema mit zugehörigen Abfragen und Mutationen ab. Dann erstellt es eine AppSync GraphQL-API und die erforderlichen AWS Ressourcen, um sie zu verwenden. Zu diesen Ressourcen gehören ein Paar IAM-Rollen und eine Lambda-Funktion, die den GraphQL-Resolver-Code enthält. Wenn das Tool fertig ist, finden Sie in der AppSync Konsole eine neue GraphQL-API unter dem Namen, den Sie im Befehl zugewiesen haben. Um es zu testen, verwenden Sie die Option AppSync **Abfragen** im Menü. Wenn Sie denselben Befehl erneut ausführen, nachdem Sie der Datenbank weitere Daten hinzugefügt haben, werden die AppSync API und der Lambda-Code entsprechend aktualisiert. Um alle mit dem Befehl verknüpften Ressourcen freizugeben, führen Sie folgenden Befehl aus: ``` neptune-for-graphql \ --remove-aws-pipeline-name (your new GraphQL API name from above) ``` # Ausgehend von einem GraphQL-Schema ohne Direktiven Sie können mit einer leeren Neptune-Datenbank beginnen und ein GraphQL-Schema ohne Direktiven verwenden, um die Daten zu erstellen und abzufragen. Der folgende Befehl erstellt automatisch AWS -Ressourcen zu diesem Zweck: ``` neptune-for-graphql \ --input-schema-file (your GraphQL schema file) --create-update-aws-pipeline \ --create-update-aws-pipeline-name (name for your new GraphQL API) \ --create-update-aws-pipeline-neptune-endpoint (your Neptune database endpoint):(port number) \ --output-resolver-query-https ``` Die GraphQL-Schemadatei muss die GraphQL-Schematypen enthalten, wie im folgenden TODO-Beispiel gezeigt. Das Hilfsprogramm analysiert Ihr Schema und erstellt eine erweiterte Version, die auf Ihren Typen basiert. Es fügt Abfragen und Mutationen für die in der Graphdatenbank gespeicherten Knoten hinzu. Wenn Ihr Schema verschachtelte Typen enthält, fügt es Beziehungen zwischen den Typen hinzu, die als Edges in der Datenbank gespeichert sind. Das Hilfsprogramm erstellt eine AppSync GraphQL-API und alle erforderlichen AWS Ressourcen. Dazu gehören ein Paar IAM-Rollen und eine Lambda-Funktion, die den GraphQL-Resolver-Code enthält. Wenn der Befehl abgeschlossen ist, können Sie eine neue GraphQL-API mit dem Namen finden, den Sie in der AppSync Konsole angegeben haben. Um es zu testen, verwenden Sie **Queries** im AppSync Menü. Das folgende Beispiel veranschaulicht, wie dies funktioniert: ## Todo-Beispiel, ausgehend von einem GraphQL-Schema ohne Direktiven In diesem Beispiel gehen wir von einem Todo GraphQL-Schema ohne Direktiven aus, das Sie im *???samples???* Verzeichnis finden. Es umfasst diese beiden Typen: ``` type Todo { name: String description: String priority: Int status: String comments: [Comment] } type Comment { content: String } ``` Dieser Befehl verarbeitet das Todo-Schema und einen Endpunkt einer leeren Neptune-Datenbank, um eine GraphQL-API zu erstellen in: AWS AppSync ``` neptune-for-graphql / --input-schema-file ./samples/todo.schema.graphql \ --create-update-aws-pipeline \ --create-update-aws-pipeline-name TodoExample \ --create-update-aws-pipeline-neptune-endpoint (empty Neptune database endpoint):(port number) \ --output-resolver-query-https ``` Das Hilfsprogramm erstellt eine neue Datei im `TodoExample.source.graphql` aufgerufenen Ausgabeordner und die GraphQL-API in AppSync. Das Hilfsprogramm leitet daraus Folgendes ab: + Im Typ Todo wurde es `@relationship` für einen neuen CommentEdge Typ hinzugefügt. Dadurch wird der Resolver angewiesen, Todo mit Comment zu verbinden, indem er eine Graphdatenbank namens Edge verwendet. CommentEdge + Es wurde eine neue Eingabe hinzugefügt, die aufgerufen wurde TodoInput , um die Abfragen und Mutationen zu unterstützen. + Es wurden zwei Abfragen für jeden Typ hinzugefügt (Todo, Comment): eine zum Abrufen eines einzelnen Typs mithilfe eines `id` oder eines der in der Eingabe aufgeführten Typfelder und die andere zum Abrufen mehrerer Werte, die anhand der Eingabe für diesen Typ gefiltert wurden. + Für jeden Typ wurden drei Mutationen hinzugefügt: erstellen, aktualisieren und löschen. Der zu löschende Typ wird mit einer `id` oder der Eingabe für diesen Typ angegeben. Diese Mutationen wirken sich auf die in der Neptun-Datenbank gespeicherten Daten aus. + Es wurden zwei Mutationen für Verbindungen hinzugefügt: Verbinden und Löschen. Sie verwenden als Eingabe die Edge-IDs der von Neptune verwendeten Von- und Zielscheitelpunkte, und die Verbindung sind Edges in der Datenbank. Der Resolver erkennt die Abfragen und Mutationen anhand ihrer Namen, aber Sie können sie wie [unten](tools.md) gezeigt anpassen. Hier ist der Inhalt der `TodoExample.source.graphql`-Datei: ``` type Todo { _id: ID! @id name: String description: String priority: Int status: String comments(filter: CommentInput, options: Options): [Comment] @relationship(type: "CommentEdge", direction: OUT) bestComment: Comment @relationship(type: "CommentEdge", direction: OUT) commentEdge: CommentEdge } type Comment { _id: ID! @id content: String } input Options { limit: Int } input TodoInput { _id: ID @id name: String description: String priority: Int status: String } type CommentEdge { _id: ID! @id } input CommentInput { _id: ID @id content: String } input Options { limit: Int } type Query { getNodeTodo(filter: TodoInput, options: Options): Todo getNodeTodos(filter: TodoInput): [Todo] getNodeComment(filter: CommentInput, options: Options): Comment getNodeComments(filter: CommentInput): [Comment] } type Mutation { createNodeTodo(input: TodoInput!): Todo updateNodeTodo(input: TodoInput!): Todo deleteNodeTodo(_id: ID!): Boolean connectNodeTodoToNodeCommentEdgeCommentEdge(from_id: ID!, to_id: ID!): CommentEdge deleteEdgeCommentEdgeFromTodoToComment(from_id: ID!, to_id: ID!): Boolean createNodeComment(input: CommentInput!): Comment updateNodeComment(input: CommentInput!): Comment deleteNodeComment(_id: ID!): Boolean } schema { query: Query mutation: Mutation } ``` Jetzt können Sie Daten erstellen und abfragen. Hier ist ein Snapshot der AppSync **Query-Konsole**, die zum Testen der neuen GraphQL-API verwendet wurde, die `TodoExampleAPI` in diesem Fall benannt ist. Im mittleren Fenster zeigt Ihnen der Explorer eine Liste von Abfragen und Mutationen, aus der Sie eine Abfrage, die Eingabeparameter und die Rückgabefelder auswählen können. Dieser Screenshot zeigt die Erstellung eines Todo-Knotentyps unter Verwendung der `createNodeTodo`-Mutation: ![\[Screenshot, der zeigt, wie die AppSync Query-Konsole einen Todo-Knoten erstellt\]](http://docs.aws.amazon.com/de_de/neptune/latest/userguide/images/todoCreate.png) Dieser Screenshot zeigt, wie alle Todo-Knoten mithilfe der `getNodeTodos`-Abfrage abgefragt werden: ![\[Screenshot, der zeigt, wie die AppSync Query-Konsole Todo-Knoten abfragt\]](http://docs.aws.amazon.com/de_de/neptune/latest/userguide/images/todoGetTodos.png) Nachdem Sie einen Kommentar mit `createNodeComment` erstellt haben, können Sie die `connectNodeTodoToNodeCommentEdgeCommentEdge`-Mutation verwenden, um sie zu verbinden, indem Sie ihre IDs angeben. Hier ist eine verschachtelte Abfrage zum Abrufen von Todos und ihren angehängten Kommentaren: ![\[Screenshot, der eine verschachtelte Abfrage zum Abrufen von Todos und ihren angehängten Kommentaren in der Query-Konsole zeigt AppSync\]](http://docs.aws.amazon.com/de_de/neptune/latest/userguide/images/todoNestedQuery.png) Wenn Sie Änderungen an der `TodoExample.source.graphql`-Datei vornehmen möchten, wie unter [Arbeiten mit Direktiven](tools-graphql-schema-with-directives.md) beschrieben, können Sie das bearbeitete Schema als Eingabe verwenden und das Hilfsprogramm erneut ausführen. Das Hilfsprogramm ändert dann die GraphQL-API entsprechend. # Arbeiten mit Direktiven für ein GraphQL-Schema Sie können mit einem GraphQL-Schema beginnen, das bereits Direktiven enthält, indem Sie einen Befehl wie den folgenden verwenden: ``` neptune-for-graphql \ --input-schema-file (your GraphQL schema file with directives) \ --create-update-aws-pipeline \ --create-update-aws-pipeline-name (name for your new GraphQL API) \ --create-update-aws-pipeline-neptune-endpoint (empty Neptune database endpoint):(port number) \ --output-resolver-query-https ``` Sie können Direktiven ändern, die das Hilfsprogramm erstellt hat, oder Ihre eigenen Direktiven zu einem GraphQL-Schema hinzufügen. Hier sind einige Möglichkeiten, mit Direktiven zu arbeiten: ## Das Hilfsprogramm so ausführen, dass es keine Mutationen generiert Um zu verhindern, dass das Hilfsprogramm Mutationen in der GraphQL-API generiert, verwenden Sie die `--output-schema-no-mutations`-Option im Befehl `neptune-for-graphql`. ## Die `@alias`-Direktive Die `@alias`-Direktive kann auf GraphQL-Schematypen oder -Felder angewendet werden. Es ordnet verschiedene Namen zwischen der Graphdatenbank und dem GraphQL-Schema zu. Die Syntax lautet wie folgt: ``` @alias(property: (property name)) ``` Im folgenden Beispiel `airport` ist die Graphdatenbankknotenbezeichnung dem GraphQL-Typ `Airport` zugeordnet, und `desc` es ist die Graphknoteneigenschaft, die dem `description`-Feld zugeordnet ist (siehe das Beispiel [Air Routes](tools-graphql.md)): ``` type Airport @alias(property: "airport") { city: String description: String @alias(property: "desc") } ``` Beachten Sie, dass die standardmäßige GraphQL-Formatierung Typnamen in Pascal-Schreibweise und Feldnamen in Kamelschreibweise erfordert. ## Die `@relationship`-Direktive Die `@relationship`-Direktive ordnet verschachtelte GraphQL-Typen den Edges von Graphdatenbanken zu. Die Syntax lautet wie folgt: ``` @relationship(edgeType: (edge name), direction: (IN or OUT)) ``` Hier sehen Sie ein Beispiel für einen Befehl. ``` type Airport @alias(property: "airport") { ... continentContainsIn: Continent @relationship(edgeType: "contains", direction: IN) countryContainsIn: Country @relationship(edgeType: "contains", direction: IN) airportRoutesOut(filter: AirportInput, options: Options): [Airport] @relationship(edgeType: "route", direction: OUT) airportRoutesIn(filter: AirportInput, options: Options): [Airport] @relationship(edgeType: "route", direction: IN) } ``` `@relationship`-Direktiven finden Sie sowohl im [Todo-Beispiel](tools-graphql-start-from-schema.md#tools-graphql-todo-example) als auch im [Air Routes-Beispiel](tools-graphql.md). ## Die Direktiven `@graphQuery` und `@cypher` Sie können openCypher-Abfragen definieren, um einen Feldwert aufzulösen, Abfragen hinzuzufügen oder Mutationen hinzuzufügen. Dadurch wird dem `Airport`-Typ beispielsweise ein neues `outboundRoutesCount`-Feld hinzugefügt, um die ausgehenden Routen zu zählen: ``` type Airport @alias(property: "airport") { ... outboundRoutesCount: Int @graphQuery(statement: "MATCH (this)-[r:route]->(a) RETURN count(r)") } ``` Hier ein Beispiel für neue Abfragen und Mutationen: ``` type Query { getAirportConnection(fromCode: String!, toCode: String!): Airport \ @cypher(statement: \ "MATCH (:airport{code: '$fromCode'})-[:route]->(this:airport)-[:route]->(:airport{code:'$toCode'})") } type Mutation { createAirport(input: AirportInput!): Airport @graphQuery(statement: "CREATE (this:airport {$input}) RETURN this") addRoute(fromAirportCode:String, toAirportCode:String, dist:Int): Route \ @graphQuery(statement: \ "MATCH (from:airport{code:'$fromAirportCode'}), (to:airport{code:'$toAirportCode'}) \ CREATE (from)-[this:route{dist:$dist}]->(to) \ RETURN this") } ``` Beachten Sie, dass, wenn Sie `RETURN` weglassen, der Resolver annimmt, dass das Schlüsselwort `this` der zurückkehrende Bereich ist. Sie können eine Abfrage oder Mutation auch mithilfe einer Gremlin-Abfrage hinzufügen: ``` type Query { getAirportWithGremlin(code:String): Airport \ @graphQuery(statement: "g.V().has('airport', 'code', '$code').elementMap()") # single node getAirportsWithGremlin: [Airport] \ @graphQuery(statement: "g.V().hasLabel('airport').elementMap().fold()") # list of nodes getCountriesCount: Int \ @graphQuery(statement: "g.V().hasLabel('country').count()") # scalar } ``` Derzeit sind Gremlin-Abfragen auf Abfragen beschränkt, die Skalarwerte zurückgeben, oder `elementMap()` für einen einzelnen Knoten oder `elementMap().fold()` für eine Liste von Knoten. ## Die `@id`-Direktive Die `@id`-Direktive identifiziert das Feld, das der `id` Graphdatenbank-Entität zugeordnet ist. Graphdatenbanken wie Amazon Neptune haben immer eine eindeutige `id` für Knoten und Edges, die bei Massenimporten zugewiesen oder automatisch generiert wird. Beispiel: ``` type Airport { _id: ID! @id city: String code: String } ``` ## Reservierte Typ-, Abfrage- und Mutationsnamen Das Hilfsprogramm generiert automatisch Abfragen und Mutationen, um eine funktionierende GraphQL-API zu erstellen. Das Muster dieser Namen wird vom Resolver erkannt und ist reserviert. Hier sind Beispiele für den Typ `Airport` und den Verbindungstyp `Route`: Der Name `Options` ist reserviert. ``` input Options { limit: Int } ``` Die Funktionsparameter `filter` und `options` sind reserviert. ``` type Query { getNodeAirports(filter: AirportInput, options: Options): [Airport] } ``` Das GetNode-Präfix von Abfragenamen ist reserviert, und Präfixe von Mutationsnamen wie `createNode`, `updateNode`, `deleteNode`, `connectNode`, `deleteNode`, `updateEdge` und `deleteEdge` sind reserviert. ``` type Query { getNodeAirport(id: ID, filter: AirportInput): Airport getNodeAirports(filter: AirportInput): [Airport] } type Mutation { createNodeAirport(input: AirportInput!): Airport updateNodeAirport(id: ID!, input: AirportInput!): Airport deleteNodeAirport(id: ID!): Boolean connectNodeAirportToNodeAirportEdgeRout(from: ID!, to: ID!, edge: RouteInput!): Route updateEdgeRouteFromAirportToAirport(from: ID!, to: ID!, edge: RouteInput!): Route deleteEdgeRouteFromAirportToAirport(from: ID!, to: ID!): Boolean } ``` ## Änderungen am GraphQL-Schema anwenden Sie können das GraphQL-Quellschema ändern und das Hilfsprogramm erneut ausführen, um das neueste Schema aus Ihrer Neptune-Datenbank abzurufen. Jedes Mal, wenn das Hilfsprogramm ein neues Schema in der Datenbank entdeckt, generiert es ein neues GraphQL-Schema. Sie können das GraphQL-Quellschema auch manuell bearbeiten und das Hilfsprogramm erneut ausführen, indem Sie das Quellschema als Eingabe anstelle des Neptune-Datenbankendpunkts verwenden. Schließlich können Sie Ihre Änderungen mit diesem JSON-Format in eine Datei einfügen: ``` [ { "type": "(GraphQL type name)", "field": "(GraphQL field name)", "action": "(remove or add)", "value": "(value)" } ] ``` Beispiel: ``` [ { "type": "Airport", "field": "outboundRoutesCountAdd", "action": "add", "value":"outboundRoutesCountAdd: Int @graphQuery(statement: \"MATCH (this)-[r:route]->(a) RETURN count(r)\")" }, { "type": "Mutation", "field": "deleteNodeVersion", "action": "remove", "value": "" }, { "type": "Mutation", "field": "createNodeVersion", "action": "remove", "value": "" } ] ``` Wenn Sie dann das Hilfsprogramm mithilfe des `--input-schema-changes-file`-Parameters im Befehl für diese Datei ausführen, wendet das Hilfsprogramm Ihre Änderungen sofort an. # Befehlszeilenargumente für das GraphQL-Hilfsprogramm + **`--help, -h`** – Gibt den Hilfetext für das GraphQL-Hilfsprogramm an die Konsole zurück.   + **`--input-schema (schema text)`** – Ein GraphQL-Schema, mit oder ohne Direktiven, das als Eingabe verwendet werden soll.   + **`--input-schema-file (file URL)`** – Die URL einer Datei, die ein GraphQL-Schema enthält, das als Eingabe verwendet werden soll.   + **`--input-schema-changes-file (file URL)`** – Die URL einer Datei, die Änderungen enthält, die Sie an einem GraphQL-Schema vornehmen möchten. Wenn Sie das Hilfsprogramm mehrmals für eine Neptune-Datenbank ausführen und auch das GraphQL-Quellschema manuell ändern, indem Sie zum Beispiel eine benutzerdefinierte Abfrage hinzufügen, gehen Ihre manuellen Änderungen verloren. Um dies zu vermeiden, fügen Sie Ihre Änderungen in eine Änderungsdatei ein und übergeben Sie sie mit diesem Argument. Die Datei der Änderungen verwendet das folgenden JSON-Format: ``` [ { "type": "(GraphQL type name)", "field": "(GraphQL field name)", "action": "(remove or add)", "value": "(value)" } ] ``` Weitere Informationen finden Sie unter [Beispiele](tools-graphql-start-from-schema.md#tools-graphql-todo-example).   + **`--input-graphdb-schema (schema text)`** – Anstatt das Hilfsprogramm für eine Neptune-Datenbank auszuführen, können Sie ein Graphdb-Schema in Textform ausdrücken, um es als Eingabe zu verwenden. Ein Graphdb-Schema hat ein JSON-Format wie dieses: ``` { "nodeStructures": [ { "label":"nodelabel1", "properties": [ { "name":"name1", "type":"type1" } ] }, { "label":"nodelabel2", "properties": [ { "name":"name2", "type":"type1" } ] } ], "edgeStructures": [ { "label":"label1", "directions": [ { "from":"nodelabel1", "to":"nodelabel2", "relationship":"ONE-ONE|ONE-MANY|MANY-MANY" } ], "properties": [ { "name":"name1", "type":"type1" } ] } ] } ```   + **`--input-graphdb-schema-file (file URL)`** – Anstatt das Hilfsprogramm für eine Neptune-Datenbank auszuführen, können Sie ein Graphdb-Schema in einer Datei speichern, um es als Eingabe zu verwenden. Unter `--input-graphdb-schema` oben finden Sie ein Beispiel für das JSON-Format für eine Graphdb-Schemadatei.   + **`--input-graphdb-schema-neptune-endpoint (endpoint URL)`** – Der Neptune-Datenbank-Endpunkt, aus dem das Hilfsprogramm das Graphdb-Schema extrahieren soll.   + **`--output-schema-file (file name)`** – Der Name der Ausgabedatei für das GraphQL-Schema. Falls nicht angegeben, ist `output.schema.graphql` die Standardeinstellung, es sei denn, ein Pipeline-Name wurde mit `--create-update-aws-pipeline-name` festgelegt. In diesem Fall lautet der Standarddateiname `(pipline name).schema.graphql`.   + **`--output-source-schema-file (file name)`** – Der Name der Ausgabedatei für das GraphQL-Schema mit Direktiven. Falls nicht angegeben, ist `output.source.schema.graphql` die Standardeinstellung, es sei denn, ein Pipeline-Name wurde mit `--create-update-aws-pipeline-name` festgelegt. In diesem Fall lautet der Standardname `(pipeline name).source.schema.graphql`.   + **`--output-schema-no-mutations`** – Wenn dieses Argument vorhanden ist, generiert das Hilfsprogramm keine Mutationen in der GraphQL-API, sondern nur Abfragen.   + **`--output-neptune-schema-file (file name)`** – Der Name der Ausgabedatei für das Neptune-Graphdb-Schema, das das Hilfsprogramm entdeckt. Falls nicht angegeben, ist `output.graphdb.json` die Standardeinstellung, es sei denn, ein Pipeline-Name wurde mit `--create-update-aws-pipeline-name` festgelegt. In diesem Fall lautet der Standarddateiname `(pipeline name).graphdb.json`.   + **`--output-js-resolver-file (file name)`** – Der Name der Ausgabedatei für eine Kopie des Resolver-Codes. Falls nicht angegeben, ist `output.resolver.graphql.js` die Standardeinstellung, es sei denn, ein Pipeline-Name wurde mit `--create-update-aws-pipeline-name` festgelegt. In diesem Fall lautet der Dateiname `(pipeline name).resolver.graphql.js`. Diese Datei ist in dem Codepaket komprimiert, das in die Lambda-Funktion hochgeladen wurde, die den Resolver ausführt.   + **`--output-resolver-query-sdk`** – Dieses Argument gibt an, dass die Lambda-Funktion des Dienstprogramms Neptune mithilfe des Neptune-Daten-SDK abfragen soll, das seit der [Neptune-Engine-Version 1.2.1.0.R5](engine-releases-1.2.1.0.R5.md) verfügbar ist (dies ist die Standardeinstellung). Wenn das Hilfsprogramm jedoch eine ältere Neptune-Engine-Version erkennt, schlägt es vor, stattdessen die HTTPS-Lambda-Option zu verwenden, die Sie mit dem Argument `--output-resolver-query-https` aufrufen können.   + **`--output-resolver-query-https`** – Dieses Argument gibt an, dass die Lambda-Funktion des Dienstprogramms Neptune mithilfe der Neptune-HTTPS-API abfragen soll.   + **`--create-update-aws-pipeline`**— Dieses Argument löst die Erstellung der AWS Ressourcen aus, die die GraphQL-API verwenden soll, einschließlich der AppSync GraphQL-API und des Lambdas, auf dem der Resolver ausgeführt wird.   + **`--create-update-aws-pipeline-name (pipeline name)`**— Dieses Argument legt den Namen für die Pipeline fest, wie die `pipeline-name` API für AppSync oder die `pipeline-name` Funktion für die Lambda-Funktion. Wenn kein Name angegeben ist, verwendet `--create-update-aws-pipeline` den Datenbanknamen `Neptune ` verwendet. + **`--create-update-aws-pipeline-region (AWS region)`**— Dieses Argument legt die AWS Region fest, in der die Pipeline für die GraphQL-API erstellt wird. Wenn nicht angegeben, ist die Standardregion entweder `us-east-1` oder die Region, in der sich die Neptun-Datenbank befindet, extrahiert aus dem Datenbankendpunkt. + **`--create-update-aws-pipeline-neptune-endpoint (endpoint URL)`** – Dieses Argument legt den Endpunkt der Neptune-Datenbank fest, der von der Lambda-Funktion für die Datenbankabfrage verwendet wird. Wenn nicht gesetzt, wird der von festgelegte `--input-graphdb-schema-neptune-endpoint`-Endpunkt verwendet. + **`--remove-aws-pipeline-name (pipeline name)`** – Dieses Argument entfernt eine Pipeline, die mit erstellt wurde`--create-update-aws-pipeline`. Die zu entfernenden Ressourcen sind in einer Datei aufgeführt, die `(pipeline name).resources.json` heißt. + **`--output-aws-pipeline-cdk`**— Dieses Argument löst die Erstellung einer CDK-Datei aus, mit der die AWS Ressourcen für die GraphQL-API erstellt werden können, einschließlich der GraphQL-API und der AppSync Lambda-Funktion, die den Resolver ausführt. + **`--output-aws-pipeline-cdk-neptume-endpoint (endpoint URL)`** – Dieses Argument legt den Endpunkt der Neptune-Datenbank fest, der von der Lambda-Funktion für die Neptune-Datenbankabfrage verwendet wird. Wenn nicht gesetzt, wird der von festgelegte `--input-graphdb-schema-neptune-endpoint`-Endpunkt verwendet. + **`--output-aws-pipeline-cdk-name (pipeline name)`**— Dieses Argument legt den Pipeline-Namen für die AppSync API und die zu verwendende Lambda-Pipeline-Name-Funktion fest. Wenn nicht angegeben, wird der Neptune-Datenbankname `--create-update-aws-pipeline` verwendet. + **`--output-aws-pipeline-cdk-region (AWS region)`**— Dies legt die AWS Region fest, in der die Pipeline für die GraphQL-API erstellt wird. Wenn nicht angegeben, wird standardmäßig `us-east-1` oder die Region verwendet, in der sich die Neptune-Datenbank befindet, extrahiert aus dem Datenbankendpunkt. + **`--output-aws-pipeline-cdk-file (file name)`** – Dadurch wird der CDK-Dateiname festgelegt. Wenn nicht festgelegt, ist der Standardwert `(pipeline name)-cdk.js`.