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.

# Integrieren Sie das Player-Gateway in ein Spiel
<a name="ddos-protection-integrate"></a>

Nachdem du eine Flotte erstellt hast, die für das Player-Gateway aktiviert ist, musst du deinen Spielclient und dein Spiel-Backend aktualisieren, um sie mit dem Player-Gateway zu integrieren. Ihr Spiel-Backend ruft Relay-Endpunkte und Spieler-Gateway-Token ab und stellt sie dann den Spielclients zur Verfügung. Spielclients senden den gesamten UDP-Verkehr an diese Relay-Endpunkte.

Die Integration folgt diesem Aufrufpfad:

1. Ihr Spiel-Backend ruft die `GetPlayerConnectionDetails` API auf, um Relay-Endpunkte und Player-Gateway-Token für jeden Spieler in einer Spielsitzung abzurufen.

1. Ihr Spiel-Backend sendet die Relay-Endpunkte und Spieler-Gateway-Token an den Spielclient.

1. Dein Spielclient stellt allen ausgehenden UDP-Paketen das Player-Gateway-Token voran und sendet die Pakete an die Relay-Endpunkte.

1. Das Relay-Netzwerk validiert das Spieler-Gateway-Token und leitet den Datenverkehr an deinen Spieleserver weiter.

1. Ihr Spieleserver sendet den Datenverkehr über dieselben Relay-Pfade zurück an Ihren Spielclient.

## Backend-Integration
<a name="ddos-protection-integrate-backend"></a>

Ihr Spiel-Backend muss die `GetPlayerConnectionDetails` API aufrufen, um Relay-Endpunkte und Player-Gateway-Token für Spieler abzurufen. Das Backend stellt diese Informationen dann den Spielclients zur Verfügung.

### GetPlayerConnectionDetails API
<a name="ddos-protection-integrate-backend-api"></a>

Die `GetPlayerConnectionDetails` API gibt Verbindungsdetails für Spieler in einer Spielsitzung zurück:

Endpunkte und Token weiterleiten  
Wenn das Player-Gateway am Standort aktiviert und unterstützt wird, wird Folgendes zurückgegeben:  
+ **Relay-Endpunkte** — Mehrere Relay-Endpunkte (IP-Adresse und Port), die sich je nach Spieler unterscheiden
+ **Player-Gateway-Token** — Token, das der Client allen UDP-Paketen voranstellen muss (gültig für mindestens 3 Minuten)
+ **Ablauf — Zeitstempel** für den Ablauf des Player-Gateway-Tokens

Direkte Verbindung  
Wenn das Player-Gateway am Standort nicht aktiviert ist oder nicht unterstützt wird, werden die IP-Adresse und der Port des Spielservers zurückgegeben

Dein Spielclient sollte so konzipiert sein, dass er beide Verbindungsarten unterstützt.

Beispiel für einen API-Aufruf:

```
// C++ example using AWS SDK
Aws::GameLift::GameLiftClient client;
Aws::GameLift::Model::GetPlayerConnectionDetailsRequest request;
request.SetGameSessionId(gameSessionId);
request.SetPlayerIds(playerIds);  // Vector of player IDs

auto outcome = client.GetPlayerConnectionDetails(request);
if (outcome.IsSuccess()) {
    auto result = outcome.GetResult();
    auto connectionDetails = result.GetPlayerConnectionDetails();
    
    // Process each player's connection details
    for (const auto& detail : connectionDetails) {
        std::string playerId = detail.GetPlayerId();
        
        // Get relay endpoints (IP address and port)
        auto endpoints = detail.GetEndpoints();
        for (const auto& endpoint : endpoints) {
            std::string ipAddress = endpoint.GetIpAddress();
            int port = endpoint.GetPort();
        }
        
        // Get player gateway token
        auto token = detail.GetPlayerGatewayToken();
        
        // Get expiration time
        auto expiration = detail.GetExpiration();
        
        // Send endpoints and token to game client
    }
}
```

Siehe [GetPlayerConnectionDetails](https://docs.aws.amazon.com/gameliftservers/latest/apireference/API_GetPlayerConnectionDetails.html)in der *Amazon GameLift ServersAPI-Referenz*.

### Relay-Endpunkte aktualisieren
<a name="ddos-protection-integrate-backend-refresh"></a>

Rufen Sie `GetPlayerConnectionDetails` regelmäßig an, um Spielern aktualisierte Endpunkte zur Verfügung zu stellen, wenn die Relay-Endpunkte nicht mehr richtig funktionieren. Wir empfehlen, die API alle 60 Sekunden für alle Spieler in einer Spielsitzung aufzurufen. Um die API-Nutzung zu optimieren, können Sie mehrere Spieler IDs in einem einzigen API-Aufruf stapeln.

**Wichtig**  
Reguläre Refresh-Aufrufe sind der wichtigste Mechanismus, um Spielern aktualisierte Endpunkte zur Verfügung zu stellen. Spieler-Gateway-Token bleiben zwar mindestens 3 Minuten lang gültig, aber durch eine Aktualisierung alle 60 Sekunden wird sichergestellt, dass die Spieler regelmäßig aktualisierte Endpunkte erhalten.

## Kundenintegration
<a name="ddos-protection-integrate-client"></a>

Dein Spielclient muss allen ausgehenden UDP-Paketen Spielergateway-Token voranstellen und die Pakete an die bereitgestellten Relay-Endpunkte senden. Das Amazon GameLift Servers Client-SDK SDK for C\$1\$1 und Unreal Engine bietet Hilfsprogramme, um diese Integration zu vereinfachen.

### Anforderungen des Kunden
<a name="ddos-protection-integrate-client-requirements"></a>

Um den Traffic über das Spieler-Gateway weiterzuleiten, muss dein Spielclient:
+ **Player-Gateway-Token** voranstellen — Das Player-Gateway-Token allen ausgehenden UDP-Paketen voranstellen. Player-Gateway-Token dürfen nicht verschlüsselt sein und müssen am Anfang jedes Pakets stehen. Pakete ohne gültiges Player-Gateway-Token werden verworfen.
+ **An Relay-Endpunkte** senden — Sendet alle UDP-Pakete an die bereitgestellten Relay-Endpunkte.
+ **Verbindungsaktivität aufrechterhalten** — Stelle sicher, dass entweder der Spielclient ein Paket an den Spieleserver sendet oder der Spieleserver mindestens einmal alle 30 Sekunden ein Paket an den Spieler sendet. Diese Aktivität hält die Verbindung über das Relay-Netzwerk aufrecht.
+ **Endpunkt-Updates durchführen** — Akzeptieren Sie aktualisierte Relay-Endpunkte und Player-Gateway-Token von Ihrem Backend (empfohlen alle 60 Sekunden) und wechseln Sie zu neuen Endpunkten, ohne die Verbindung zu unterbrechen.

### Kunden-SDK
<a name="ddos-protection-integrate-client-sdk"></a>

Das Amazon GameLift Servers Client-SDK SDK for C\$1\$1 und Unreal Engine bietet Hilfsprogramme zur Vereinfachung der Player-Gateway-Integration:
+ **Tokenverwaltung** — Fügt allen ausgehenden UDP-Paketen Player-Gateway-Token voran.
+ **Endpunktauswahl** — Leitet den Datenverkehr mithilfe eines konfigurierbaren Algorithmus an Relay-Endpunkte weiter.
+ **Aktualisierung der Endpunkte** — Plant regelmäßige Rückrufe, um aktualisierte Relay-Endpunkte und Player-Gateway-Token von Ihrem Backend abzurufen.

### Algorithmen zur Endpunktauswahl
<a name="ddos-protection-integrate-client-algorithms"></a>

Das Client-SDK bietet zwei integrierte Algorithmen für die Auswahl des zu verwendenden Relay-Endpunkts:

Fallback-Algorithmus  
Verwendet einen Endpunkt, bis er fehlerhaft ist, und wechselt dann zu einem anderen Endpunkt. Ideal für Menüs, Lobbys und rundenbasierte Spiele, bei denen kurze Unterbrechungen akzeptabel sind. Während des Endpunkt-Failovers können Pakete für den konfigurierten Timeout-Zeitraum (Standard: 2 Sekunden) verloren gehen.

Algorithmus für prädiktive Rotation  
Durchläuft kontinuierlich alle verfügbaren Endpunkte und prognostiziert Ausfälle, bevor sie auftreten. Ideal für Echtzeit-Gameplays wie Ego-Shooter und Rennspiele, bei denen eine konsistente Paketzustellung entscheidend ist. Erfordert, dass der Spieleserver Nachrichten mit einer konsistenten Frequenz sendet.

Sie können auch benutzerdefinierte Algorithmen implementieren, indem Sie die Basisalgorithmusklasse des SDK erweitern.

### SDK-Ressourcen für Kunden
<a name="ddos-protection-integrate-client-resources"></a>

Vollständige Integrationsanweisungen und Beispielcode finden Sie in den folgenden Ressourcen:

C\$1\$1  
Ein Client-SDK SDK for C\$1\$1 ist unter [Amazon GameLift ServersClient-SDK SDK for C\$1\$1](https://github.com/amazon-gamelift/amazon-gamelift-servers-client-sdk-for-cpp) verfügbar.

Unreal Engine  
Ein Plugin für Unreal Engine ist im [Amazon GameLift ServersClient-SDK für Unreal](https://github.com/amazon-gamelift-for-unreal/amazon-gamelift-servers-client-sdk-for-unreal) Engine verfügbar. Für den Zugriff ist eine Mitgliedschaft in der Epic Games-Organisation am erforderlich. GitHub Einzelheiten [findest du unter Unreal Engine GitHub auf](https://www.unrealengine.com/en-US/ue-on-github).

## Testen Sie Ihre Integration
<a name="ddos-protection-integrate-testing"></a>

Testen Sie Ihre Player-Gateway-Integration vor dem Einsatz in einer Flotte lokal mit dem Player-Gateway-Testtool. Dieses Tool simuliert die UDP-Proxyinfrastruktur des Player-Gateways und hilft dir dabei, zu überprüfen, ob dein Spiele-Client Spieler-Gateway-Token korrekt voranstellt, den Verkehr über mehrere Endpunkte leitet und mit Netzwerkverschlechterungen umgeht.

Anweisungen zur Einrichtung und Verwendung finden Sie in der [Player-Gateway-Test-App](https://github.com/amazon-gamelift/amazon-gamelift-toolkit/tree/main/player-gateway-testing-app) unter. GitHub

## Best Practices
<a name="ddos-protection-integrate-best-practices"></a>

Halten Sie sich bei der Integration von Player Gateway an die folgenden bewährten Methoden:
+ **Endgeräte alle 60 Sekunden aktualisieren — Rufen Sie `GetPlayerConnectionDetails` alle 60 Sekunden** an, um sicherzustellen, dass die Spieler regelmäßig aktualisierte Endpunkte erhalten.
+ **Batch-API-Aufrufe** — Wenn Sie mehrere Spieler in derselben Spielsitzung aufrufen`GetPlayerConnectionDetails`, sollten Sie die Aufrufe stapeln, um den API-Overhead zu reduzieren.
+ **Aufrechterhaltung der Verbindungsaktivität** — Stelle sicher, dass der Datenverkehr mindestens einmal alle 30 Sekunden zwischen dem Spielclient und dem Spieleserver fließt. Das kann entweder client-to-server oder server-to-client Verkehr sein.
+ **Gehen Sie ordnungsgemäß mit Endpunkt-Updates um** — Wenn Ihr Spielclient aktualisierte Endpunkte vom Backend empfängt, wechseln Sie zu den neuen Endpunkten, ohne die Verbindung des Spielers zu unterbrechen.
+ **Wähle den richtigen Algorithmus — Wähle den Algorithmus zur** Endpunktauswahl, der den Anforderungen deines Spiels am besten entspricht. Verwenden Sie den Fallback-Algorithmus für rundenbasierte Spiele und den Algorithmus für prädiktive Rotation für Echtzeitspiele.