Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà. # Go server SDK per Amazon GameLift Servers -- Azioni Usa il riferimento all'SDK 5.x del server per integrare il tuo gioco multiplayer con cui ospitarlo. Amazon GameLift Servers Per indicazioni sul processo di integrazione, consulta. [Aggiungi Amazon GameLift Servers al tuo server di gioco con l'SDK del server](gamelift-sdk-server-api.md) `GameLiftServerAPI.go`definisce le azioni dell'SDK del server Go. [Go server SDK perAmazon GameLift Servers: tipi di dati](integration-server-sdk-go-datatypes.md) **Topics** + [Go server SDK perAmazon GameLift Servers: tipi di dati](integration-server-sdk-go-datatypes.md) + [GetSdkVersion()](#integration-server-sdk-go-getsdkversion) + [InitMetrics()](#integration-server-sdk-go-initmetrics) + [InitMetricsFromEnvironment()](#integration-server-sdk-go-initmetricsfromenv) + [InitSDK()](#integration-server-sdk-go-initsdk) + [ProcessReady()](#integration-server-sdk-go-processready) + [ProcessEnding()](#integration-server-sdk-go-processending) + [ActivateGameSession()](#integration-server-sdk-go-activategamesession) + [UpdatePlayerSessionCreationPolicy()](#integration-server-sdk-go-updateplayersessioncreationpolicy) + [GetGameSessionId()](#integration-server-sdk-go-getgamesessionid) + [GetTerminationTime()](#integration-server-sdk-go-getterm) + [AcceptPlayerSession()](#integration-server-sdk-go-acceptplayersession) + [RemovePlayerSession()](#integration-server-sdk-go-removeplayersession) + [DescribePlayerSessions()](#integration-server-sdk-go-describeplayersessions) + [StartMatchBackfill()](#integration-server-sdk-go-startmatchbackfill) + [StopMatchBackfill()](#integration-server-sdk-go-stopmatchbackfill) + [GetComputeCertificate()](#integration-server-sdk-go-getcomputecertificate) + [GetFleetRoleCredentials()](#integration-server-sdk-go-getfleetrolecredentials) + [Distruggi ()](#integration-server-sdk-go-destroy) ## GetSdkVersion() Restituisce il numero di versione corrente dell'SDK integrato nel processo del server. ### Sintassi ``` func GetSdkVersion() (string, error) ``` ### Valore restituito In caso di successo, restituisce la versione SDK corrente come stringa. La stringa restituita include il numero di versione (esempio`5.0.0`). Se non riesce, restituisce un messaggio di errore come`common.SdkVersionDetectionFailed`. ### Esempio ``` version, err := server.GetSdkVersion() ``` ## InitMetrics() Inizializza la raccolta di metriche per l'SDK. Amazon GameLift Servers Questo metodo imposta la reportistica delle metriche per aiutare a monitorare le prestazioni e lo stato del server. Chiama questo metodo dopo [InitSDK()](#integration-server-sdk-go-initsdk) ma prima[ProcessReady()](#integration-server-sdk-go-processready). ### Sintassi ``` func InitMetrics() error func InitMetrics(metricsParameters MetricsParameters) error ``` ### Parameters MetricsParameters (facoltativo) Un `MetricsParameters` oggetto che configura la raccolta di metriche. Se non viene fornita, viene utilizzata la configurazione delle metriche predefinita. La MetricsParameters struttura contiene i seguenti campi: + `StatsdHost`- Il nome host o l'indirizzo IP del server StatSD. + `StatsdPort`- Il numero di porta per il server StatSD. + `CrashReporterHost`- Il nome host o l'indirizzo IP del servizio crash reporter. + `CrashReporterPort`- Il numero di porta per il servizio crash reporter. + `FlushIntervalMs`- L'intervallo in millisecondi per il lavaggio dei dati delle metriche. + `MaxPacketSize`- La dimensione massima dei pacchetti di metriche in byte. Per ulteriori informazioni sulla MetricsParameters struttura, consulta [Server SDK 5.x](https://docs.aws.amazon.com/gameliftservers/latest/developerguide/integration-server-sdk5-csharp-datatypes.html) per i tipi di dati C\$1. ### Valore restituito In caso di successo, restituisce `nil` un errore per indicare che la raccolta delle metriche è stata inizializzata correttamente. ### Esempio Inizializza le metriche con la configurazione predefinita: ``` err := server.InitMetrics() ``` Inizializza le metriche con una configurazione personalizzata: ``` metricsParams := MetricsParameters{ StatsdHost: "localhost", StatsdPort: 8125, CrashReporterHost: "localhost", CrashReporterPort: 9125, FlushIntervalMs: 5000, MaxPacketSize: 1024, } err := server.InitMetrics(metricsParams) ``` ## InitMetricsFromEnvironment() Inizializza la raccolta di metriche per l'Amazon GameLift ServersSDK utilizzando la configurazione delle variabili di ambiente. Questo metodo configura il reporting delle metriche utilizzando le impostazioni predefinite derivate dall'ambiente di runtime. Chiama questo metodo dopo [InitSDK()](#integration-server-sdk-go-initsdk) ma prima[ProcessReady()](#integration-server-sdk-go-processready). ### Sintassi ``` func InitMetricsFromEnvironment() error ``` ### Valore restituito In caso di successo, restituisce `nil` un errore per indicare che la raccolta delle metriche è stata inizializzata correttamente utilizzando la configurazione dell'ambiente. ### Esempio ``` err := server.InitMetricsFromEnvironment() ``` ## InitSDK() Inizializza l'SDK Amazon GameLift Servers. Chiama questo metodo all'avvio prima che si verifichi qualsiasi altra inizializzazione correlata a. Amazon GameLift Servers Questo metodo imposta la comunicazione tra il server e il Amazon GameLift Servers servizio. ### Sintassi ``` func InitSDK(params ServerParameters) error ``` ### Parameters [ServerParameters](integration-server-sdk-go-datatypes.md#integration-server-sdk-go-dataypes-serverparameters) Per inizializzare un server di gioco su una flotta Amazon GameLift Servers Anywhere, costruisci un `ServerParameters` oggetto con le seguenti informazioni: + L'URL WebSocket utilizzato per connettersi al server di gioco. + L'ID del processo utilizzato per ospitare il server di gioco. + L'ID del computer che ospita i processi del server di gioco. + L'ID della Amazon GameLift Servers flotta contenente il tuo computer Amazon GameLift Servers Anywhere. + Il token di autorizzazione generato dall'Amazon GameLift Serversoperazione. Per inizializzare un server di gioco su una flotta EC2 Amazon GameLift Servers gestita, costruisci un `ServerParameters` oggetto senza parametri. Con questa chiamata, l'Amazon GameLift Serversagente configura l'ambiente di calcolo e si connette automaticamente al Amazon GameLift Servers servizio per te. ### Valore restituito In caso di successo, restituisce un `nil` errore per indicare che il processo del server è pronto per la chiamata[ProcessReady()](#integration-server-sdk-go-processready). **Nota** Se le chiamate a non `InitSDK()` riescono per le build di gioco distribuite sulle flotte Anywhere, controlla il `ServerSdkVersion` parametro utilizzato durante la creazione della risorsa di compilazione. È necessario impostare esplicitamente questo valore sulla versione SDK del server in uso. Il valore predefinito per questo parametro è 4.x, che non è compatibile. Per risolvere questo problema, crea una nuova build e distribuiscila in una nuova flotta. ### Esempio Amazon GameLift ServersEsempio: Ovunque ``` //Define the server parameters serverParameters := ServerParameters { WebSocketURL: "wss://us-west-1.api.amazongamelift.com", ProcessID: "PID1234", HostID: "HardwareAnywhere", FleetID: "aarn:aws:gamelift:us-west-1:111122223333:fleet/fleet-9999ffff-88ee-77dd-66cc-5555bbbb44aa", AuthToken: "1111aaaa-22bb-33cc-44dd-5555eeee66ff" } //Call InitSDK to establish a local connection with the Amazon GameLift Servers Agent to enable further communication. err := server.InitSDK(serverParameters) ``` Amazon GameLift Serversesempio EC2 gestito ``` //Define the server parameters serverParameters := ServerParameters {} //Call InitSDK to establish a local connection with the Amazon GameLift Servers Agent to enable further communication. err := server.InitSDK(serverParameters) ``` ## ProcessReady() Notifica Amazon GameLift Servers che il processo del server è pronto per ospitare sessioni di gioco. Chiama questo metodo dopo averlo [InitSDK()](#integration-server-sdk-go-initsdk) invocato. Questo metodo deve essere chiamato solo una volta per processo. ### Sintassi ``` func ProcessReady(param ProcessParameters) error ``` ### Parameters **ProcessParameters** Un [ProcessParameters](integration-server-sdk-go-datatypes.md#integration-server-sdk-go-dataypes-process) oggetto comunica le seguenti informazioni sul processo del server: + I nomi dei metodi di callback implementati nel codice del server di gioco richiamato dal Amazon GameLift Servers servizio per comunicare con il processo del server. + Il numero di porta su cui il processo server è in ascolto. + Il tipo di [LogParameters](integration-server-sdk-go-datatypes.md#integration-server-sdk-go-dataypes-log) dati contenente il percorso di tutti i file specifici della sessione di gioco che desideri acquisire e Amazon GameLift Servers archiviare. ### Valore restituito Restituisce un errore con un messaggio di errore se il metodo fallisce. Restituisce `nil` se il metodo ha successo. ### Esempio Questo esempio illustra la chiamata [ProcessReady()](#integration-server-sdk-go-processready) e le implementazioni della funzione delegata. ``` // Define the process parameters processParams := ProcessParameters { OnStartGameSession: gameProcess.OnStartGameSession, OnUpdateGameSession: gameProcess.OnGameSessionUpdate, OnProcessTerminate: gameProcess.OnProcessTerminate, OnHealthCheck: gameProcess.OnHealthCheck, Port: port, LogParameters: LogParameters { // logging and error example []string {"C:\\game\\logs", "C:\\game\\error"} } } err := server.ProcessReady(processParams) ``` ## ProcessEnding() Notifica Amazon GameLift Servers che il processo del server sta terminando. Chiama questo metodo dopo tutte le altre attività di pulizia (inclusa la chiusura della sessione di gioco attiva) e prima di terminare il processo. A seconda del risultato di`ProcessEnding()`, il processo termina con successo (0) o errore (-1) e genera un evento relativo alla flotta. Se il processo termina con un errore, l'evento fleet generato è. `SERVER_PROCESS_TERMINATED_UNHEALTHY` ### Sintassi ``` func ProcessEnding() error ``` ### Valore restituito Restituisce un codice di errore 0 o un codice di errore definito. ### Esempio ``` // operations to end game sessions and the server process defer func() { err := server.ProcessEnding() server.Destroy() if err != nil { fmt.Println("ProcessEnding() failed. Error: ", err) os.Exit(-1) } else { os.Exit(0) } } ``` ## ActivateGameSession() Notifica Amazon GameLift Servers che il processo del server ha attivato una sessione di gioco ed è ora pronto per ricevere le connessioni dei giocatori. Questa azione viene richiamata come parte della funzione di `onStartGameSession()` callback, dopo l'inizializzazione di tutta la sessione di gioco. ### Sintassi ``` func ActivateGameSession() error ``` ### Valore restituito Restituisce un errore con un messaggio di errore se il metodo fallisce. ### Esempio Questo esempio mostra le `ActivateGameSession()` chiamate come parte della funzione `onStartGameSession()` delegata. ``` func OnStartGameSession(GameSession gameSession) { // game-specific tasks when starting a new game session, such as loading map // Activate when ready to receive players err := server.ActivateGameSession(); } ``` ## UpdatePlayerSessionCreationPolicy() Aggiorna la capacità della sessione di gioco corrente di accettare nuove sessioni giocatore. Una sessione di gioco può essere configurata per accettare o rifiutare tutte le nuove sessioni giocatore. ### Sintassi ``` func UpdatePlayerSessionCreationPolicy(policy model.PlayerSessionCreationPolicy) error ``` ### Parameters **playerSessionCreationPolitica** Valore di stringa che indica se la sessione di gioco accetta nuovi giocatori. I valori validi includono: + **`model.AcceptAll`**— Accetta tutte le sessioni di nuovi giocatori. + **`model.DenyAll`**— Nega tutte le sessioni dei nuovi giocatori. ### Valore restituito Restituisce un errore con un messaggio di errore se si verifica un errore. ### Esempio Questo esempio definisce la policy di partecipazione alla sessione di gioco corrente per accettare tutti i giocatori. ``` err := server.UpdatePlayerSessionCreationPolicy(model.AcceptAll) ``` ## GetGameSessionId() Recupera l'ID della sessione di gioco ospitata dal processo del server attivo. ### Sintassi ``` func GetGameSessionID() (string, error) ``` ### Parameters Questa operazione non prevede parametri. ### Valore restituito In caso di successo, restituisce l'ID della sessione di gioco e l'errore zero. Per i processi inattivi che non sono ancora stati attivati con una sessione di gioco, la chiamata restituisce una stringa vuota e `nil` un errore. ### Esempio ``` gameSessionID, err := server.GetGameSessionID() ``` ## GetTerminationTime() Restituisce l'ora in cui è pianificata la chiusura di un processo del server, se è disponibile un orario di terminazione. Un processo server esegue questa azione dopo aver ricevuto una `onProcessTerminate()` richiamata da. Amazon GameLift Servers Amazon GameLift Serverschiama `onProcessTerminate()` per i seguenti motivi: + Quando il processo del server ha segnalato problemi di salute o non ha risposto. Amazon GameLift Servers + Quando si termina l'istanza durante un evento di scale-down. + [Quando un'istanza viene terminata a causa di un'interruzione di un'istanza spot.](spot-tasks.md) ### Sintassi ``` func GetTerminationTime() (int64, error) ``` ### Valore restituito In caso di successo, restituisce il timestamp in secondi di epoca in cui è pianificata la chiusura del processo del server e l'interruzione di un errore. `nil` Il valore è il tempo di terminazione, espresso in tick trascorsi da. `0001 00:00:00` Ad esempio, il valore di data e ora è uguale ai segni di `2020-09-13 12:26:40 -000Z` spunta. `637355968000000000` Se non è disponibile alcun orario di terminazione, restituisce un messaggio di errore. ### Esempio ``` terminationTime, err := server.GetTerminationTime() ``` ## AcceptPlayerSession() Notifica Amazon GameLift Servers che un giocatore con l'ID di sessione specificato si è connesso al processo del server e deve essere convalidato. Amazon GameLift Serversverifica che l'ID della sessione del giocatore sia valido. Dopo la convalida della sessione del giocatore, Amazon GameLift Servers modifica lo stato dello slot del giocatore da a`RESERVED`. `ACTIVE` ### Sintassi ``` func AcceptPlayerSession(playerSessionID string) error ``` ### Parameters `playerSessionId` ID univoco rilasciato da Amazon GameLift Servers quando viene creata una nuova sessione giocatore. ### Valore restituito Restituisce un risultato generico composto da successo o fallimento con un messaggio di errore. ### Esempio Questo esempio gestisce una richiesta di connessione che include la convalida e il rifiuto di una sessione giocatore non valida. IDs ``` func ReceiveConnectingPlayerSessionID(conn Connection, playerSessionID string) { err := server.AcceptPlayerSession(playerSessionID) if err != nil { connection.Accept() } else { connection.Reject(err.Error()) } } ``` ## RemovePlayerSession() Notifica Amazon GameLift Servers che un giocatore si è disconnesso dal processo del server. In risposta, Amazon GameLift Servers modifica lo slot del giocatore rendendolo disponibile. ### Sintassi ``` func RemovePlayerSession(playerSessionID string) error ``` ### Parameters **`playerSessionId`** ID univoco rilasciato Amazon GameLift Servers quando viene creata una nuova sessione giocatore. ### Valore restituito Restituisce un risultato generico composto da successo o fallimento con un messaggio di errore. ### Esempio ``` err := server.RemovePlayerSession(playerSessionID) ``` ## DescribePlayerSessions() Recupera i dati della sessione del giocatore che includono impostazioni, metadati della sessione e dati del giocatore. Utilizzate questo metodo per ottenere informazioni su quanto segue: + Una sessione per giocatore singolo + Tutte le sessioni dei giocatori in una sessione di gioco + Tutte le sessioni dei giocatori sono associate a un ID giocatore singolo ### Sintassi ``` func DescribePlayerSessions(req request.DescribePlayerSessionsRequest) (result.DescribePlayerSessionsResult, error) { return srv.describePlayerSessions(&req) } ``` ### Parameters **[DescribePlayerSessionsRequest](integration-server-sdk-go-datatypes.md#integration-server-sdk-go-dataypes-playersessions)** Un `DescribePlayerSessionsRequest` oggetto descrive le sessioni dei giocatori da recuperare. ### Valore restituito In caso di successo, restituisce un `DescribePlayerSessionsResult` oggetto che contiene un set di oggetti della sessione del giocatore che soddisfano i parametri della richiesta. ### Esempio Questo esempio richiede che tutte le sessioni dei giocatori siano connesse attivamente a una sessione di gioco specificata. Omettendo *NextToken*e impostando il valore *Limite* su 10, Amazon GameLift Servers restituisce i primi 10 record di sessione tra giocatori corrispondenti alla richiesta. ``` // create request describePlayerSessionsRequest := request.NewDescribePlayerSessions() describePlayerSessionsRequest.GameSessionID, _ = server.GetGameSessionID() // get ID for the current game session describePlayerSessionsRequest.Limit = 10 // return the first 10 player sessions describePlayerSessionsRequest.PlayerSessionStatusFilter = "ACTIVE" // Get all player sessions actively connected to the game session describePlayerSessionsResult, err := server.DescribePlayerSessions(describePlayerSessionsRequest) ``` ## StartMatchBackfill() Invia una richiesta per trovare nuovi giocatori per gli slot aperti in una sessione di gioco creata con FlexMatch. Per ulteriori informazioni, consulta la funzione di [FlexMatchriempimento](https://docs.aws.amazon.com/gameliftservers/latest/flexmatchguide/match-backfill.html). Questa operazione è asincrona. Se vengono abbinati nuovi giocatori, Amazon GameLift Servers fornisce dati aggiornati sul matchmaker utilizzando la funzione di callback. `OnUpdateGameSession()` Un processo del server può avere un solo backfill degli abbinamenti attivo alla volta. Per inviare una nuova richiesta, chiama prima [StopMatchBackfill()](#integration-server-sdk-go-stopmatchbackfill) per annullare la richiesta originale. ### Sintassi ``` func StartMatchBackfill(req request.StartMatchBackfillRequest) (result.StartMatchBackfillResult, error) ``` ### Parameters **[StartMatchBackfillRequest](integration-server-sdk-go-datatypes.md#integration-server-sdk-go-dataypes-startmatchbackfillrequest)** Un StartMatchBackfillRequest oggetto comunica le seguenti informazioni: + ID del ticket da assegnare alla richiesta di backfill. Queste informazioni sono facoltative; se non viene fornito alcun ID, ne Amazon GameLift Servers genera uno. + Matchmaker a cui inviare la richiesta. L'ARN di configurazione completo è obbligatorio. Questo valore si trova nei dati del matchmaker della sessione di gioco. + L'ID della sessione di gioco da riempire. + I dati di matchmaking disponibili per i giocatori attuali della sessione di gioco. ### Valore restituito Restituisce un `StartMatchBackfillResult` oggetto con l'ID del ticket match backfill, oppure restituisce un errore con un messaggio di errore. ### Esempio ``` // form the request startBackfillRequest := request.NewStartMatchBackfill() startBackfillRequest.RequestID = "1111aaaa-22bb-33cc-44dd-5555eeee66ff" // optional startBackfillRequest.MatchmakingConfigurationArn = "arn:aws:gamelift:us-west-2:111122223333:matchmakingconfiguration/MyMatchmakerConfig" var matchMaker model.MatchmakerData if err := matchMaker.UnmarshalJSON([]byte(gameSession.MatchmakerData)); err != nil { return } startBackfillRequest.Players = matchMaker.Players res, err := server.StartMatchBackfill(startBackfillRequest) // Implement callback function for backfill func OnUpdateGameSession(myGameSession model.GameSession) { // game-specific tasks to prepare for the newly matched players and update matchmaker data as needed } ``` ## StopMatchBackfill() Annulla una richiesta di match backfill attiva. Per ulteriori informazioni, consulta la funzione di [FlexMatchriempimento](https://docs.aws.amazon.com/gameliftservers/latest/flexmatchguide/match-backfill.html). ### Sintassi ``` func StopMatchBackfill(req request.StopMatchBackfillRequest) error ``` ### Parameters **[StopMatchBackfillRequest](integration-server-sdk-go-datatypes.md#integration-server-sdk-go-dataypes-stopmatchbackfillrequest)** Un StopMatchBackfillRequest oggetto che identifica il ticket di matchmaking da annullare: + L'ID del ticket assegnato alla richiesta di riempimento. + Il matchmaker a cui è stata inviata la richiesta di riempimento. + La sessione di gioco associata alla richiesta di riempimento. ### Valore restituito Restituisce un risultato generico composto da successo o fallimento con un messaggio di errore. ### Esempio ``` stopBackfillRequest := request.NewStopMatchBackfill() // Use this function to create request stopBackfillRequest.TicketID = "1111aaaa-22bb-33cc-44dd-5555eeee66ff" stopBackfillRequest.MatchmakingConfigurationArn = "arn:aws:gamelift:us-west-2:111122223333:matchmakingconfiguration/MyMatchmakerConfig" //error err := server.StopMatchBackfill(stopBackfillRequest) ``` ## GetComputeCertificate() Recupera il percorso del certificato TLS utilizzato per crittografare la connessione di rete tra il server di gioco e il client di gioco. Puoi utilizzare il percorso del certificato quando registri il tuo dispositivo di elaborazione in una flotta Anywhere. Amazon GameLift Servers Per ulteriori informazioni, consulta [RegisterCompute](https://docs.aws.amazon.com/gameliftservers/latest/apireference/API_RegisterCompute.html). ### Sintassi ``` func GetComputeCertificate() (result.GetComputeCertificateResult, error) ``` ### Valore restituito Restituisce un `GetComputeCertificateResult` oggetto che contiene quanto segue: + CertificatePath: il percorso del certificato TLS sulla risorsa di calcolo. Quando si utilizza una flotta Amazon GameLift Servers gestita, questo percorso contiene: + `certificate.pem`: Il certificato dell'utente finale. La catena completa di certificati è la combinazione dei certificati `certificateChain.pem` aggiunti a questo certificato. + `certificateChain.pem`: La catena di certificati che contiene il certificato principale e i certificati intermedi. + `rootCertificate.pem`: Il certificato principale. + `privateKey.pem`: la chiave privata per il certificato dell'utente finale. + ComputeName: il nome della risorsa di calcolo. ### Esempio ``` tlsCertificate, err := server.GetFleetRoleCredentials(getFleetRoleCredentialsRequest) ``` ## GetFleetRoleCredentials() Recupera le credenziali del ruolo di servizio che crei per estendere le autorizzazioni agli altri utenti. Servizi AWS Amazon GameLift Servers Queste credenziali consentono al server di gioco di utilizzare le tue risorse. AWS Per ulteriori informazioni, consulta [Configurare un ruolo di servizio IAM per Amazon GameLift Servers](setting-up-role.md). ### Sintassi ``` func GetFleetRoleCredentials( req request.GetFleetRoleCredentialsRequest, ) (result.GetFleetRoleCredentialsResult, error) { return srv.getFleetRoleCredentials(&req) } ``` ### Parameters [GetFleetRoleCredentialsRequest](integration-server-sdk-go-datatypes.md#integration-server-sdk-go-dataypes-getfleetrolecredentialsrequest) Credenziali di ruolo che estendono l'accesso limitato alle tue AWS risorse al server di gioco. ### Valore restituito Restituisce un `GetFleetRoleCredentialsResult` oggetto che contiene quanto segue: + AssumedRoleUserArn - L'Amazon Resource Name (ARN) dell'utente a cui appartiene il ruolo di servizio. + AssumedRoleId - L'ID dell'utente a cui appartiene il ruolo di servizio. + AccessKeyId - L'ID della chiave di accesso per autenticare e fornire l'accesso alle AWS risorse. + SecretAccessKey - L'ID della chiave di accesso segreta per l'autenticazione. + SessionToken - Un token per identificare la sessione attiva corrente che interagisce con AWS le tue risorse. + Scadenza: il periodo di tempo che manca alla scadenza delle credenziali della sessione. ### Esempio ``` // form the customer credentials request getFleetRoleCredentialsRequest := request.NewGetFleetRoleCredentials() getFleetRoleCredentialsRequest.RoleArn = "arn:aws:iam::123456789012:role/service-role/exampleGameLiftAction" credentials, err := server.GetFleetRoleCredentials(getFleetRoleCredentialsRequest) ``` ## Distruggi () Libera l'SDK del server di Amazon GameLift Servers gioco dalla memoria. È consigliabile chiamare questo metodo dopo `ProcessEnding()` e prima di terminare il processo. Se utilizzi una flotta Anywhere e non interrompi i processi del server dopo ogni sessione di gioco, chiama `Destroy()` e poi `InitSDK()` reinizializza prima di notificare Amazon GameLift Servers che il processo è pronto per ospitare una sessione di gioco. `ProcessReady()` ### Sintassi ``` func Destroy() error { return srv.destroy() } ``` ### Valore restituito Restituisce un errore con un messaggio di errore se il metodo fallisce. ### Esempio ``` // operations to end game sessions and the server process defer func() { err := server.ProcessEnding() server.Destroy() if err != nil { fmt.Println("ProcessEnding() failed. Error: ", err) os.Exit(-1) } else { os.Exit(0) } } ```