Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Heartbeat-Konfiguration für Neptune Serverless
<a name="best-practices-gremlin-heartbeat-serverless"></a>

Wenn Sie WebSocket Gremlin-Clients mit Neptune Serverless verwenden, müssen Sie das Ping-Intervall des Clients entsprechend konfigurieren, um stabile Verbindungen während Skalierungsereignissen aufrechtzuerhalten. Der Gremlin-Client verwendet WebSocket Verbindungen und sendet regelmäßig Pings, um zu überprüfen, ob die Verbindung aktiv ist. Der Client erwartet innerhalb des Ping-Intervalls eine Antwort vom Server. Wenn der Server nicht antwortet, schließt der Client die Verbindung automatisch.

**Für von Neptune **bereitgestellte** Instances empfehlen wir, das Ping-Intervall auf 5 Sekunden festzulegen.** Für Neptune **Serverless-Cluster** empfehlen wir, das Ping-Intervall auf mindestens **20 Sekunden festzulegen, um möglichen Verzögerungen bei Skalierungsvorgängen** Rechnung zu tragen. Dieser Parameter steuert, wie lange der Client zwischen Schreibvorgängen auf den Server wartet, bevor er einen Ping sendet, um zu überprüfen, ob die Verbindung noch aktiv ist.

Die Konfiguration dieses Parameters hängt von der Client-Implementierung ab:

**Konfiguration des Java-Clients**

Konfigurieren Sie für den TinkerPop Java-Gremlin-Client den `keepAliveInterval` Parameter:

```
Cluster.Builder builder = Cluster.build()
    .addContactPoint(endpoint)
    .keepAliveInterval(20000); // Configure ping interval in milliseconds
```

Weitere Informationen zur Java-Treiberkonfiguration finden Sie in der [ TinkerPop Java-Dokumentation](https://tinkerpop.apache.org/docs/current/reference/#gremlin-java-configuration).

**Gehen Sie zur Client-Konfiguration**

Konfigurieren Sie für den Gremlin Go-Client den `KeepAliveInterval` Parameter:

```
rc, err := driver.NewDriverRemoteConnection(endpoint,
    func(settings *driver.DriverRemoteConnectionSettings) {
        settings.TraversalSource = "g"
        settings.AuthInfo = auth
        settings.KeepAliveInterval = 20 * time.Second // Configure ping interval
        ...
    })
```

Weitere Informationen zur Go-Treiberkonfiguration finden Sie in der [ TinkerPop Go-Dokumentation](https://tinkerpop.apache.org/docs/current/reference/#gremlin-go-configuration).

**JavaScript/Node.js Client-Konfiguration**

Konfigurieren Sie für den Gremlin-Client JavaScript /Node.js den `pingInterval` Parameter:

```
const gremlin = require('gremlin');
const DriverRemoteConnection = gremlin.driver.DriverRemoteConnection;

const connection = new DriverRemoteConnection(endpoint, {
    traversalSource: 'g',
    pingInterval: 20000  // Configure ping interval in milliseconds
});
```

[Weitere Informationen zur JavaScript Treiberkonfiguration finden Sie in der JavaScript TinkerPop Dokumentation.](https://tinkerpop.apache.org/docs/current/reference/#gremlin-javascript-configuration)

**Python-Client-Konfiguration**

Für den Python-Gremlin-Client wird das Ping-Intervall normalerweise auf der Transportschicht verwaltet. Informationen zu den Konfigurationsoptionen finden Sie in der spezifischen Dokumentation zur Transportimplementierung:

```
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))))
```

Weitere Informationen zur Python-Treiberkonfiguration finden Sie in der [ TinkerPop Python-Dokumentation](https://tinkerpop.apache.org/docs/current/reference/#gremlin-python-configuration).

Diese Konfiguration stellt sicher, dass Ihr Client bei Skalierungsereignissen mit Neptune Serverless die Verbindungsstabilität beibehält, wodurch unnötige Verbindungsabbrüche verhindert und die Anwendungszuverlässigkeit verbessert wird.