Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà. # Utilità Amazon Neptune per GraphQL L'utilità Amazon Neptune per [GraphQL](https://graphql.org/) è uno strumento a riga di comando Node.js open source che può aiutarti a creare e gestire un'API GraphQL per un database a grafo delle proprietà di Neptune (non funziona ancora con dati RDF). È un modo per creare, senza codice, un resolver GraphQL per query GraphQL che hanno un numero variabile di parametri di input e restituiscono un numero variabile di campi annidati. È stato rilasciato come progetto open source situato all'indirizzo. [https://github.com/aws/amazon-neptune-for-graphql](https://github.com/aws/amazon-neptune-for-graphql) Puoi installare l'utilità usando NPM in questo modo (consulta la sezione [Installazione e configurazione](tools-graphql-setup.md) per i dettagli): ``` npm i @aws/neptune-for-graphql -g ``` L'utilità può scoprire lo schema di un grafo delle proprietà di Neptune esistente, inclusi nodi, archi, proprietà e cardinalità degli archi. Quindi genera uno schema GraphQL con le direttive necessarie per mappare i tipi GraphQL ai nodi e agli archi del database, poi genera automaticamente il codice resolver. Quest'ultimo è progettato per ridurre al minimo la latenza restituendo solo i dati richiesti dalla query GraphQL. Puoi anche iniziare con uno schema GraphQL esistente e un database Neptune vuoto, lasciando che l'utilità deduca le direttive necessarie per mappare lo schema GraphQL ai nodi e agli archi dei dati da caricare nel database. In alternativa, puoi iniziare con uno schema GraphQL e le direttive che hai già creato o modificato. L'utilità è in grado di creare tutte le AWS risorse necessarie per la sua pipeline, tra cui l' AWS AppSync API, i ruoli IAM, l'origine dati, lo schema e il resolver e la AWS funzione Lambda che interroga Neptune. **Nota** Gli esempi da riga di comando riportati qui presuppongono l'uso di una console Linux. Se usi Windows, sostituisci la barra rovesciata ("\$1") alla fine delle righe con un accento circonflesso ("^"). **Topics** + [Installazione e configurazione dell'utilità Amazon Neptune per GraphQL](tools-graphql-setup.md) + [Scansione dei dati in un database Neptune esistente](tools-graphql-scan-existing.md) + [Inizio da uno schema GraphQL senza direttive](tools-graphql-start-from-schema.md) + [Uso delle direttive per uno schema GraphQL](tools-graphql-schema-with-directives.md) + [Argomenti della riga di comando per l'utilità GraphQL](tools-graphql-cmd-line-args.md) # Installazione e configurazione dell'utilità Amazon Neptune per GraphQL Se intendi usare l'utilità con un database Neptune esistente, ne hai bisogno per poterti connettere all'endpoint del database. Per impostazione predefinita, un database Neptune è accessibile solo dall'interno del VPC in cui è contenuto. Poiché l'utilità è uno strumento da riga di comando Node.js, per poterla eseguire è necessario che sia installato Node.js (versione 18 o successiva). Per installare Node.js su un'istanza EC2 nello stesso VPC che contiene il database Neptune, segui le [istruzioni riportate qui](https://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/setting-up-node-on-ec2-instance.html). L'istanza di dimensione minima per eseguire l'utilità è t2.micro. Durante la creazione dell'istanza, seleziona il VPC del database Neptune dal menu a discesa **Gruppi di sicurezza comuni**. Per installare l'utilità stessa su un'istanza EC2 o sul computer locale, usa NPM: ``` npm i @aws/neptune-for-graphql -g ``` Puoi quindi eseguire il comando help dell'utilità per verificare se è stata installata correttamente: ``` neptune-for-graphql --help ``` [Potresti anche voler installare il file per gestire le risorse. AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) AWS # Scansione dei dati in un database Neptune esistente Che tu abbia o meno familiarità con GraphQL, il comando seguente è il modo più veloce per creare un'API GraphQL. Questa procedura presuppone che sia stata installata e configurata l'utilità Neptune per GraphQL come descritto nella [sezione dedicata all'installazione](tools-graphql-setup.md), in modo che sia connessa all'endpoint del database Neptune. ``` 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 ``` L'utilità analizza il database per scoprire lo schema dei nodi, degli archi e delle proprietà in esso contenuti. Sulla base di tale schema, deduce uno schema GraphQL con le query e le mutazioni associate. Quindi crea un'API AppSync GraphQL e le AWS risorse necessarie per utilizzarla. Queste risorse includono un paio di ruoli IAM e una funzione Lambda contenente il codice resolver GraphQL. Al termine dell'utilità, troverai una nuova API GraphQL nella AppSync console con il nome assegnato nel comando. Per testarlo, usa l'opzione AppSync **Queries** del menu. Se esegui nuovamente lo stesso comando dopo aver aggiunto altri dati al database, aggiornerà l' AppSync API e il codice Lambda di conseguenza. Per rilasciare tutte le risorse associate al comando, esegui: ``` neptune-for-graphql \ --remove-aws-pipeline-name (your new GraphQL API name from above) ``` # Inizio da uno schema GraphQL senza direttive Puoi iniziare da un database Neptune vuoto e usare uno schema GraphQL senza direttive per creare i dati e interrogarli. Il seguente comando crea automaticamente le risorse AWS per eseguire questo processo: ``` 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 ``` Il file dello schema GraphQL deve includere i tipi di schema GraphQL, come mostrato nell'esempio per TODO riportato di seguito. L'utilità analizza lo schema e crea una versione estesa basata sui tipi che usi. Aggiunge query e mutazioni per i nodi archiviati nel database a grafo e, se lo schema ha dei tipi annidati, aggiunge relazioni tra i tipi archiviati come archi nel database. L'utilità crea un'API AppSync GraphQL e tutte le AWS risorse richieste. Queste includono un paio di ruoli IAM e una funzione Lambda che contiene il codice resolver GraphQL. Al termine del comando, puoi trovare una nuova API GraphQL con il nome specificato nella AppSync console. Per testarlo, usa **Queries nel menu**. AppSync Nell'esempio seguente viene illustrato il funzionamento: ## Esempio Todo, inizio da uno schema GraphQL senza direttive In questo esempio partiamo da uno schema Todo GraphQL senza direttive, che puoi trovare nella directory. *???samples???* Sono inclusi questi due tipi: ``` type Todo { name: String description: String priority: Int status: String comments: [Comment] } type Comment { content: String } ``` Questo comando elabora lo schema Todo e un endpoint di un database Neptune vuoto per creare un'API GraphQL 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 ``` L'utilità crea un nuovo file nella cartella di output denominata `TodoExample.source.graphql` e l'API GraphQL in. AppSync L'utilità deduce quanto segue: + Nel tipo Todo è stato aggiunto `@relationship` un nuovo CommentEdge tipo. Questo indica al resolver di connettere Todo a Comment usando un database grafico chiamato edge. CommentEdge + Ha aggiunto un nuovo input chiamato TodoInput per aiutare le domande e le mutazioni. + Aggiunta di due query per ogni tipo (Todo, Comment): una per recuperare un singolo tipo utilizzando un `id` o uno qualsiasi dei campi del tipo elencati nell'input; l'altra per recuperare più valori, filtrati utilizzando l'input per il tipo in questione. + Aggiunta di tre mutazioni per ogni tipo: create, update e delete. Il tipo da eliminare viene specificato utilizzando un `id` o l'input per quel tipo. Queste mutazioni influiscono sui dati archiviati nel database Neptune. + Aggiunta di due mutazioni per le connessioni: connect e delete. Queste prendono come input gli id nodo dei vertici di partenza e di arrivo utilizzati da Neptune; la connessione è rappresentata dagli archi nel database. Il resolver riconosce query e mutazioni in base al relativo nome, ma è possibile personalizzarle come illustrato [di seguito](tools.md). Di seguito è riportato il contenuto del file `TodoExample.source.graphql`: ``` 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 } ``` Ora puoi creare e interrogare i dati. Ecco un'istantanea della console AppSync **Queries** utilizzata per testare la nuova API GraphQL, denominata `TodoExampleAPI` in questo caso. Nella finestra centrale, lo strumento di esplorazione mostra un elenco di query e mutazioni da cui puoi scegliere una query, i parametri di input e i campi restituiti. Lo screenshot mostra la creazione di un tipo di nodo Todo utilizzando la mutazione `createNodeTodo`: ![\[Schermata che mostra la console AppSync Queries che crea un nodo Todo\]](http://docs.aws.amazon.com/it_it/neptune/latest/userguide/images/todoCreate.png) Lo screenshot mostra l'interrogazione di tutti i nodi Todo utilizzando la query `getNodeTodos`: ![\[Schermata che mostra la console AppSync Queries che interroga i nodi Todo\]](http://docs.aws.amazon.com/it_it/neptune/latest/userguide/images/todoGetTodos.png) Dopo aver creato un Comment utilizzando `createNodeComment`, puoi usare la mutazione `connectNodeTodoToNodeCommentEdgeCommentEdge` per connetterli specificando i relativi id. Di seguito è riportata una query annidata per recuperare i nodi Todo e i relativi commenti allegati: ![\[Schermata che mostra una query annidata per recuperare Todos e i relativi commenti allegati nella console Queries AppSync\]](http://docs.aws.amazon.com/it_it/neptune/latest/userguide/images/todoNestedQuery.png) Se desideri apportare modifiche al file `TodoExample.source.graphql` come descritto nella sezione [Uso delle direttive](tools-graphql-schema-with-directives.md), puoi quindi utilizzare lo schema modificato come input ed eseguire nuovamente l'utilità. A questo punto, l'utilità modifica l'API GraphQL di conseguenza. # Uso delle direttive per uno schema GraphQL Puoi iniziare da uno schema GraphQL che contiene già delle direttive, usando un comando come questo: ``` 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 ``` Puoi modificare le direttive create dall'utilità o aggiungere direttive personalizzate a uno schema GraphQL. Di seguito sono descritti alcuni modi per usare le direttive: ## Esecuzione dell'utilità in modo che non generi mutazioni Per impedire all'utilità di generare mutazioni nell'API GraphQL, usa l'opzione `--output-schema-no-mutations` nel comando `neptune-for-graphql`. ## Direttiva `@alias` La direttiva `@alias` può essere applicata ai tipi o ai campi dello schema GraphQL. Essa esegue la mappatura di nomi diversi tra il database a grafo e lo schema GraphQL. La sintassi è: ``` @alias(property: (property name)) ``` Nell'esempio seguente, `airport` è l'etichetta del nodo del database a grafo mappata al tipo GraphQL `Airport`, mentre `desc` è la proprietà del nodo del grafo mappata al campo `description` (consulta l'[esempio per Air Routes](tools-graphql.md)): ``` type Airport @alias(property: "airport") { city: String description: String @alias(property: "desc") } ``` Nota che la formattazione GraphQL standard richiama nomi di tipo Pascal-casing e nomi di campo camel-casing. ## Direttiva `@relationship` La direttiva `@relationship` mappa i tipi GraphQL annidati agli archi del database a grafo. La sintassi è: ``` @relationship(edgeType: (edge name), direction: (IN or OUT)) ``` Di seguito è illustrato un esempio di comando: ``` 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) } ``` Puoi trovare le direttive `@relationship` sia nell'[esempio Todo](tools-graphql-start-from-schema.md#tools-graphql-todo-example) che nell'[esempio Air Routes](tools-graphql.md). ## Direttive `@graphQuery` e `@cypher` Puoi definire query openCypher per risolvere un valore di campo, aggiungere query o aggiungere mutazioni. Ad esempio, puoi aggiungere un nuovo campo `outboundRoutesCount` al tipo `Airport` per contare le route in uscita: ``` type Airport @alias(property: "airport") { ... outboundRoutesCount: Int @graphQuery(statement: "MATCH (this)-[r:route]->(a) RETURN count(r)") } ``` Di seguito è riportato un esempio con nuove query e mutazioni: ``` 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") } ``` Nota: se ometti `RETURN`, il resolver presume che la parola chiave `this` sia l'ambito di restituzione. Puoi anche aggiungere una query o una mutazione usando una query Gremlin: ``` 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 } ``` Al momento le query Gremlin sono limitate a quelle che restituiscono valori scalari, ovvero `elementMap()` per un singolo nodo o `elementMap().fold()` per un elenco di nodi. ## Direttiva `@id` La direttiva `@id` identifica il campo mappato all'entità del database a grafo `id`. I database a grafo come Amazon Neptune hanno sempre un `id` univoco per nodi e archi che viene assegnato durante le importazioni in blocco o generato automaticamente. Esempio: ``` type Airport { _id: ID! @id city: String code: String } ``` ## Nomi di tipo, query e mutazione riservati L'utilità genera automaticamente query e mutazioni per creare un'API GraphQL funzionante. Il modello di questi nomi è riconosciuto dal resolver ed è riservato. Di seguito sono riportati alcuni esempi del tipo `Airport` e del tipo di connessione `Route`: Il tipo `Options` è riservato. ``` input Options { limit: Int } ``` I parametri `filter` e `options` della funzione sono riservati. ``` type Query { getNodeAirports(filter: AirportInput, options: Options): [Airport] } ``` Il prefisso getNode dei nomi delle query è riservato, e anche i prefissi dei nomi delle mutazioni come`createNode`, `updateNode`, `deleteNode`, `connectNode`, `deleteNode`, `updateEdge` e `deleteEdge` sono riservati. ``` 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 } ``` ## Applicazione di modifiche allo schema GraphQL Puoi modificare lo schema di origine GraphQL ed eseguire nuovamente l'utilità, ottenendo lo schema più recente dal database Neptune. Ogni volta che l'utilità rileva un nuovo schema nel database, genera un nuovo schema GraphQL. Puoi anche modificare manualmente lo schema di origine GraphQL ed eseguire nuovamente l'utilità utilizzando come input lo schema di origine anziché l'endpoint del database Neptune. Infine, puoi inserire le modifiche in un file utilizzando questo formato JSON: ``` [ { "type": "(GraphQL type name)", "field": "(GraphQL field name)", "action": "(remove or add)", "value": "(value)" } ] ``` Esempio: ``` [ { "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": "" } ] ``` Quindi, quando esegui l'utilità su questo file utilizzando il parametro `--input-schema-changes-file` nel comando, l'utilità applica le modifiche tutte insieme. # Argomenti della riga di comando per l'utilità GraphQL + **`--help, -h`**: restituisce alla console il testo della guida per l'utilità GraphQL.   + **`--input-schema (schema text)`**: uno schema GraphQL, con o senza direttive, da usare come input.   + **`--input-schema-file (file URL)`**: URL di un file contenente uno schema GraphQL da usare come input.   + **`--input-schema-changes-file (file URL)`**: URL di un file contenente le modifiche da apportare a uno schema GraphQL. Se esegui più volte l'utilità su un database Neptune e in più modifichi manualmente lo schema di origine GraphQL (aggiungendo ad esempio una query personalizzata), le modifiche manuali andranno perse. Per evitare che ciò accada, inserisci le modifiche in un file dedicato e passalo utilizzando questo argomento. Il file delle modifiche usa il seguente formato JSON: ``` [ { "type": "(GraphQL type name)", "field": "(GraphQL field name)", "action": "(remove or add)", "value": "(value)" } ] ``` Per ulteriori informazioni, consulta l'[esempio Todo](tools-graphql-start-from-schema.md#tools-graphql-todo-example).   + **`--input-graphdb-schema (schema text)`**: anziché eseguire l'utilità su un database Neptune, puoi esplicitare uno schema graphdb in formato testo da utilizzare come input. Uno schema graphdb ha un formato JSON come questo: ``` { "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)`**: anziché eseguire l'utilità su un database Neptune, puoi salvare uno schema graphdb in un file da utilizzare come input. Vedi `--input-graphdb-schema` qui sopra per un esempio del formato JSON per un file dello schema graphdb.   + **`--input-graphdb-schema-neptune-endpoint (endpoint URL)`**: endpoint del database Neptune da cui l'utilità deve estrarre lo schema graphdb.   + **`--output-schema-file (file name)`**: nome del file di output per lo schema GraphQL. Se non specificato, il valore predefinito è `output.schema.graphql`, a meno che non sia stato impostato un nome di pipeline utilizzando `--create-update-aws-pipeline-name`, nel qual caso il nome di file predefinito è `(pipline name).schema.graphql`.   + **`--output-source-schema-file (file name)`**: nome del file di output per lo schema GraphQL con direttive. Se non specificato, il valore predefinito è `output.source.schema.graphql`, a meno che non sia stato impostato un nome di pipeline utilizzando `--create-update-aws-pipeline-name`, nel qual caso il nome predefinito è `(pipeline name).source.schema.graphql`.   + **`--output-schema-no-mutations`**: se questo argomento è presente, l'utilità non genera mutazioni nell'API GraphQL, ma solo query.   + **`--output-neptune-schema-file (file name)`**: nome del file di output per lo schema graphdb di Neptune che l'utilità rileva. Se non specificato, il valore predefinito è `output.graphdb.json`, a meno che non sia stato impostato un nome di pipeline utilizzando `--create-update-aws-pipeline-name`, nel qual caso il nome di file predefinito è `(pipeline name).graphdb.json`.   + **`--output-js-resolver-file (file name)`**: nome del file di output per una copia del codice del resolver. Se non specificato, il valore predefinito è `output.resolver.graphql.js`, a meno che non sia stato impostato un nome di pipeline utilizzando `--create-update-aws-pipeline-name`, nel qual caso il nome del file è `(pipeline name).resolver.graphql.js`. Questo file è compresso nel pacchetto di codice caricato nella funzione Lambda che esegue il resolver.   + **`--output-resolver-query-sdk`**: questo argomento specifica che la funzione Lambda dell'utilità deve interrogare Neptune utilizzando l'SDK per i dati Neptune, disponibile a partire dalla [versione 1.2.1.0.R5 del motore Neptune](engine-releases-1.2.1.0.R5.md) (questa è l'impostazione predefinita). Tuttavia, se l'utilità rileva una versione precedente del motore Neptune, suggerisce di utilizzare invece l'opzione HTTPS Lambda, che è possibile richiamare utilizzando l'argomento `--output-resolver-query-https`.   + **`--output-resolver-query-https`**: questo argomento specifica che la funzione Lambda dell'utilità deve interrogare Neptune utilizzando l'API HTTPS Neptune.   + **`--create-update-aws-pipeline`**— Questo argomento attiva la creazione delle AWS risorse da utilizzare per l'API GraphQL, tra cui l'API AppSync GraphQL e la Lambda che esegue il resolver.   + **`--create-update-aws-pipeline-name (pipeline name)`**— Questo argomento imposta il nome della pipeline, ad esempio l'`pipeline-name`API AppSync o la `pipeline-name` funzione per la funzione Lambda. Se non viene specificato un nome, `--create-update-aws-pipeline` usa il nome del database `Neptune `. + **`--create-update-aws-pipeline-region (AWS region)`**— Questo argomento imposta la AWS regione in cui viene creata la pipeline per l'API GraphQL. Se non è specificata, la regione predefinita è `us-east-1` o la regione in cui si trova il database Neptune, ricavata dall'endpoint del database. + **`--create-update-aws-pipeline-neptune-endpoint (endpoint URL)`**: questo argomento imposta l'endpoint del database Neptune utilizzato dalla funzione Lambda per interrogare il database. Se non è impostato, viene utilizzato l'endpoint impostato da `--input-graphdb-schema-neptune-endpoint`. + **`--remove-aws-pipeline-name (pipeline name)`**: questo argomento rimuove una pipeline creata utilizzando `--create-update-aws-pipeline`. Le risorse da rimuovere sono elencate in un file denominato `(pipeline name).resources.json`. + **`--output-aws-pipeline-cdk`**— Questo argomento attiva la creazione di un file CDK che può essere utilizzato per creare AWS le risorse per l'API GraphQL, tra cui l'API GraphQL e la funzione AppSync Lambda che esegue il resolver. + **`--output-aws-pipeline-cdk-neptume-endpoint (endpoint URL)`**: questo argomento imposta l'endpoint del database Neptune utilizzato dalla funzione Lambda per interrogare il database Neptune. Se non è impostato, viene utilizzato l'endpoint impostato da `--input-graphdb-schema-neptune-endpoint`. + **`--output-aws-pipeline-cdk-name (pipeline name)`**— Questo argomento imposta il nome della pipeline per l' AppSync API e la funzione Lambda pipeline-name da utilizzare. Se non specificato, `--create-update-aws-pipeline` utilizza il nome del database Neptune. + **`--output-aws-pipeline-cdk-region (AWS region)`**— Imposta la AWS regione in cui viene creata la pipeline per l'API GraphQL. Se non specificato, il valore predefinito è `us-east-1` o la regione in cui si trova il database Neptune, ricavata dall'endpoint del database. + **`--output-aws-pipeline-cdk-file (file name)`**: imposta il nome del file CDK. Se non è impostato, il valore predefinito è `(pipeline name)-cdk.js`.