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á.

# Configuração Heartbeat para Neptune Serverless
<a name="best-practices-gremlin-heartbeat-serverless"></a>

Ao usar WebSocket clientes Gremlin com o Neptune Serverless, você precisa configurar o intervalo de ping do cliente adequadamente 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).

**JavaScript/Node.js Configuração do cliente**

Para o cliente JavaScript/Node.js Gremlin, 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.