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á. # Práticas recomendadas gerais para usar o Gremlin com o Neptune Siga estas recomendações ao usar a linguagem de percurso de grafos Gremlin com o Neptune. Para obter informações sobre como usar o Gremlin com Neptune, consulte [Acessar o grafo do Neptune com o Gremlin](access-graph-gremlin.md). **Importante** Foi feita uma alteração na TinkerPop versão 3.4.11 que melhora a exatidão de como as consultas são processadas, mas, no momento, às vezes pode afetar seriamente o desempenho das consultas. Por exemplo, uma consulta desse tipo pode apresentar uma lentidão significativa: ``` g.V().hasLabel('airport'). order(). by(out().count(),desc). limit(10). out() ``` Os vértices após a etapa limite agora são buscados de uma forma não ideal devido à alteração 3.4.11. TinkerPop Para evitar isso, é possível modificar a consulta adicionando a etapa barrier() a qualquer momento após `order().by()`. Por exemplo: ``` g.V().hasLabel('airport'). order(). by(out().count(),desc). limit(10). barrier(). out() ``` TinkerPop [3.4.11 foi habilitado na versão 1.0.5.0 do motor Neptune.](engine-releases-1.0.5.0.md) **Topics** + [Configuração Heartbeat para Neptune Serverless](best-practices-gremlin-heartbeat-serverless.md) + [Estruturar consultas de upsert para aproveitar as vantagens do mecanismo do DFE](#best-practices-gremlin-upserts) + [Testar o código do Gremlin no contexto em que você o implantará](best-practices-gremlin-console-glv-differences.md) + [Criação de gravações eficientes com multi-thread do Gremlin](best-practices-gremlin-multithreaded-writes.md) + [Redução de registros com o Creation Time Property](best-practices-gremlin-prune.md) + [Ao usar o método `datetime( )` para o Groovy Time Data](best-practices-gremlin-datetime.md) + [Uso da data e hora nativas para dados de data GLV](best-practices-gremlin-datetime-glv.md) # Configuração Heartbeat para Neptune Serverless Ao usar WebSocket clientes Gremlin com o Neptune Serverless, você precisa configurar o intervalo de ping do cliente de forma adequada para manter conexões estáveis durante eventos de escalabilidade. O cliente Gremlin usa WebSocket conexões e envia pings periódicos para verificar se a conexão está ativa. O cliente espera uma resposta do servidor dentro do intervalo de ping. Se o servidor não responder, o cliente fechará automaticamente a conexão. **Para instâncias provisionadas pelo **Neptune**, recomendamos definir o intervalo de ping para 5 segundos.** Para clusters **Neptune Serverless**, recomendamos definir o intervalo de ping para **pelo menos 20** segundos para acomodar possíveis atrasos durante as operações de escalabilidade. Esse parâmetro controla quanto tempo o cliente espera entre as gravações no servidor antes de enviar um ping para verificar se a conexão ainda está ativa. A configuração desse parâmetro varia de acordo com a implementação do cliente: **Configuração do cliente Java** Para o cliente Java TinkerPop Gremlin, configure o `keepAliveInterval` parâmetro: ``` Cluster.Builder builder = Cluster.build() .addContactPoint(endpoint) .keepAliveInterval(20000); // Configure ping interval in milliseconds ``` Para obter mais detalhes sobre a configuração do driver Java, consulte a [ TinkerPop documentação do Java](https://tinkerpop.apache.org/docs/current/reference/#gremlin-java-configuration). **Configuração do Go Client** Para o cliente Gremlin Go, configure o `KeepAliveInterval` parâmetro: ``` rc, err := driver.NewDriverRemoteConnection(endpoint, func(settings *driver.DriverRemoteConnectionSettings) { settings.TraversalSource = "g" settings.AuthInfo = auth settings.KeepAliveInterval = 20 * time.Second // Configure ping interval ... }) ``` Para obter mais detalhes sobre a configuração do driver Go, consulte a [ TinkerPop documentação do Go](https://tinkerpop.apache.org/docs/current/reference/#gremlin-go-configuration). **JavaScriptConfiguração do cliente /Node.js** Para o cliente Gremlin JavaScript /Node.js, configure o `pingInterval` parâmetro: ``` const gremlin = require('gremlin'); const DriverRemoteConnection = gremlin.driver.DriverRemoteConnection; const connection = new DriverRemoteConnection(endpoint, { traversalSource: 'g', pingInterval: 20000 // Configure ping interval in milliseconds }); ``` Para obter mais detalhes sobre a configuração do JavaScript driver, consulte a [JavaScript TinkerPop documentação](https://tinkerpop.apache.org/docs/current/reference/#gremlin-javascript-configuration). **Configuração do cliente Python** Para o cliente Python Gremlin, o intervalo de ping normalmente é gerenciado na camada de transporte. Consulte a documentação específica de implementação de transporte para ver as opções de configuração: ``` from gremlin_python.driver.driver_remote_connection import DriverRemoteConnection g = traversal().with_remote( DriverRemoteConnection('wss://your-neptune-endpoint:your-neptune-port/gremlin','g', transport_factory=lambda: AiohttpTransport(read_timeout=60, write_timeout=20, heartbeat=20, // Configure heartbeat call_from_event_loop=True, max_content_length=100*1024*1024, ssl_options=ssl.create_default_context(Purpose.CLIENT_AUTH)))) ``` [Para obter mais detalhes sobre a configuração do driver do Python, consulte a documentação do Python. TinkerPop ](https://tinkerpop.apache.org/docs/current/reference/#gremlin-python-configuration) Essa configuração garante que seu cliente mantenha a estabilidade da conexão durante os eventos de escalabilidade do Neptune Serverless, evitando fechamentos de conexão desnecessários e melhorando a confiabilidade do aplicativo. ## Estruturar consultas de upsert para aproveitar as vantagens do mecanismo do DFE [Criar surtos eficientes com as etapas `mergeV()` e `mergeE()` do Gremlin.](gremlin-efficient-upserts.md) explica como estruturar consultas de upsert para usar o mecanismo do DFE da forma mais eficaz possível. # Testar o código do Gremlin no contexto em que você o implantará No Gremlin, há várias maneiras de os clientes enviarem consultas ao servidor: usando WebSocket o Bytecode GLV ou por meio do console do Gremlin usando scripts baseados em strings. É importante reconhecer que a execução da consulta do Gremlin pode ser diferente dependendo de como você envia a consulta. Uma consulta que gere um resultado vazio pode ser tratada como bem-sucedida se enviada no modo Bytecode, mas com falha se enviada no modo script. Por exemplo, se você incluir `next()` em uma consulta no modo script, ela será enviada para `next()` o servidor, mas o uso do cliente geralmente ByteCode processa a consulta por si só. `next()` No primeiro caso, a consulta falhará se nenhum resultado for encontrado, mas no segundo, a consulta será bem-sucedida independentemente de o conjunto de resultados estar vazio ou não. Se você desenvolver e testar o código em um contexto (por exemplo, o console do Gremlin, que geralmente envia consultas em formato de texto), mas depois implanta o código em um contexto diferente (por exemplo, por meio do driver do Java usando Bytecode), você pode ter problemas com o código apresentando comportamentos diferentes na produção e no ambiente de desenvolvimento. **Importante** Teste o código do Gremlin no contexto do GLV em que ele será implantado, para evitar resultados inesperados. # Criação de gravações eficientes com multi-thread do Gremlin Há algumas diretrizes para carregamento de dados com multi-thread para o Neptune usando o Gremlin. Se possível, atribua a cada thread um conjunto de vértices ou bordas a serem inseridos ou modificados que não colidam. Por exemplo, o thread abrange o intervalo de IDs de 1 a 50.000, o thread 2 abrange o intervalo de IDs de 50.001 a 100.000, etc. Isso reduz a chance de atingir uma `ConcurrentModificationException`. Para melhor segurança, coloque um bloco `try/catch` em torno de todas as gravações. Se ocorrer uma falha em qualquer uma delas, você poderá repeti-las depois de um breve atraso. O agrupamento de gravações em lotes de 50 a 100 (vértices ou bordas) geralmente funciona bem. Se você tiver uma grande quantidade de propriedades sendo adicionadas para cada vértice, um número mais próximo de 50 do que de 100 poderá ser a melhor opção. Alguma experimentação é útil. Portanto, para gravações em lote, você pode usar algo como o seguinte: ``` g.addV(‘test’).property(id,’1’).as(‘a’). addV(‘test’).property(id,’2’). addE(‘friend’).to(‘a’). ``` Isso é, então, repetido em cada operação em lote. O uso de lotes é significativamente mais eficiente do que a adição de um vértice ou borda por Gremlin de ida e volta para o servidor. Se você estiver usando um cliente de Variante da linguagem Gremlin (GLV), crie um lote de forma programática primeiro criando uma travessia. Em seguida, adicione a ele e, por fim, itere sobre ele; por exemplo: ``` t.addV(‘test’).property(id,’1’).as(‘a’) t.addV(‘test’).property(id,’2’) t.addE(‘friend’).to(‘a’) t.iterate() ``` É melhor usar o cliente da variante de linguagem do Gremlin, se possível. No entanto, você pode fazer algo parecido com um cliente que envia consultas como strings de texto concatenando as strings para criar um lote. Se você estiver usando uma das bibliotecas do cliente de Gremlin em vez de HTTP básico para consultas, os threads deverão compartilhar o mesmo cliente, cluster ou grupo de conexões. Pode ser necessário ajustar as configurações para obter o melhor throughput possível, configurações como o tamanho do grupo de conexões e o número de threads de operador que o cliente do Gremlin usa. # Redução de registros com o Creation Time Property É possível remover os registros de tabela ao armazenar a hora de criação como uma propriedade em vértices e removê-los periodicamente. Caso precise armazenar dados para uma vida útil específica e então removê-la do gráfico (tempo de vida do vértice), você pode armazenar uma propriedade time stamp na criação do vértice. Em seguida, você pode periodicamente emitir uma consulta do `drop()` para todos os vértices que foram criados antes de um certo período, por exemplo: ``` g.V().has(“timestamp”, lt(datetime('2018-10-11'))) ``` # Ao usar o método `datetime( )` para o Groovy Time Data O Neptune oferece o método `datetime` para especificar datas e horas para consultas enviadas na variante Gremlin **Groovy**. Isso inclui o Gremlin Console, strings de texto usando a API REST HTTP, e qualquer outra serialização que usa o Groovy. **Importante** Isso se aplica *somente* a métodos onde você envia a consulta Gremlin como uma *string de texto*. Se você estiver usando uma Variante da Linguagem Gremlin, deverá usar as classes e funções de data nativa para o idioma. Para obter mais informações, consulte a próxima sessão, [Uso da data e hora nativas para dados de data GLV](best-practices-gremlin-datetime-glv.md). Começar com TinkerPop `3.5.2` (introduzido na [versão 1.1.1.0 do motor Neptune](engine-releases-1.1.1.0.md)) `datetime` é parte integrante do. TinkerPop Você pode usar o método do `datetime` para armazenar e comparar datas: ``` g.V('3').property('date',datetime('2001-02-08')) ``` ``` g.V().has('date',gt(datetime('2000-01-01'))) ``` # Uso da data e hora nativas para dados de data GLV Se estiver usando uma Variante da Linguagem Gremlin (GLV, Gremlin Language Variant), você deve usar as classes e funções de data e hora nativas fornecidas pela linguagem de programação para dados de tempo do Gremlin. As TinkerPop bibliotecas oficiais são todas bibliotecas Gremlin Language Variant. + [Go](https://tinkerpop.apache.org/docs/current/reference/#gremlin-go) + [Java](https://tinkerpop.apache.org/docs/current/reference/#gremlin-java) + [Javascript](https://tinkerpop.apache.org/docs/current/reference/#gremlin-javascript) + [.NET](https://tinkerpop.apache.org/docs/current/reference/#gremlin-dotnet) + [Python](https://tinkerpop.apache.org/docs/current/reference/#gremlin-python) **Importante** Esta página se aplica somente às bibliotecas de Variante da Linguagem Gremlin (GLV). Se estiver usando um método para enviar a consulta do Gremlin como sequência de texto, você deve usar a função datetime() do Gremlin. Isso inclui o console do Gremlin, sequências de texto usando a API REST HTTP ou envio direto de sequências de caracteres Gremlin por meio dos drivers. **Go** Veja a seguir um exemplo parcial no Go que cria uma propriedade única chamada “date” para o vértice com um ID de “3”. Isso define o valor para ser uma data gerada usando a função Go. time.Now(). ``` import ( "time" ) g.V('3').property('date', time.Now()).next(); ``` Para ver um exemplo completo de conexão com o Neptune usando Go, consulte [Usar um cliente Go para se conectar a uma instância de banco de dados do Neptune](https://docs.aws.amazon.com//neptune/latest/userguide/access-graph-gremlin-go.html). **Java** Veja a seguir um exemplo parcial em Java que cria uma propriedade única chamada '`date`' para o vértice com um ID do '`3`'. Isso define o valor a ser uma data gerada usando o construtor do `Date()` Java. ``` import java.util.date g.V('3').property('date', new Date()).next(); ``` Para ver um exemplo completo de como se conectar ao Neptune usando Java, consulte [Usar o cliente do Java para conectar-se a uma instância de banco de dados do Neptune](access-graph-gremlin-java.md). **Node.js (JavaScript)** A seguir está um exemplo parcial em JavaScript que cria uma única propriedade chamada '`date`' para o vértice com um ID de '`3`'. Isso define o valor a ser uma data gerada usando o construtor do `Date()` Node.js. ``` g.V('3').property('date', new Date()).next() ``` Para ver um exemplo completo de como se conectar ao Neptune usando Node.js, consulte [Usar o Node.js para conectar-se a uma instância de banco de dados do Neptune](access-graph-gremlin-node-js.md). **.NET (C\$1)** Veja a seguir um exemplo parcial em C\$1 que cria uma propriedade única chamada '`date`' para o vértice com um ID do '`3`'. Isso define o valor a ser uma data gerada usando a propriedade do `DateTime.UtcNow` .NET. ``` Using System; g.V('3').property('date', DateTime.UtcNow).next() ``` Para ver um exemplo completo de como se conectar ao Neptune usando C\$1, consulte [Usar .NET para conectar-se a uma instância de banco de dados do Neptune](access-graph-gremlin-dotnet.md). **Python** Veja a seguir um exemplo parcial em Python que cria uma propriedade única chamada '`date`' para o vértice com um ID do '`3`'. Isso define o valor a ser uma data gerada usando o método do `datetime.now()` Python. ``` import datetime g.V('3').property('date',datetime.datetime.now()).next() ``` Para ver um exemplo completo de como se conectar ao Neptune usando Python, consulte [Usar o Python para conectar-se a uma instância de banco de dados do Neptune](access-graph-gremlin-python.md).