Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés. # Herramientas y utilidades de Neptune Amazon Neptune ofrece una serie de herramientas y utilidades que pueden simplificar y automatizar el trabajo con un gráfico. A continuación, vamos a ver algunas: **Herramientas de Amazon Neptune** + **[Utilidad de Amazon Neptune para GraphQL](tools-graphql.md)**: es una herramienta de línea de comandos de código abierto de Node.js que puede ayudarle a crear y mantener una API de [GraphQL](https://graphql.org/) para una base de datos de gráficos de propiedades de Neptune. Es una forma sin código de crear un solucionador de GraphQL para consultas de GraphQL que tienen un número variable de parámetros de entrada y devuelven un número variable de campos anidados. + **[Nodestream](tools-Nodestream.md)**: Nodestream es un marco para tratar el modelado semántico de datos como un gráfico. Se ha diseñado para ser flexible y extensible, de manera que permite definir la forma de recopilar y modelar los datos como un gráfico. Utiliza un enfoque basado en canalizaciones para determinar el modo en que se recopilan y procesan los datos, y establece una forma de definir cómo debe actualizarse el gráfico cuando cambia el esquema. + **[Servidores de consultas MCP de Amazon Neptune: servidor](https://github.com/aws-samples/amazon-neptune-generative-ai-samples/blob/main/neptune-mcp-servers/neptune-query/README.md)** de protocolo de contexto modelo (MCP) para Amazon Neptune que admite Neptune Database y Neptune Analytics, ya que permite ejecutar consultas de gráficos (OpenCypher y Gremlin) y obtener el esquema de gráficos. + **[Servidores de memoria MCP de Amazon Neptune: servidor](https://github.com/aws-samples/amazon-neptune-generative-ai-samples/blob/main/neptune-mcp-servers/neptune-memory/README.md)** modelo de protocolo de contexto (MCP) para Amazon Neptune que proporciona memoria a los agentes, almacenada en un gráfico de conocimiento frente a Amazon Neptune. # Utilidad de Amazon Neptune para GraphQL La utilidad de Amazon Neptune para [GraphQL](https://graphql.org/) es una herramienta de línea de comandos de código abierto de Node.js que puede ayudarle a crear y mantener una API de GraphQL para una base de datos de gráficos de propiedades de Neptune (aún no funciona con datos RDF). Es una forma sin código de crear un solucionador de GraphQL para consultas de GraphQL que tienen un número variable de parámetros de entrada y devuelven un número variable de campos anidados. Se ha publicado como un proyecto de código abierto ubicado en [https://github.com/aws/amazon-neptune-for-graphql](https://github.com/aws/amazon-neptune-for-graphql). Puede instalar la utilidad con NPM de la siguiente manera (consulte [Instalación y configuración](tools-graphql-setup.md) para obtener más información): ``` npm i @aws/neptune-for-graphql -g ``` La utilidad puede descubrir el esquema de gráfico de un gráfico de propiedades de Neptune existente, incluidos los nodos, los bordes, las propiedades y la cardinalidad de los bordes. A continuación, genera un esquema de GraphQL con las directivas necesarias para mapear los tipos de GraphQL a los nodos y los bordes de la base de datos, y genera automáticamente el código de resolución. El código de resolución se ha diseñado para minimizar la latencia al devolver solo los datos solicitados por la consulta de GraphQL. También puede empezar con un esquema de GraphQL existente y una base de datos de Neptune vacía, y dejar que la utilidad infiera las directivas necesarias para mapear ese esquema de GraphQL a los nodos y los bordes de los datos que se van a cargar en la base de datos. O bien, puede empezar con un esquema y directivas de GraphQL que ya haya creado o modificado. La utilidad es capaz de crear todos los AWS recursos que necesita para su canalización, incluida la AWS AppSync API, las funciones de IAM, la fuente de datos, el esquema y la resolución, y la función AWS Lambda que consulta Neptune. **nota** En los ejemplos de línea de comandos que se muestran aquí se supone que estamos utilizando una consola de Linux. Si utiliza Windows, sustituya las barras diagonales inversas (“\$1”) al final de las líneas por signos de intercalación (“^”). **Topics** + [Instalación y configuración de la utilidad de Amazon Neptune para GraphQL](tools-graphql-setup.md) + [Escaneo de datos en una base de datos de Neptune existente](tools-graphql-scan-existing.md) + [Partir de un esquema de GraphQL sin directivas](tools-graphql-start-from-schema.md) + [Trabajar con directivas para un esquema de GraphQL](tools-graphql-schema-with-directives.md) + [Argumentos de línea de comandos para la utilidad de GraphQL](tools-graphql-cmd-line-args.md) # Instalación y configuración de la utilidad de Amazon Neptune para GraphQL Si va a utilizar la utilidad con una base de datos de Neptune existente, necesitará que pueda conectarse al punto de conexión de la base de datos. De forma predeterminada, solo se puede acceder a una base de datos de Neptune desde la VPC en la que se encuentra. Como la utilidad es una herramienta de línea de comandos de Node.js, debe tener Node.js (versión 18 o posterior) instalado para que se ejecute la utilidad. Para instalar Node.js en una instancia de EC2 en la misma VPC que la base de datos de Neptune, siga las [instrucciones que aparecen aquí](https://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/setting-up-node-on-ec2-instance.html). La instancia de tamaño mínimo para ejecutar la utilidad es t2.micro. Durante la creación de la instancia, seleccione la VPC de la base de datos de Neptune en el menú desplegable **Grupos de seguridad comunes**. Para instalar la propia utilidad en una instancia de EC2 o en una máquina local, utilice NPM: ``` npm i @aws/neptune-for-graphql -g ``` A continuación, puede ejecutar el comando help de la utilidad para comprobar si se ha instalado correctamente: ``` neptune-for-graphql --help ``` Es posible que también desee [instalar el para administrar los recursos AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html). AWS # Escaneo de datos en una base de datos de Neptune existente Ya sea que esté familiarizado con GraphQL o no, el siguiente comando es la forma más rápida de crear una API de GraphQL. Esto supone que ha instalado y configurado la utilidad de Neptune para GraphQL tal y como se describe en la [sección de instalación](tools-graphql-setup.md), de forma que esté conectada al punto de conexión de la base de datos de 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 ``` La utilidad analiza la base de datos para detectar el esquema de los nodos, los bordes y las propiedades que incluye. En función de este esquema, infiere un esquema de GraphQL con consultas y mutaciones asociadas. A continuación, crea una API de AppSync GraphQL y los AWS recursos necesarios para utilizarla. Estos recursos incluyen un par de roles de IAM y una función de Lambda que incluye el código de resolución de GraphQL. Cuando la utilidad haya terminado, encontrarás una nueva API de GraphQL en la AppSync consola con el nombre que asignaste en el comando. Para probarla, usa la opción AppSync **Consultas** del menú. Si vuelve a ejecutar el mismo comando después de añadir más datos a la base de datos, actualizará la AppSync API y el código Lambda en consecuencia. Para liberar todos los recursos asociados con el comando, ejecute: ``` neptune-for-graphql \ --remove-aws-pipeline-name (your new GraphQL API name from above) ``` # Partir de un esquema de GraphQL sin directivas Puede partir de una base de datos de Neptune vacía y utilizar un esquema de GraphQL sin directivas para crear los datos y consultarlos. El siguiente comando crea automáticamente los recursos de AWS para hacer esto: ``` 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 ``` El archivo de esquema de GraphQL debe incluir los tipos de esquema de GraphQL, tal y como se muestra en el siguiente ejemplo de TODO. La utilidad analiza el esquema y crea una versión ampliada en función de los tipos. Añade consultas y mutaciones para los nodos almacenados en la base de datos de gráficos y, si el esquema tiene tipos anidados, añade relaciones entre los tipos almacenados como bordes en la base de datos. La utilidad crea una API de AppSync GraphQL y todos los AWS recursos necesarios. Estos recursos incluyen un par de roles de IAM y una función de Lambda que incluye el código de resolución de GraphQL. Cuando se complete el comando, encontrarás una nueva API de GraphQL con el nombre que especificaste en la AppSync consola. Para probarlo, usa **Queries** en el AppSync menú. En el siguiente ejemplo se muestra cómo funciona: ## Ejemplo de Todo, a partir de un esquema de GraphQL sin directivas En este ejemplo partimos de un esquema Todo GraphQL sin directivas, que se encuentra en el *???samples???* directorio. Incluye estos dos tipos: ``` type Todo { name: String description: String priority: Int status: String comments: [Comment] } type Comment { content: String } ``` Este comando procesa el esquema Todo y un punto final de una base de datos de Neptune vacía para crear una API GraphQL en: 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 ``` La utilidad crea un nuevo archivo en la carpeta de salida llamada `TodoExample.source.graphql` y la API GraphQL en. AppSync La utilidad infiere lo siguiente: + En el tipo Todo, se agregó `@relationship` un nuevo CommentEdge tipo. Esto indica al solucionador que conecte Todo a Comment mediante el borde de una base de datos de gráficos llamado CommentEdge. + Se agregó una nueva entrada llamada TodoInput para facilitar las consultas y las mutaciones. + Se añadieron dos consultas para cada tipo (Todo, Comment): una para recuperar un solo tipo mediante un `id` o cualquiera de los campos de tipo enumerados en la entrada, y la otra para recuperar varios valores, filtrados con la entrada de ese tipo. + Se añadió tres mutaciones para cada tipo: crear, actualizar y eliminar. El tipo que se va a eliminar se especifica mediante un `id` o la entrada correspondiente a ese tipo. Estas mutaciones afectan a los datos almacenados en la base de datos de Neptune. + Se añadieron dos mutaciones para las conexiones: conectar y eliminar. Toman como entrada los identificadores de los nodos de los vértices de origen y destino utilizados por Neptune y las conexiones son bordes en la base de datos. El solucionador reconoce las consultas y las mutaciones por sus nombres, pero puede personalizarlas, tal y como se muestra [a continuación](tools.md). Este es el contenido del archivo `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 } ``` Ahora puede crear y consultar datos. Esta es una instantánea de la consola AppSync **Queries** utilizada para probar la nueva API de GraphQL, denominada `TodoExampleAPI` en este caso. En la ventana central, el explorador muestra una lista de consultas y mutaciones entre las que puede seleccionar una consulta, los parámetros de entrada y los campos de devolución. En esta captura de pantalla se muestra la creación de un tipo de nodo Todo mediante la mutación `createNodeTodo`: ![\[Captura de pantalla que muestra la consola de AppSync Queries creando un nodo Todo\]](http://docs.aws.amazon.com/es_es/neptune/latest/userguide/images/todoCreate.png) En esta captura de pantalla se muestra la consulta de todos los nodos de Todo mediante la consulta `getNodeTodos`: ![\[Captura de pantalla que muestra la consola de AppSync Queries consultando los nodos de Todo\]](http://docs.aws.amazon.com/es_es/neptune/latest/userguide/images/todoGetTodos.png) Después de crear un comentario con `createNodeComment`, puede usar la mutación `connectNodeTodoToNodeCommentEdgeCommentEdge` para conectarlos especificando sus identificadores. Esta es una consulta anidada para recuperar Todos y sus comentarios adjuntos: ![\[Captura de pantalla que muestra una consulta anidada para recuperar Todos y sus comentarios adjuntos en la AppSync consola de Queries\]](http://docs.aws.amazon.com/es_es/neptune/latest/userguide/images/todoNestedQuery.png) Si desea realizar cambios en el archivo `TodoExample.source.graphql`, tal y como se describe en [Trabajar con directivas](tools-graphql-schema-with-directives.md), puede utilizar el esquema editado como entrada y volver a ejecutar la utilidad. A continuación, la utilidad modificará la API de GraphQL en consecuencia. # Trabajar con directivas para un esquema de GraphQL Puede partir de un esquema de GraphQL que ya tenga directivas y utilizar un comando como el siguiente: ``` 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 ``` Puede modificar las directivas que ha creado la utilidad o añadir sus propias directivas a un esquema de GraphQL. Estas son algunas de las formas de trabajar con las directivas: ## Ejecutar la utilidad para que no genere mutaciones Para evitar que la utilidad genere mutaciones en la API de GraphQL, utilice la opción `--output-schema-no-mutations` del comando `neptune-for-graphql`. ## La directiva `@alias` La directiva `@alias` se puede aplicar a campos o tipos de esquemas de GraphQL. Mapea diferentes nombres entre la base de datos de gráficos y el esquema de GraphQL. La sintaxis es la siguiente: ``` @alias(property: (property name)) ``` En el siguiente ejemplo, `airport` es la etiqueta del nodo de la base de datos de gráficos mapeada al tipo `Airport` de GraphQL y `desc` es la propiedad del nodo de gráficos mapeada al campo `description` (consulte el [ejemplo de rutas aéreas](tools-graphql.md)): ``` type Airport @alias(property: "airport") { city: String description: String @alias(property: "desc") } ``` Tenga en cuenta que el formato estándar de GraphQL requiere nombres del tipo PascalCase y nombres de campo del tipo CamelCase. ## La directiva `@relationship` La directiva `@relationship` mapea los tipos de GraphQL anidados a los bordes de las bases de datos de gráficos. La sintaxis es la siguiente: ``` @relationship(edgeType: (edge name), direction: (IN or OUT)) ``` A continuación se muestra un comando de ejemplo: ``` 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) } ``` Puede encontrar las directivas `@relationship` tanto en el [ejemplo de Todo](tools-graphql-start-from-schema.md#tools-graphql-todo-example) como en el [ejemplo de rutas aéreas](tools-graphql.md). ## Las directivas `@graphQuery` y `@cypher` Puede definir consultas de openCypher para resolver un valor de campo, añadir consultas o añadir mutaciones. Por ejemplo, esto añade un campo nuevo `outboundRoutesCount` al tipo `Airport` para contar las rutas de salida: ``` type Airport @alias(property: "airport") { ... outboundRoutesCount: Int @graphQuery(statement: "MATCH (this)-[r:route]->(a) RETURN count(r)") } ``` A continuación se muestra un ejemplo de nuevas consultas y mutaciones: ``` 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") } ``` Tenga en cuenta que si omite `RETURN`, el solucionador asume que la palabra clave `this` es el ámbito de devolución. También puede añadir una consulta o mutación mediante una consulta de 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 } ``` En este momento, las consultas de Gremlin se limitan a las que devuelven valores escalares, o `elementMap()` a un solo nodo o `elementMap().fold()` a una lista de nodos. ## La directiva `@id` La directiva `@id` identifica el campo mapeado a la entidad de la base de datos de gráficos `id`. Las bases de datos de gráficos como Amazon Neptune siempre tienen un único `id` para los nodos y los bordes que se asignan durante las importaciones masivas o que se generan automáticamente. Por ejemplo: ``` type Airport { _id: ID! @id city: String code: String } ``` ## Nombres reservados de tipos, consultas y mutaciones La utilidad genera automáticamente consultas y mutaciones para crear una API de GraphQL que funcione. El solucionador reconoce el patrón de estos nombres y lo reserva. Estos son algunos ejemplos del tipo `Airport` y del tipo de conexión `Route`: El tipo `Options` está reservado. ``` input Options { limit: Int } ``` Los parámetros de la función `filter` y `options` están reservados. ``` type Query { getNodeAirports(filter: AirportInput, options: Options): [Airport] } ``` El prefijo getNode de los nombres de consulta está reservado y los prefijos de los nombres de mutaciones como `createNode`, `updateNode`, `deleteNode`, `connectNode`, `deleteNode`, `updateEdge` y `deleteEdge` están reservados. ``` 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 } ``` ## Aplicación de cambios al esquema de GraphQL Puede modificar el esquema de origen de GraphQL y volver a ejecutar la utilidad, obteniendo el esquema más reciente de la base de datos de Neptune. Cada vez que la utilidad detecta un nuevo esquema en la base de datos, genera un nuevo esquema de GraphQL. También puede editar manualmente el esquema de origen de GraphQL y volver a ejecutar la utilidad con el esquema de origen como entrada en lugar del punto de conexión de la base de datos de Neptune. Por último, puede introducir los cambios en un archivo con este formato JSON: ``` [ { "type": "(GraphQL type name)", "field": "(GraphQL field name)", "action": "(remove or add)", "value": "(value)" } ] ``` Por ejemplo: ``` [ { "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": "" } ] ``` A continuación, al ejecutar la utilidad en este archivo con el parámetro `--input-schema-changes-file` del comando, la utilidad aplicará los cambios a la vez. # Argumentos de línea de comandos para la utilidad de GraphQL + **`--help, -h`**: devuelve el texto de ayuda de la utilidad de GraphQL a la consola.   + **`--input-schema (schema text)`**: un esquema de GraphQL, con o sin directivas, para usarlo como entrada.   + **`--input-schema-file (file URL)`**: la URL de un archivo que incluye un esquema de GraphQL para usarlo como entrada.   + **`--input-schema-changes-file (file URL)`**: la URL de un archivo que incluye los cambios que desea realizar en un esquema de GraphQL. Si ejecuta la utilidad en una base de datos de Neptune varias veces y también cambia manualmente el esquema de origen de GraphQL, tal vez si añade una consulta personalizada, se perderán los cambios manuales. Para evitarlo, introduzca los cambios en un archivo de cambios y páselo con este argumento. El archivo de cambios utiliza el siguiente formato JSON: ``` [ { "type": "(GraphQL type name)", "field": "(GraphQL field name)", "action": "(remove or add)", "value": "(value)" } ] ``` Consulte el [ejemplo de Todo](tools-graphql-start-from-schema.md#tools-graphql-todo-example) para obtener más información.   + **`--input-graphdb-schema (schema text)`**: en lugar de ejecutar la utilidad en una base de datos de Neptune, puede expresar un esquema de graphdb en formato escrito para usarlo como entrada. Un esquema de graphdb tiene un formato JSON como este: ``` { "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)`**: en lugar de ejecutar la utilidad en una base de datos de Neptune, puede guardar un esquema de graphdb en un archivo para usarlo como entrada. Consulte la opción anterior `--input-graphdb-schema` para ver un ejemplo del formato JSON para un archivo de esquema de graphdb.   + **`--input-graphdb-schema-neptune-endpoint (endpoint URL)`**: el punto de conexión de la base de datos de Neptune del que la utilidad debe extraer el esquema de graphdb.   + **`--output-schema-file (file name)`**: el nombre del archivo de salida del esquema de GraphQL. Si no se especifica, el valor predeterminado es `output.schema.graphql`, a menos que se haya establecido un nombre de canalización con `--create-update-aws-pipeline-name`, en cuyo caso, el nombre de archivo predeterminado es `(pipline name).schema.graphql`.   + **`--output-source-schema-file (file name)`**: el nombre del archivo de salida del esquema de GraphQL con directivas. Si no se especifica, el valor predeterminado es `output.source.schema.graphql`, a menos que se haya establecido un nombre de canalización con `--create-update-aws-pipeline-name`, en cuyo caso, el nombre predeterminado es `(pipeline name).source.schema.graphql`.   + **`--output-schema-no-mutations`**: si este argumento está presente, la utilidad no genera mutaciones en la API de GraphQL, solo consultas.   + **`--output-neptune-schema-file (file name)`**: el nombre del archivo de salida del esquema de graphdb de Neptune que detecta la utilidad. Si no se especifica, el valor predeterminado es `output.graphdb.json`, a menos que se haya establecido un nombre de canalización con `--create-update-aws-pipeline-name`, en cuyo caso, el nombre de archivo predeterminado es `(pipeline name).graphdb.json`.   + **`--output-js-resolver-file (file name)`**: el nombre del archivo de salida de una copia del código de resolución. Si no se especifica, el valor predeterminado es `output.resolver.graphql.js`, a menos que se haya establecido un nombre de canalización con `--create-update-aws-pipeline-name`, en cuyo caso, el nombre del archivo es `(pipeline name).resolver.graphql.js`. Este archivo está comprimido en el paquete de código cargado en la función de Lambda que ejecuta el solucionador.   + **`--output-resolver-query-sdk`**: este argumento especifica que la función de Lambda de la utilidad debe consultar Neptune mediante el SDK de datos de Neptune, que ha estado disponible a partir de la [versión 1.2.1.0.R5 del motor](engine-releases-1.2.1.0.R5.md) de Neptune (esta es la versión predeterminada). Sin embargo, si la utilidad detecta una versión anterior del motor de Neptune, sugiere utilizar en su lugar la opción HTTPS Lambda, que se puede invocar con el argumento `--output-resolver-query-https`.   + **`--output-resolver-query-https`**: este argumento especifica que la función de Lambda de la utilidad debe consultar a Neptune mediante la API de HTTPS de Neptune.   + **`--create-update-aws-pipeline`**— Este argumento desencadena la creación de los AWS recursos que debe utilizar la API GraphQL, incluida la API AppSync GraphQL y la Lambda que ejecuta el solucionador.   + **`--create-update-aws-pipeline-name (pipeline name)`**— Este argumento establece el nombre de la canalización, como la `pipeline-name` API AppSync o la `pipeline-name` función de la función Lambda. Si no se especifica un nombre, `--create-update-aws-pipeline` utiliza el nombre de la base de datos de `Neptune `. + **`--create-update-aws-pipeline-region (AWS region)`**— Este argumento establece la AWS región en la que se crea la canalización de la API GraphQL. Si no se especifica, la región predeterminada es `us-east-1` o la región en la que se encuentra la base de datos de Neptune, extraída del punto de conexión de la base de datos. + **`--create-update-aws-pipeline-neptune-endpoint (endpoint URL)`**: este argumento establece el punto de conexión de la base de datos de Neptune que utiliza la función de Lambda para consultar la base de datos. Si no se establece, se utiliza el punto de conexión establecido por `--input-graphdb-schema-neptune-endpoint`. + **`--remove-aws-pipeline-name (pipeline name)`**: este argumento elimina una canalización creada con `--create-update-aws-pipeline`. Los recursos que se van a eliminar se enumeran en un archivo denominado `(pipeline name).resources.json`. + **`--output-aws-pipeline-cdk`**— Este argumento desencadena la creación de un archivo CDK que se puede utilizar para crear AWS los recursos para la API GraphQL, incluida la API AppSync GraphQL y la función Lambda que ejecuta el solucionador. + **`--output-aws-pipeline-cdk-neptume-endpoint (endpoint URL)`**: este argumento establece el punto de conexión de la base de datos de Neptune que utiliza la función de Lambda para consultar la base de datos de Neptune. Si no se establece, se utiliza el punto de conexión establecido por `--input-graphdb-schema-neptune-endpoint`. + **`--output-aws-pipeline-cdk-name (pipeline name)`**— Este argumento establece el nombre de la canalización que deben utilizar la AppSync API y la función de nombre de canalización de Lambda. Si no se especifica, `--create-update-aws-pipeline` utiliza el nombre de la base de datos de Neptune. + **`--output-aws-pipeline-cdk-region (AWS region)`**— Establece la AWS región en la que se crea la canalización de la API GraphQL. Si no se especifica, se establece de forma predeterminada en `us-east-1` o la región en la que se encuentra la base de datos de Neptune, extraída del punto de conexión de la base de datos. + **`--output-aws-pipeline-cdk-file (file name)`**: esta opción establece el nombre del archivo CDK. Si no se establece, el valor predeterminado es `(pipeline name)-cdk.js`. # Nodestream [Nodestream](https://nodestream-proj.github.io/docs/docs/intro/) es un marco para tratar el modelado semántico de datos como un gráfico. Se ha diseñado para ser flexible y extensible, lo que permite definir la forma de recopilar y modelar los datos como un gráfico. Utiliza un enfoque basado en canalizaciones para determinar el modo en que se recopilan y procesan los datos, y establece una forma de definir cómo debe actualizarse el gráfico cuando cambia el esquema. Todo esto se hace mediante un archivo de configuración sencillo y legible en formato yaml. Para ello, Nodestream utiliza una serie de conceptos básicos, entre los que se incluyen canalizaciones, extractores, transformadores, filtros, intérpretes, interpretaciones y migraciones. A partir de [Nodestream 0.12](https://nodestream-proj.github.io/docs/blog/2024/04/05/nodestream-0-12/), Amazon Neptune es compatible tanto con [Neptune Database y Neptune Analytics](https://nodestream-proj.github.io/docs/docs/databases/neptune/). Consulte la documentación de Nodestream para obtener más información sobre cómo configurar y usar Nodestream con Neptune: [compatibilidad de Nodestream con Amazon Neptune](https://nodestream-proj.github.io/docs/docs/databases/neptune/). Nodestream con Neptune actualmente admite canalizaciones de ETL estándar, así como canalizaciones de tiempo de vida (TTL). Las canalizaciones de ETL permiten la ingesta masiva de datos en Neptune a partir de una gama mucho más amplia de orígenes y formatos de datos que la que era posible anteriormente en Neptune, entre los que se incluyen: + [Lista de materiales de software](https://nodestream-proj.github.io/docs/docs/official-plugins/sbom/) + [Archivos CSV, JSON, JSONL, Parquet, txt y yaml](https://nodestream-proj.github.io/docs/docs/reference/extractors/) + [Kafka](https://nodestream-proj.github.io/docs/docs/reference/extractors/#streamextractor) + [Athena](https://nodestream-proj.github.io/docs/docs/reference/extractors/#athenaextractor) + [API de REST](https://nodestream-proj.github.io/docs/docs/reference/extractors/#simpleapiextractor) Nodestream es totalmente compatible con la autenticación de IAM cuando se conecta a Amazon Neptune, siempre que las credenciales estén configuradas correctamente. Consulte la [guía de credenciales de boto3](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/credentials.html#configuring-credentials) para obtener más información sobre cómo configurar correctamente las credenciales. El [mecanismo de TTL de Nodestream](https://nodestream-proj.github.io/docs/docs/tutorials-intermediate/removing-data/) también habilita nuevas capacidades que antes no estaban disponibles en Neptune. Al anotar los elementos del gráfico ingeridos con marcas de tiempo, Nodestream puede crear canalizaciones que caducan automáticamente y eliminan los datos que hayan superado la vida útil configurada.