Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra. # Outils et utilitaires Neptune Amazon Neptune fournit divers outils et utilitaires qui contribuent à simplifier et à automatiser les tâches liées à un graphe. Parmi eux, citons : **Outils Amazon Neptune** + **[Utilitaire Amazon Neptune pour GraphQL](tools-graphql.md)** : l'utilitaire Amazon Neptune pour GraphQL est un outil de ligne de commande Node.js open source qui peut vous aider à créer et à gérer une API [GraphQL](https://graphql.org/) pour une base de données orientée graphe de propriétés Neptune. Il s'agit d'une méthode sans code permettant de créer un résolveur GraphQL pour les requêtes GraphQL qui ont un nombre variable de paramètres d'entrée et renvoient un nombre variable de champs imbriqués. + **[Nodestream](tools-Nodestream.md)** — Nodestream est un framework permettant de modéliser sémantiquement des données sous forme de graphe. Il est conçu pour être flexible et extensible, vous permettant de définir la manière dont les données sont collectées et modélisées sous forme de graphique. Il utilise une approche basée sur le pipeline pour définir la manière dont les données sont collectées et traitées, et il fournit un moyen de définir la manière dont le graphique doit être mis à jour lorsque le schéma change. + **[Serveurs de requête Amazon Neptune MCP : serveur](https://github.com/aws-samples/amazon-neptune-generative-ai-samples/blob/main/neptune-mcp-servers/neptune-query/README.md)** MCP (Model Context Protocol) pour Amazon Neptune qui prend en charge à la fois Neptune Database et Neptune Analytics en permettant d'exécuter des requêtes graphiques (OpenCypher et Gremlin) ainsi que de récupérer le schéma du graphe. + **[Serveurs de mémoire Amazon Neptune MCP : serveur](https://github.com/aws-samples/amazon-neptune-generative-ai-samples/blob/main/neptune-mcp-servers/neptune-memory/README.md)** MCP (Model Context Protocol) pour Amazon Neptune qui fournit de la mémoire aux agents, stockée dans un graphe de connaissances par rapport à Amazon Neptune. # Utilitaire Amazon Neptune pour GraphQL L'utilitaire Amazon Neptune pour [GraphQL](https://graphql.org/) est un outil de ligne de commande Node.js open source qui peut vous aider à créer et à gérer une API GraphQL pour une base de données orientée graphe de propriétés Neptune (il ne fonctionne pas encore avec les données RDF). Il s'agit d'une méthode sans code permettant de créer un résolveur GraphQL pour les requêtes GraphQL qui ont un nombre variable de paramètres d'entrée et renvoient un nombre variable de champs imbriqués. Il a été publié en tant que projet open source situé à l'adresse [https://github.com/aws/amazon-neptune-for-graphql](https://github.com/aws/amazon-neptune-for-graphql). Vous pouvez installer cet utilitaire à l'aide de NPM comme suit (voir [Installation et configuration](tools-graphql-setup.md) pour plus d'informations) : ``` npm i @aws/neptune-for-graphql -g ``` L'utilitaire peut découvrir le schéma d'un graphe de propriétés Neptune existant, y compris les nœuds, les arêtes, les propriétés et la cardinalité des arêtes. Il génère ensuite un schéma GraphQL avec les directives nécessaires pour mapper les types GraphQL avec les nœuds et les arêtes de la base de données, puis génère automatiquement le code du résolveur. Le code du résolveur est conçu pour minimiser la latence en renvoyant uniquement les données demandées par la requête GraphQL. Vous pouvez également commencer avec un schéma GraphQL existant et une base de données Neptune vide, puis laisser l'utilitaire déduire les directives nécessaires pour mapper ce schéma GraphQL avec les nœuds et arêtes des données à charger dans la base de données. Vous pouvez également commencer par un schéma GraphQL et des directives que vous avez déjà créés ou modifiés. L'utilitaire est capable de créer toutes les AWS ressources dont il a besoin pour son pipeline, notamment l' AWS AppSync API, les rôles IAM, la source de données, le schéma et le résolveur, ainsi que la fonction AWS Lambda qui interroge Neptune. **Note** Les exemples de ligne de commande présentés ici supposent l'utilisation d'une console Linux. Si vous utilisez Windows, remplacez les barres obliques inverses (« \$1 ») à la fin des lignes par des accents circonflexes (« ^ »). **Topics** + [Installation et configuration de l'utilitaire Amazon Neptune pour GraphQL](tools-graphql-setup.md) + [Numérisation de données dans une base de données Neptune existante](tools-graphql-scan-existing.md) + [À partir d'un schéma GraphQL sans directives](tools-graphql-start-from-schema.md) + [Utilisation des directives pour un schéma GraphQL](tools-graphql-schema-with-directives.md) + [Arguments de ligne de commande pour l'utilitaire GraphQL](tools-graphql-cmd-line-args.md) # Installation et configuration de l'utilitaire Amazon Neptune pour GraphQL Si vous comptez utiliser l'utilitaire avec une base de données Neptune existante, il doit pouvoir se connecter au point de terminaison de la base de données. Par défaut, une base de données Neptune n'est accessible que depuis le VPC où elle se trouve. Étant donné que l'utilitaire est un outil de ligne de commande Node.js, Node.js (version 18 ou supérieure) doit être installé pour qu'il s'exécute. Pour installer Node.js sur une instance EC2 dans le même VPC que votre base de données Neptune, suivez [ces instructions](https://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/setting-up-node-on-ec2-instance.html). La taille minimale de l'instance pour exécuter l'utilitaire est t2.micro. Lors de la création de l'instance, sélectionnez le VPC de base de données Neptune dans le menu déroulant **Groupes de sécurité courants**. Pour installer l'utilitaire lui-même sur une instance EC2 ou sur votre ordinateur local, utilisez NPM : ``` npm i @aws/neptune-for-graphql -g ``` Vous pouvez ensuite exécuter la commande d'aide de l'utilitaire pour vérifier s'il est correctement installé : ``` neptune-for-graphql --help ``` Vous pouvez également [installer le AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) pour gérer les AWS ressources. # Numérisation de données dans une base de données Neptune existante Que vous connaissiez GraphQL ou non, la commande ci-dessous est le moyen le plus rapide de créer une API GraphQL. Cela suppose que vous avez installé et configuré l'utilitaire Neptune pour GraphQL comme décrit dans la [section d'installation](tools-graphql-setup.md), afin qu'il soit connecté au point de terminaison de votre base de données 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'utilitaire analyse la base de données pour découvrir le schéma des nœuds, des arêtes et des propriétés qu'elle contient. Sur la base de ce schéma, il déduit un schéma GraphQL avec les requêtes et les mutations associées. Il crée ensuite une API AppSync GraphQL et les AWS ressources nécessaires pour l'utiliser. Ces ressources incluent une paire de rôles IAM et une fonction Lambda contenant le code du résolveur GraphQL. Une fois l'utilitaire terminé, vous trouverez une nouvelle API GraphQL dans la AppSync console sous le nom que vous avez attribué dans la commande. Pour le tester, utilisez l'option AppSync **Requêtes** du menu. Si vous réexécutez la même commande après avoir ajouté des données supplémentaires à la base de données, l' AppSync API et le code Lambda seront mis à jour en conséquence. Pour libérer toutes les ressources associées à la commande, exécutez : ``` neptune-for-graphql \ --remove-aws-pipeline-name (your new GraphQL API name from above) ``` # À partir d'un schéma GraphQL sans directives Vous pouvez commencer avec une base de données Neptune vide et utiliser un schéma GraphQL sans directives pour créer les données et les interroger. La commande ci-dessous crée automatiquement les ressources AWS nécessaires à cette fin : ``` 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 ``` Le fichier de schéma GraphQL doit inclure les types de schéma GraphQL, comme indiqué dans l'exemple TODO ci-dessous. L'utilitaire analyse le schéma et crée une version étendue en fonction de vos types. Il ajoute des requêtes et des mutations pour les nœuds stockés dans la base de données orientée graphe, et si votre schéma comporte des types imbriqués, il ajoute des relations entre les types stockés sous forme d'arêtes dans la base de données. L'utilitaire crée une API AppSync GraphQL et toutes les AWS ressources nécessaires. Ces ressources incluent une paire de rôles IAM et une fonction Lambda contenant le code du résolveur GraphQL. Lorsque la commande est terminée, vous pouvez trouver une nouvelle API GraphQL portant le nom que vous avez spécifié dans la AppSync console. Pour le tester, utilisez **Requêtes** dans le AppSync menu. L'exemple suivant illustre comment cela fonctionne : ## Exemple Todo avec un schéma GraphQL sans directives Dans cet exemple, nous partons d'un schéma Todo GraphQL sans directives, que vous pouvez trouver dans *???samples???* le répertoire. Il inclut les deux types suivants : ``` type Todo { name: String description: String priority: Int status: String comments: [Comment] } type Comment { content: String } ``` Cette commande traite le schéma Todo et un point de terminaison d'une base de données Neptune vide pour créer une API GraphQL dans : 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'utilitaire crée un nouveau fichier dans le dossier de sortie appelé`TodoExample.source.graphql`, et l'API GraphQL dans. AppSync L'utilitaire en déduit ce qui suit : + Dans le type Todo, il a été ajouté `@relationship` pour un nouveau CommentEdge type. Cela indique au résolveur de connecter Todo à Comment à l'aide d'un edge de base de données de graphes appelé. CommentEdge + Il a ajouté une nouvelle entrée appelée TodoInput pour aider les requêtes et les mutations. + Il a ajouté deux requêtes pour chaque type (Todo, Comment) : l'une pour récupérer un seul type en utilisant un `id` ou l'un des champs de type répertoriés dans l'entrée, et l'autre pour récupérer plusieurs valeurs, filtrées à l'aide de l'entrée correspondant à ce type. + Il a ajouté trois mutations pour chaque type : créer, mettre à jour et supprimer. Le type à supprimer est spécifié à l'aide d'un `id` ou de l'entrée correspondant à ce type. Ces mutations concernent les données stockées dans la base de données Neptune. + Il a ajouté deux mutations pour les connexions : connecter et supprimer. Elles utilisent en entrée les ID de nœud des sommets de départ et de destination utilisés par Neptune, et les connexions sont des arêtes dans la base de données. Le résolveur reconnaît les requêtes et les mutations par leur nom, mais vous pouvez les personnaliser comme indiqué [ci-dessous](tools.md). Voici le contenu du fichier `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 } ``` Vous pouvez désormais créer et interroger des données. Voici un aperçu de la console AppSync **Queries** utilisée pour tester la nouvelle API GraphQL, nommée `TodoExampleAPI` dans ce cas. Dans la fenêtre du milieu, l'explorateur affiche une liste de requêtes et de mutations parmi lesquelles vous pouvez sélectionner une requête, les paramètres d'entrée et les champs de retour. Cette capture d'écran montre la création d'un type de nœud Todo à l'aide de la mutation `createNodeTodo` : ![\[Capture d'écran montrant la console AppSync Queries créant un nœud Todo\]](http://docs.aws.amazon.com/fr_fr/neptune/latest/userguide/images/todoCreate.png) Cette capture d'écran montre comment interroger tous les nœuds Todo à l'aide de la requête `getNodeTodos` : ![\[Capture d'écran montrant la console AppSync Queries interrogeant les nœuds Todo\]](http://docs.aws.amazon.com/fr_fr/neptune/latest/userguide/images/todoGetTodos.png) Après avoir créé un commentaire à l'aide de `createNodeComment`, vous pouvez utiliser la mutation `connectNodeTodoToNodeCommentEdgeCommentEdge` pour les connecter en spécifiant leur ID. Voici une requête imbriquée permettant de récupérer les nœuds Todo et les commentaires qui y sont associés : ![\[Capture d'écran montrant une requête imbriquée pour récupérer Todos et ses commentaires joints dans la AppSync console Queries\]](http://docs.aws.amazon.com/fr_fr/neptune/latest/userguide/images/todoNestedQuery.png) Si vous souhaitez apporter des modifications au fichier `TodoExample.source.graphql` comme décrit dans la section [Utilisation des directives](tools-graphql-schema-with-directives.md), vous pouvez utiliser le schéma modifié comme entrée et exécuter à nouveau l'utilitaire. L'utilitaire modifiera ensuite l'API GraphQL en conséquence. # Utilisation des directives pour un schéma GraphQL Vous pouvez partir d'un schéma GraphQL qui contient déjà des directives, en utilisant une commande comme celle-ci : ``` 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 ``` Vous pouvez modifier les directives créées par l'utilitaire ou ajouter les vôtres à un schéma GraphQL. Voici quelques méthodes d'utilisation des directives : ## Exécutation de l'utilitaire pour qu'il ne génère pas de mutations Pour empêcher l'utilitaire de générer des mutations dans l'API GraphQL, utilisez l'option `--output-schema-no-mutations` de la commande `neptune-for-graphql`. ## Directive `@alias` La directive `@alias` peut être appliquée aux types de schéma ou aux champs GraphQL. Elle mappe différents noms entre la base de données orientée graphe et le schéma GraphQL. La syntaxe est la suivante : ``` @alias(property: (property name)) ``` Dans l'exemple ci-dessous, `airport` est l'étiquette du nœud de base de données orientée graphe mappée avec le type GraphQL `Airport`, et `desc` est la propriété du nœud de graphe mappée avec le champ `description` (voir l'[exemple des routes aériennes](tools-graphql.md)) : ``` type Airport @alias(property: "airport") { city: String description: String @alias(property: "desc") } ``` Notez que la mise en forme GraphQL standard nécessite des noms de type avec la casse Pascal et des noms de champs avec la casse Camel. ## Directive `@relationship` La directive `@relationship` mappe les types GraphQL imbriqués avec les arêtes de la base de données orientée graphe. La syntaxe est la suivante : ``` @relationship(edgeType: (edge name), direction: (IN or OUT)) ``` Voici un exemple de commande : ``` 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) } ``` Vous trouverez des directives `@relationship` à la fois dans l'[exemple Todo](tools-graphql-start-from-schema.md#tools-graphql-todo-example) et dans l'[exemple des routes aériennes](tools-graphql.md). ## Directives `@graphQuery` et `@cypher` Vous pouvez définir des requêtes openCypher pour résoudre une valeur de champ, ajouter des requêtes ou ajouter des mutations. Par exemple, cela ajoute un nouveau champ `outboundRoutesCount` au type `Airport` pour compter les routes sortantes : ``` type Airport @alias(property: "airport") { ... outboundRoutesCount: Int @graphQuery(statement: "MATCH (this)-[r:route]->(a) RETURN count(r)") } ``` Voici un exemple de nouvelles requêtes et mutations : ``` 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") } ``` Notez que si vous omettez `RETURN`, le résolveur suppose que le mot clé `this` est la portée renvoyée. Vous pouvez également ajouter une requête ou une mututation à l'aide d'une requête 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 } ``` À l'heure actuelle, les requêtes Gremlin sont limitées à celles qui renvoient des valeurs scalaires, `elementMap()` pour un seul nœud ou `elementMap().fold()` pour une liste de nœuds. ## Directive `@id` La directive `@id` identifie le champ mappé avec l'entité de base de données orientée graphe `id`. Les bases de données orientées graphe telles qu'Amazon Neptune disposent toujours d'un `id` unique pour les nœuds et les arêtes. Celui-ci est attribué lors des importations en bloc ou est généré automatiquement. Par exemple : ``` type Airport { _id: ID! @id city: String code: String } ``` ## Noms de type, de requête et de mutation réservés L'utilitaire génère automatiquement des requêtes et des mutations pour créer une API GraphQL fonctionnelle. Le modèle de ces noms est reconnu par le résolveur et est réservé. Voici des exemples pour le type `Airport` et le type de connexion `Route` : Le nom `Options` est réservé. ``` input Options { limit: Int } ``` Les paramètres de fonction `filter` et `options` sont réservés. ``` type Query { getNodeAirports(filter: AirportInput, options: Options): [Airport] } ``` Le préfixe getNode des noms de requêtes est réservé, et les préfixes des noms de mutations tels que `createNode`, `updateNode`, `deleteNode`, `connectNode`, `deleteNode`, `updateEdge` et `deleteEdge` sont réservés. ``` 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 } ``` ## Application de modifications au schéma GraphQL Vous pouvez modifier le schéma source GraphQL et réexécuter l'utilitaire pour obtenir le dernier schéma de la base de données Neptune. Chaque fois que l'utilitaire découvre un nouveau schéma dans la base de données, il génère un nouveau schéma GraphQL. Vous pouvez également modifier manuellement le schéma source GraphQL et réexécuter l'utilitaire en utilisant le schéma source comme entrée au lieu du point de terminaison de la base de données Neptune. Enfin, vous pouvez placer vos modifications dans un fichier à l'aide de ce format JSON : ``` [ { "type": "(GraphQL type name)", "field": "(GraphQL field name)", "action": "(remove or add)", "value": "(value)" } ] ``` Par exemple : ``` [ { "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": "" } ] ``` Ensuite, lorsque vous exécutez l'utilitaire sur ce fichier à l'aide du paramètre `--input-schema-changes-file` de la commande, l'utilitaire applique les modifications immédiatement. # Arguments de ligne de commande pour l'utilitaire GraphQL + **`--help, -h`** : renvoie le texte d'aide de l'utilitaire GraphQL à la console.   + **`--input-schema (schema text)`** : schéma GraphQL, avec ou sans directives, à utiliser en entrée.   + **`--input-schema-file (file URL)`** : URL d'un fichier contenant un schéma GraphQL à utiliser en entrée.   + **`--input-schema-changes-file (file URL)`** : URL d'un fichier contenant les modifications que vous souhaitez apporter à un schéma GraphQL. Si vous exécutez l'utilitaire sur une base de données Neptune à plusieurs reprises et que vous modifiez également manuellement le schéma source GraphQL, par exemple en ajoutant une requête personnalisée, les modifications manuelles seront perdues. Pour éviter cela, placez les modifications dans un fichier de modifications et transmettez-le à l'aide de cet argument. Le fichier de modifications utilise le format JSON suivant : ``` [ { "type": "(GraphQL type name)", "field": "(GraphQL field name)", "action": "(remove or add)", "value": "(value)" } ] ``` Pour plus d'informations, consultez l'[exemple Todo](tools-graphql-start-from-schema.md#tools-graphql-todo-example).   + **`--input-graphdb-schema (schema text)`** : au lieu d'exécuter l'utilitaire sur une base de données Neptune, vous pouvez exprimer un schéma graphdb sous forme de texte à utiliser comme entrée. Un schéma graphdb a un format JSON comme celui-ci : ``` { "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)`** : au lieu d'exécuter l'utilitaire sur une base de données Neptune, vous pouvez enregistrer un schéma graphdb dans un fichier à utiliser comme entrée. Consultez `--input-graphdb-schema` ci-dessus pour voir un exemple du format JSON pour un fichier de schéma graphdb.   + **`--input-graphdb-schema-neptune-endpoint (endpoint URL)`** : point de terminaison de base de données Neptune à partir duquel l'utilitaire doit extraire le schéma graphdb.   + **`--output-schema-file (file name)`** : nom du fichier de sortie pour le schéma GraphQL. S'il n'est pas spécifié, la valeur par défaut est `output.schema.graphql`, sauf si un nom de pipeline a été défini avec `--create-update-aws-pipeline-name`, auquel cas le nom de fichier par défaut est `(pipline name).schema.graphql`.   + **`--output-source-schema-file (file name)`** : nom du fichier de sortie correspondant au schéma GraphQL avec directives. S'il n'est pas spécifié, la valeur par défaut est `output.source.schema.graphql`, sauf si un nom de pipeline a été défini avec `--create-update-aws-pipeline-name`, auquel cas le nom par défaut est `(pipeline name).source.schema.graphql`.   + **`--output-schema-no-mutations`** : si cet argument est présent, l'utilitaire ne génère aucune mutation dans l'API GraphQL, uniquement des requêtes.   + **`--output-neptune-schema-file (file name)`** : nom du fichier de sortie du schéma Neptune graphdb découvert par l'utilitaire. S'il n'est pas spécifié, la valeur par défaut est `output.graphdb.json`, sauf si un nom de pipeline a été défini avec `--create-update-aws-pipeline-name`, auquel cas le nom de fichier par défaut est `(pipeline name).graphdb.json`.   + **`--output-js-resolver-file (file name)`** : nom du fichier de sortie correspondant à une version du code du résolveur. S'il n'est pas spécifié, la valeur par défaut est `output.resolver.graphql.js`, sauf si un nom de pipeline a été défini avec `--create-update-aws-pipeline-name`, auquel cas le nom de fichier est `(pipeline name).resolver.graphql.js`. Ce fichier est compressé dans le package de code chargé vers la fonction Lambda qui exécutera le résolveur.   + **`--output-resolver-query-sdk`** : cet argument indique que la fonction Lambda de l'utilitaire doit interroger Neptune à l'aide du kit SDK de données Neptune, qui est disponible à partir de la [version 1.2.1.0.R5 du moteur Neptune](engine-releases-1.2.1.0.R5.md) (il s'agit de la version par défaut). Toutefois, si l'utilitaire détecte une ancienne version du moteur Neptune, il suggère d'utiliser plutôt l'option Lambda HTTPS, que vous pouvez invoquer à l'aide de l'argument `--output-resolver-query-https`.   + **`--output-resolver-query-https`** : cet argument indique que la fonction Lambda de l'utilitaire doit interroger Neptune à l'aide de l'API Neptune HTTPS.   + **`--create-update-aws-pipeline`**— Cet argument déclenche la création des AWS ressources que l'API GraphQL doit utiliser, notamment l'API AppSync GraphQL et le Lambda qui exécute le résolveur.   + **`--create-update-aws-pipeline-name (pipeline name)`**— Cet argument définit le nom du pipeline, comme l'`pipeline-name`API AppSync ou la fonction de la `pipeline-name` fonction Lambda. Si aucun nom n'est spécifié, `--create-update-aws-pipeline` utilise le nom de la base de données `Neptune `. + **`--create-update-aws-pipeline-region (AWS region)`**— Cet argument définit la AWS région dans laquelle le pipeline de l'API GraphQL est créé. Si elle n'est pas spécifiée, la région par défaut est `us-east-1` ou la région où se trouve la base de données Neptune, extraite du point de terminaison de la base de données. + **`--create-update-aws-pipeline-neptune-endpoint (endpoint URL)`** : cet argument définit le point de terminaison de la base de données Neptune utilisé par la fonction Lambda pour interroger la base de données. S'il n'est pas défini, le point de terminaison défini par `--input-graphdb-schema-neptune-endpoint` est utilisé. + **`--remove-aws-pipeline-name (pipeline name)`** : cet argument supprime un pipeline créé à l'aide de `--create-update-aws-pipeline`. Les ressources à supprimer sont répertoriées dans un fichier nommé `(pipeline name).resources.json`. + **`--output-aws-pipeline-cdk`**— Cet argument déclenche la création d'un fichier CDK qui peut être utilisé pour créer les AWS ressources de l'API GraphQL, notamment l'API GraphQL et la AppSync fonction Lambda qui exécute le résolveur. + **`--output-aws-pipeline-cdk-neptume-endpoint (endpoint URL)`** : cet argument définit le point de terminaison de la base de données Neptune utilisé par la fonction Lambda pour interroger la base de données Neptune. S'il n'est pas défini, le point de terminaison défini par `--input-graphdb-schema-neptune-endpoint` est utilisé. + **`--output-aws-pipeline-cdk-name (pipeline name)`**— Cet argument définit le nom du pipeline pour l' AppSync API et la fonction Lambda pipeline-name à utiliser. S'il n'est pas spécifié, `--create-update-aws-pipeline` utilise le nom de la base de données Neptune. + **`--output-aws-pipeline-cdk-region (AWS region)`**— Cela définit la AWS région dans laquelle le pipeline de l'API GraphQL est créé. Si elle n'est pas spécifiée, la région par défaut est `us-east-1` ou la région où se trouve la base de données Neptune, extraite du point de terminaison de la base de données. + **`--output-aws-pipeline-cdk-file (file name)`** : définit le nom du fichier CDK. Si aucune valeur n'est définie, la valeur par défaut est `(pipeline name)-cdk.js`. # Flux de nœuds [Nodestream](https://nodestream-proj.github.io/docs/docs/intro/) est un framework permettant de modéliser sémantiquement des données sous forme de graphe. Il est conçu pour être flexible et extensible, vous permettant de définir la manière dont les données sont collectées et modélisées sous forme de graphique. Il utilise une approche basée sur le pipeline pour définir la manière dont les données sont collectées et traitées, et il fournit un moyen de définir la manière dont le graphique doit être mis à jour lorsque le schéma change. Tout cela se fait à l'aide d'un fichier de configuration simple et lisible par l'homme au format yaml. Pour ce faire, Nodestream utilise un certain nombre de concepts de base, notamment les pipelines, les extracteurs, les transformateurs, les filtres, les interpréteurs, les interprétations et les migrations. [À partir de [Nodestream 0.12, Amazon](https://nodestream-proj.github.io/docs/blog/2024/04/05/nodestream-0-12/) Neptune est pris en charge à la fois pour Neptune Database et Neptune Analytics.](https://nodestream-proj.github.io/docs/docs/databases/neptune/) [Consultez la documentation Nodestream pour savoir comment configurer et utiliser Nodestream avec Neptune : support Nodestream pour Amazon Neptune.](https://nodestream-proj.github.io/docs/docs/databases/neptune/) Nodestream with Neptune prend actuellement en charge les pipelines ETL standard ainsi que les pipelines Time to Live (TTL). Les pipelines ETL permettent l'ingestion de données en masse dans Neptune à partir d'un éventail de sources de données et de formats beaucoup plus large que ce qui était possible auparavant dans Neptune, notamment : + [Nomenclature du logiciel](https://nodestream-proj.github.io/docs/docs/official-plugins/sbom/) + [Fichiers tels que CSV, JSON, JSONL, Parquet, txt et yaml](https://nodestream-proj.github.io/docs/docs/reference/extractors/) + [Kafka](https://nodestream-proj.github.io/docs/docs/reference/extractors/#streamextractor) + [Athéna](https://nodestream-proj.github.io/docs/docs/reference/extractors/#athenaextractor) + [REST APIs](https://nodestream-proj.github.io/docs/docs/reference/extractors/#simpleapiextractor) Nodestream prend entièrement en charge l'authentification IAM lors de la connexion à Amazon Neptune, à condition que les informations d'identification soient correctement configurées. Consultez le [guide des informations d'identification boto3](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/credentials.html#configuring-credentials) pour plus d'informations sur la configuration correcte des informations d'identification. Le [mécanisme TTL de Nodestream permet également de](https://nodestream-proj.github.io/docs/docs/tutorials-intermediate/removing-data/) nouvelles fonctionnalités qui n'étaient pas disponibles auparavant dans Neptune. En annotant les éléments graphiques ingérés avec des horodatages, Nodestream peut créer des pipelines qui expirent automatiquement et suppriment les données dont la durée de vie est dépassée.