As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá. # Ferramentas e utilitários do Neptune O Amazon Neptune oferece várias ferramentas e utilitários que podem simplificar e automatizar o trabalho com um grafo. Estes são alguns exemplos: **Ferramentas do Amazon Neptune** + **[Utilitário do Amazon Neptune para GraphQL](tools-graphql.md)**: o utilitário do Amazon Neptune para GraphQL é uma ferramenta de linha de comando Node.js de código aberto que pode ajudar a criar e manter uma API [GraphQL](https://graphql.org/) para um banco de dados de grafos de propriedades do Neptune. É uma forma sem código de criar um resolvedor GraphQL para consultas do GraphQL que tenham um número variável de parâmetros de entrada e geram um número variável de campos aninhados. + **[Nodestream](tools-Nodestream.md)**: é uma estrutura para lidar com dados de modelagem semântica como grafos. Ele foi projetado para ser flexível e extensível, permitindo que você defina como os dados são coletados e modelados como um grafo. Ele usa uma abordagem baseada em pipeline para definir como os dados são coletados e processados e fornece uma maneira de definir como o grafo deve ser atualizado quando o esquema é alterado. + **[Amazon Neptune MCP Query](https://github.com/aws-samples/amazon-neptune-generative-ai-samples/blob/main/neptune-mcp-servers/neptune-query/README.md)** Servers — servidor Model Context Protocol (MCP) para Amazon Neptune que suporta o Neptune Database e o Neptune Analytics, fornecendo a capacidade de executar consultas gráficas (OpenCypher e Gremlin), bem como buscar o esquema gráfico. + Servidores de **[memória Amazon Neptune MCP](https://github.com/aws-samples/amazon-neptune-generative-ai-samples/blob/main/neptune-mcp-servers/neptune-memory/README.md)** — servidor Model Context Protocol (MCP) para o Amazon Neptune que fornece memória aos agentes, armazenada em um gráfico de conhecimento em relação ao Amazon Neptune. # Utilitário Amazon Neptune para GraphQL O utilitário Amazon Neptune para [GraphQL](https://graphql.org/) é uma ferramenta de linha de comando Node.js de código aberto que pode ajudar a criar e manter uma API GraphQL para um banco de dados de grafos de propriedades do Neptune (ele ainda não funciona com dados RDF). É uma forma sem código de criar um resolvedor GraphQL para consultas do GraphQL que tenham um número variável de parâmetros de entrada e geram um número variável de campos aninhados. Foi lançado como um projeto de código aberto localizado em [https://github.com/aws/amazon-neptune-for-graphql](https://github.com/aws/amazon-neptune-for-graphql). É possível instalar o utilitário usando o NPM desta forma (consulte [Instalação e configuração](tools-graphql-setup.md) para obter detalhes): ``` npm i @aws/neptune-for-graphql -g ``` O utilitário pode descobrir o esquema de grafos de um grafo de propriedades do Neptune existente, incluindo nós, bordas, propriedades e cardinalidade de bordas. Depois, ele gera um esquema GraphQL com as diretivas necessárias para associar os tipos do GraphQL aos nós e às bordas do banco de dados, além de gerar automaticamente o código do resolvedor. O código do resolvedor foi projetado para minimizar a latência gerando somente os dados solicitados pela consulta do GraphQL. Você também pode começar com um esquema do GraphQL existente e um banco de dados Neptune vazio e deixar que o utilitário deduza as diretivas necessárias para associar esse esquema do GraphQL aos nós e às bordas dos dados a serem carregados no banco de dados. Ou você pode começar com um esquema e diretivas do GraphQL que você já criou ou modificou. O utilitário é capaz de criar todos os AWS recursos necessários para seu pipeline, incluindo a AWS AppSync API, as funções do IAM, a fonte de dados, o esquema e o resolvedor, além da função AWS Lambda que consulta Neptune. **nota** Os exemplos de linha de comando aqui pressupõem um console do Linux. Se você estiver usando o Windows, substitua as barras invertidas (“\$1”) no final das linhas por acentos circunflexos (“^”). **Topics** + [Instalar e configurar o utilitário Amazon Neptune para GraphQL](tools-graphql-setup.md) + [Verificar dados em um banco de dados Neptune existente](tools-graphql-scan-existing.md) + [Iniciar com um esquema GraphQL sem diretivas](tools-graphql-start-from-schema.md) + [Trabalhar com diretivas para um esquema do GraphQL](tools-graphql-schema-with-directives.md) + [Argumentos de linha de comando para o utilitário GraphQL](tools-graphql-cmd-line-args.md) # Instalar e configurar o utilitário Amazon Neptune para GraphQL Se você for usar o utilitário com um banco de dados Neptune existente, precisará que ele possa se conectar ao endpoint do banco de dados. Por padrão, um banco de dados Neptune só pode ser acessado de dentro da VPC em que está localizado. Como o utilitário é uma ferramenta de linha de comando do Node.js, você deve ter o Node.js (versão 18 ou superior) instalado para que o utilitário seja executado. Para instalar o Node.js em uma instância do EC2 na mesma VPC do banco de dados Neptune, siga as [instruções aqui](https://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/setting-up-node-on-ec2-instance.html). O tamanho mínimo da instância para executar o utilitário é t2.micro. Durante a criação da instância, selecione a VPC do banco de dados Neptune no menu suspenso **Grupos de segurança comuns**. Para instalar o utilitário em uma instância do EC2 ou na máquina local, use o NPM: ``` npm i @aws/neptune-for-graphql -g ``` Depois, você pode executar o comando help do utilitário para conferir se ele foi instalado corretamente: ``` neptune-for-graphql --help ``` Talvez você também queira [instalar o AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) para gerenciar AWS recursos. # Verificar dados em um banco de dados Neptune existente Você conheça ou não o GraphQL, o comando abaixo é a maneira mais rápida de criar uma API do GraphQL. Isso pressupõe que você tenha instalado e configurado o utilitário Neptune para GraphQL conforme descrito na [seção de instalação](tools-graphql-setup.md), para que ele esteja conectado ao endpoint do banco de dados 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 ``` O utilitário analisa o banco de dados para descobrir o esquema dos nós, das bordas e das propriedades nele. Com base nesse esquema, ele infere um esquema GraphQL com consultas e mutações associadas. Em seguida, ele cria uma API AppSync GraphQL e os AWS recursos necessários para usá-la. Esses recursos incluem dois perfis do IAM e uma função do Lambda contendo o código do resolvedor GraphQL. Quando o utilitário terminar, você encontrará uma nova API do GraphQL no AppSync console com o nome que você atribuiu no comando. Para testá-lo, use a opção AppSync **Consultas** no menu. Se você executar o mesmo comando novamente após adicionar mais dados ao banco de dados, atualizará a AppSync API e o código Lambda adequadamente. Para liberar todos os recursos associados ao comando, execute: ``` neptune-for-graphql \ --remove-aws-pipeline-name (your new GraphQL API name from above) ``` # Iniciar com um esquema GraphQL sem diretivas Você pode começar com um banco de dados Neptune vazio e usar um esquema GraphQL sem diretivas para criar os dados e consultá-los. O comando abaixo cria automaticamente recursos AWS para fazer o seguinte: ``` 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 ``` O arquivo do esquema GraphQL deve incluir os tipos de esquema GraphQL, conforme mostrado no exemplo TODO abaixo. O utilitário analisa seu esquema e cria uma versão estendida com base em seus tipos. Ele adiciona consultas e mutações para os nós armazenados no banco de dados de grafos e, se seu esquema tiver tipos aninhados, ele adicionará relacionamentos entre os tipos armazenados como bordas no banco de dados. O utilitário cria uma API AppSync GraphQL e todos os AWS recursos necessários. Eles incluem dois perfis do IAM e uma função do Lambda contendo o código do resolvedor GraphQL. Quando o comando for concluído, você poderá encontrar uma nova API do GraphQL com o nome especificado no AppSync console. Para testá-lo, use **Consultas** no AppSync menu. O exemplo a seguir ilustra como isso funciona: ## Exemplo de Todo, partindo de um esquema GraphQL sem diretivas Neste exemplo, partimos de um esquema Todo GraphQL sem diretivas, que você pode encontrar no diretório. *???samples???* Ele inclui estes dois tipos: ``` type Todo { name: String description: String priority: Int status: String comments: [Comment] } type Comment { content: String } ``` Esse comando processa o esquema Todo e um endpoint de um banco de dados Neptune vazio para criar uma API GraphQL em: 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 ``` O utilitário cria um novo arquivo na pasta de saída chamada`TodoExample.source.graphql`, e a API GraphQL em. AppSync O utilitário infere o seguinte: + No tipo Todo, ele adicionou `@relationship` um novo CommentEdge tipo. Isso instrui o resolvedor a conectar Todo ao Comment usando uma borda de banco de dados gráfica chamada CommentEdge. + Ele adicionou uma nova entrada chamada TodoInput para ajudar nas consultas e mutações. + Ele adicionou duas consultas para cada tipo (Todo, Comment): uma para recuperar um único tipo usando um `id` ou qualquer um dos campos de tipo listados na entrada e outra para recuperar vários valores, filtrados usando a entrada desse tipo. + Ele adicionou três mutações para cada tipo: criar, atualizar e excluir. O tipo a ser excluído é especificado usando um `id` ou a entrada desse tipo. Essas mutações afetam os dados armazenados no banco de dados Neptune. + Ele adicionou duas mutações para conexões: conectar e excluir. Eles tomam como entrada os IDs dos nós entre os vértices usados pelo Neptune e a conexão são bordas no banco de dados. O resolvedor reconhece as consultas e as mutações pelos nomes, mas você pode personalizá-las conforme mostrado [abaixo](tools.md). Aqui está o conteúdo do arquivo `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 } ``` Agora você pode criar e consultar dados. Aqui está um instantâneo do console de AppSync **consultas** usado para testar a nova API GraphQL, nomeada `TodoExampleAPI` neste caso. Na janela central, o Explorador mostra uma lista de consultas e mutações das quais você pode escolher uma consulta, os parâmetros de entrada e os campos de retorno. Esta captura de tela mostra a criação de um tipo de nó Todo usando a mutação `createNodeTodo`: ![\[Captura de tela mostrando o console de AppSync consultas criando um nó Todo\]](http://docs.aws.amazon.com/pt_br/neptune/latest/userguide/images/todoCreate.png) Esta captura de tela mostra a consulta de todos os nós Todo usando a consulta `getNodeTodos`: ![\[Captura de tela mostrando o console de AppSync consultas consultando nós Todo\]](http://docs.aws.amazon.com/pt_br/neptune/latest/userguide/images/todoGetTodos.png) Depois de criar um comentário usando `createNodeComment`, você pode usar mutação `connectNodeTodoToNodeCommentEdgeCommentEdge` para conectá-los especificando seus IDs. Aqui está uma consulta aninhada para recuperar Todos e seus comentários anexados: ![\[Captura de tela mostrando uma consulta aninhada para recuperar Todos e seus comentários anexados no console de consultas AppSync\]](http://docs.aws.amazon.com/pt_br/neptune/latest/userguide/images/todoNestedQuery.png) Se quiser fazer alterações no arquivo `TodoExample.source.graphql` conforme descrito em [Trabalhar com diretivas](tools-graphql-schema-with-directives.md), você poderá usar o esquema editado como entrada e executar o utilitário novamente. O utilitário então modificará a API GraphQL adequadamente. # Trabalhar com diretivas para um esquema do GraphQL É possível partir de um esquema do GraphQL que já tenha diretivas, usando um comando como o seguinte: ``` 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 ``` Você pode modificar as diretivas que o utilitário criou ou adicionar as próprias diretivas a um esquema do GraphQL. Aqui estão algumas maneiras de trabalhar com diretivas: ## Executar o utilitário para que ele não gere mutações Para evitar que o utilitário gere mutações na API do GraphQL, use a opção `--output-schema-no-mutations` no comando `neptune-for-graphql`. ## A diretiva `@alias` A diretiva `@alias` pode ser aplicada aos tipos ou aos campos do esquema do GraphQL. Ele associa nomes diferentes entre o banco de dados de grafos e o esquema do GraphQL. A sintaxe é: ``` @alias(property: (property name)) ``` No exemplo abaixo, `airport` é o rótulo do nó do banco de dados de grafos associado ao tipo `Airport` do GraphQL e `desc` é a propriedade do nó gráfico associada ao campo `description` (veja o [Exemplo de rotas aéreas](tools-graphql.md)): ``` type Airport @alias(property: "airport") { city: String description: String @alias(property: "desc") } ``` Observe que a formatação padrão do GraphQL exige nomes de tipo Pascal-casing e nomes de campo camel-casing. ## A diretiva `@relationship` A diretiva `@relationship` associa tipos de GraphQL a bordas do banco de dados de grafos. A sintaxe é: ``` @relationship(edgeType: (edge name), direction: (IN or OUT)) ``` Veja a seguir um exemplo de 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) } ``` Você pode encontrar diretivas `@relationship` no [Exemplo de Todo](tools-graphql-start-from-schema.md#tools-graphql-todo-example) e no [Exemplo de rotas aéreas](tools-graphql.md). ## As diretivas `@graphQuery` e `@cypher` É possível definir consultas do openCypher para resolver um valor de campo, bem como adicionar consultas ou mutações. Por exemplo, isso adiciona um novo campo `outboundRoutesCount` ao tipo `Airport` para contar as rotas de saída: ``` type Airport @alias(property: "airport") { ... outboundRoutesCount: Int @graphQuery(statement: "MATCH (this)-[r:route]->(a) RETURN count(r)") } ``` Aqui está um exemplo de novas consultas e mutações: ``` 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") } ``` Observe que, se você omitir o `RETURN`, o resolvedor assumirá que a palavra-chave `this` é o escopo de retorno. Você também pode adicionar uma consulta ou uma mutação usando uma consulta do 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 } ``` No momento, as consultas do Gremlin são limitadas às que geram valores escalares, ou `elementMap()` para um único nó, ou `elementMap().fold()` para uma lista de nós. ## A diretiva `@id` A diretiva `@id` identifica o campo associada à entidade do banco de dados `id` de grafos. Bancos de dados de grafos, como o Amazon Neptune, sempre têm um `id` exclusivo para nós e bordas que é atribuído durante importações em massa ou gerado automaticamente. Por exemplo: ``` type Airport { _id: ID! @id city: String code: String } ``` ## Nomes reservados de tipo, consulta e mutação O utilitário gera automaticamente consultas e mutações para criar uma API do GraphQL funcional. O padrão desses nomes é reconhecido pelo resolvedor e é reservado. Aqui estão alguns exemplos do tipo `Airport` e do tipo de conexão `Route`: O tipo `Options` é reservado. ``` input Options { limit: Int } ``` Os parâmetros de função `filter` e `options` são reservados. ``` type Query { getNodeAirports(filter: AirportInput, options: Options): [Airport] } ``` O prefixo getNode dos nomes das consultas é reservado, e os prefixos de nomes de mutações, como `createNode`, `updateNode`, `deleteNode`, `connectNode`, `deleteNode`, `updateEdge` e `deleteEdge` são 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 } ``` ## Aplicar alterações ao esquema do GraphQL É possível modificar o esquema de origem do GraphQL e executar o utilitário novamente, obtendo o esquema mais recente do seu banco de dados Neptune. Toda vez que o utilitário descobre um novo esquema no banco de dados, ele gera um novo esquema do GraphQL. Você também pode editar manualmente o esquema de origem do GraphQL e executar o utilitário novamente usando o esquema de origem como entrada em vez do endpoint do banco de dados Neptune. Por fim, é possível colocar suas alterações em um arquivo usando este formato JSON: ``` [ { "type": "(GraphQL type name)", "field": "(GraphQL field name)", "action": "(remove or add)", "value": "(value)" } ] ``` Por exemplo: ``` [ { "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": "" } ] ``` Depois, ao executar o utilitário nesse arquivo usando o parâmetro `--input-schema-changes-file` no comando, o utilitário aplica suas alterações de uma só vez. # Argumentos de linha de comando para o utilitário GraphQL + **`--help, -h`**: gera o texto de ajuda do utilitário GraphQL para o console.   + **`--input-schema (schema text)`**: um esquema do GraphQL, com ou sem diretivas, para usar como entrada.   + **`--input-schema-file (file URL)`**: o URL de um arquivo que contém um esquema do GraphQL para usar como entrada.   + **`--input-schema-changes-file (file URL)`**: o URL de um arquivo que contém as alterações que você deseja fazer em um esquema do GraphQL. Se você executar o utilitário em um banco de dados Neptune várias vezes e também alterar manualmente o esquema de origem do GraphQL, talvez adicionando uma consulta personalizada, suas alterações manuais serão perdidas. Para evitar isso, coloque suas alterações em um arquivo de alterações e passe-o usando esse argumento. O arquivo de alterações requer o seguinte formato JSON: ``` [ { "type": "(GraphQL type name)", "field": "(GraphQL field name)", "action": "(remove or add)", "value": "(value)" } ] ``` Para obter mais informações, consulte o [Exemplo de Todo](tools-graphql-start-from-schema.md#tools-graphql-todo-example).   + **`--input-graphdb-schema (schema text)`**: em vez de executar o utilitário em um banco de dados Neptune, você pode expressar um esquema graphdb em formato de texto para usar como entrada. Um esquema graphdb tem um 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)`**: em vez de executar o utilitário em um banco de dados Neptune, você pode expressar um esquema graphdb em um texto para usar como entrada. Consulte `--input-graphdb-schema` acima para obter um exemplo do formato JSON para um arquivo de esquema graphdb.   + **`--input-graphdb-schema-neptune-endpoint (endpoint URL)`**: o enpoint do banco de dados Neptune do qual o utilitário deve extrair o esquema graphdb.   + **`--output-schema-file (file name)`**: o nome do arquivo de saída para o esquema GraphQL. Se não for especificado, o padrão será `output.schema.graphql`, a menos que um nome de pipeline tenha sido definido usando `--create-update-aws-pipeline-name`. Nesse caso, o nome do arquivo padrão será `(pipline name).schema.graphql`.   + **`--output-source-schema-file (file name)`**: o nome do arquivo de saída para o esquema do GraphQL com diretivas. Se não for especificado, o padrão será `output.source.schema.graphql`, a menos que um nome de pipeline tenha sido definido usando `--create-update-aws-pipeline-name`. Nesse caso, o nome padrão será `(pipeline name).source.schema.graphql`.   + **`--output-schema-no-mutations`**: se esse argumento estiver presente, o utilitário não vai gerar mutações na API do GraphQL, apenas consultas.   + **`--output-neptune-schema-file (file name)`**: o nome do arquivo de saída do esquema graphdb do Neptune descoberto pelo utilitário. Se não for especificado, o padrão será `output.graphdb.json`, a menos que um nome de pipeline tenha sido definido usando `--create-update-aws-pipeline-name`. Nesse caso, o nome do arquivo padrão será `(pipeline name).graphdb.json`.   + **`--output-js-resolver-file (file name)`**: o nome do arquivo de saída para uma cópia do código do resolvedor. Se não for especificado, o padrão será `output.resolver.graphql.js`, a menos que um nome de pipeline tenha sido definido usando `--create-update-aws-pipeline-name`. Nesse caso, o nome do arquivo será `(pipeline name).resolver.graphql.js`. Esse arquivo é compactado no pacote de código carregado na função do Lambda que executa o resolvedor.   + **`--output-resolver-query-sdk`**: esse argumento especifica que a função do Lambda do utilitário deve consultar o Neptune usando o SDK de dados do Neptune, que está disponível a partir da [versão 1.2.1.0.R5 do mecanismo](engine-releases-1.2.1.0.R5.md) do Neptune (esse é o padrão). No entanto, se o utilitário detectar uma versão mais antiga do mecanismo do Neptune, ele vai sugerir o uso da opção HTTPS do Lambda, que você pode invocar usando o argumento `--output-resolver-query-https`.   + **`--output-resolver-query-https`**: esse argumento especifica que a função do Lambda do utilitário deve consultar o Neptune usando a API HTTPS do Neptune.   + **`--create-update-aws-pipeline`**— Esse argumento aciona a criação dos AWS recursos para uso da API GraphQL, incluindo a API GraphQL e o Lambda que AppSync executa o resolvedor.   + **`--create-update-aws-pipeline-name (pipeline name)`**— Esse argumento define o nome do pipeline, como a `pipeline-name` API AppSync ou a `pipeline-name` função da função Lambda. Se um nome não for especificado, `--create-update-aws-pipeline` usará o nome do banco de dados `Neptune `. + **`--create-update-aws-pipeline-region (AWS region)`**— Esse argumento define a AWS região na qual o pipeline da API GraphQL é criado. Se não for especificada, a região padrão será `us-east-1` ou a região em que o banco de dados Neptune está localizado, extraída do endpoint do banco de dados. + **`--create-update-aws-pipeline-neptune-endpoint (endpoint URL)`**: esse argumento define o endpoint do banco de dados Neptune usado pela função do Lambda para consultar o banco de dados. Se não for definido, o endpoint definido por `--input-graphdb-schema-neptune-endpoint` será usado. + **`--remove-aws-pipeline-name (pipeline name)`**: esse argumento remove um pipeline criado usando `--create-update-aws-pipeline`. Os recursos a serem removidos estão listados em um arquivo chamado `(pipeline name).resources.json`. + **`--output-aws-pipeline-cdk`**— Esse argumento aciona a criação de um arquivo CDK que pode ser usado para criar os AWS recursos para a API GraphQL, incluindo a AppSync API GraphQL e a função Lambda que executa o resolvedor. + **`--output-aws-pipeline-cdk-neptume-endpoint (endpoint URL)`**: esse argumento define o endpoint do banco de dados Neptune usado pela função do Lambda para consultar o banco de dados Neptune. Se não for definido, o endpoint definido por `--input-graphdb-schema-neptune-endpoint` será usado. + **`--output-aws-pipeline-cdk-name (pipeline name)`**— Esse argumento define o nome do pipeline para a AppSync API e a função Lambda pipeline-name a serem usados. Se não for especificado, `--create-update-aws-pipeline` usará o nome do banco de dados Neptune. + **`--output-aws-pipeline-cdk-region (AWS region)`**— Isso define a AWS região na qual o pipeline da API GraphQL é criado. Se não for especificada, o padrão será `us-east-1` ou a região em que o banco de dados Neptune está localizado, extraída do endpoint do banco de dados. + **`--output-aws-pipeline-cdk-file (file name)`**: isso define o nome do arquivo CDK. Se não estiver definido, o padrão será `(pipeline name)-cdk.js`. # Nodestream O [Nodestream](https://nodestream-proj.github.io/docs/docs/intro/) é uma estrutura para lidar com dados de modelagem semântica como grafos. Ele foi projetado para ser flexível e extensível, permitindo que você defina como os dados são coletados e modelados como um grafo. Ele usa uma abordagem baseada em pipeline para definir como os dados são coletados e processados e fornece uma maneira de definir como o grafo deve ser atualizado quando o esquema é alterado. Tudo isso é feito usando um arquivo de configuração simples e legível por humanos no formato yaml. Para fazer isso, o Nodestream usa vários conceitos básicos, incluindo pipelines, extratores, transformadores, filtros, intérpretes, interpretações e migrações. A partir do [Nodestream 0.12](https://nodestream-proj.github.io/docs/blog/2024/04/05/nodestream-0-12/), o Amazon Neptune é compatível tanto com o [banco de dados do Neptune quanto com o Neptune Analytics](https://nodestream-proj.github.io/docs/docs/databases/neptune/). Consulte a documentação do Nodestream para obter detalhes sobre como configurar e usar o Nodestream com o Neptune: [Nodestream support for Amazon Neptune](https://nodestream-proj.github.io/docs/docs/databases/neptune/). Atualmente, o Nodestream com Neptune é compatível com pipelines de ETL padrão, bem como pipelines de tempo de vida (TTL). Os pipelines de ETL permitem a ingestão de dados em massa no Neptune a partir de uma variedade muito mais ampla de formatos e fontes de dados do que era possível anteriormente no Neptune, incluindo: + [Lista de materiais de software](https://nodestream-proj.github.io/docs/docs/official-plugins/sbom/) + [Arquivos incluindo CSV, JSON, JSONL, Parquet, txt e 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) + [APIs REST](https://nodestream-proj.github.io/docs/docs/reference/extractors/#simpleapiextractor) O Nodestream oferece suporte total à autenticação do IAM ao se conectar ao Amazon Neptune, desde que as credenciais estejam configuradas corretamente. Consulte o [guia de credenciais do boto3](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/credentials.html#configuring-credentials) para obter mais informações sobre como configurar corretamente as credenciais. O [mecanismo TTL do Nodestream](https://nodestream-proj.github.io/docs/docs/tutorials-intermediate/removing-data/) também habilita novos recursos que não estavam disponíveis anteriormente no Neptune. Ao anotar elementos de grafos ingeridos com carimbos de data/hora, o Nodestream pode criar pipelines que expiram automaticamente e remover dados que tenham passado por uma vida útil configurada.