Cluster registrieren

Auf dieser Seite wird erläutert, wie Sie einen Game Servers-Cluster in einem Bereich registrieren, auflisten und ansehen.

Hinweis

Bevor Sie beginnen, sollten Sie sich mit den wichtigsten Konzepten in der Übersicht über Game Servers vertraut machen. Führen Sie außerdem die folgenden Aufgaben aus:

  • Prüfen Sie, ob die Game Services API aktiviert ist.
  • Game Services API aktivieren
  • Wählen Sie entweder eine Shell mit installiertem Cloud SDK aus oder verwenden Sie einen API-Client:
  • Cloud Shell

    So starten Sie Cloud Shell:

    1. Öffnen Sie die Google Cloud Console.

      Google Cloud Console

    2. Klicken Sie in der oberen rechten Ecke der Console auf die Schaltfläche Cloud Shell aktivieren:

    In einem Frame im unteren Teil der Console wird eine Cloud Shell-Sitzung geöffnet. Mit dieser Shell führen Sie gcloud-Befehle aus.

    Lokale Shell

    Installieren Sie zur Installation von gcloud das Cloud SDK. Darin ist das gcloud-Befehlszeilentool enthalten.

    Prüfen Sie, ob Sie das gewünschte Standardprojekt für das gcloud-Befehlszeilentool festgelegt haben. Andernfalls müssen Sie das Flag --project für jeden Befehl später explizit angeben:

    gcloud config list project
    

    Wenn Sie den folgenden Befehl nicht ausführen können, um ein Standardprojekt festzulegen, ersetzen Sie PROJECT_ID durch Ihre gewünschte Projekt-ID:

    gcloud config set project PROJECT_ID
    

    Führen Sie den folgenden Befehl aus, um Ihre Version des Google Cloud SDK zu prüfen. Für Game Servers ist Version 306.0.0 oder höher des SDK erforderlich.

    gcloud version
    

    Aktualisieren Sie Ihre Installation mit dem folgenden Befehl:

    gcloud components update
    

    curl / PowerShell

    So verwenden Sie die REST API mit curl oder Windows PowerShell:

    1. Erstellen Sie ein Dienstkonto:
    2. Laden Sie einen privaten Schlüssel als JSON-Datei herunter.
    3. Legen Sie für die Umgebungsvariable GOOGLE_APPLICATION_CREDENTIALS den Pfad der JSON-Datei fest, die Ihren Dienstkontoschlüssel enthält. Diese Variable gilt nur für Ihre aktuelle Shellsitzung. Wenn Sie eine neue Sitzung öffnen, müssen Sie die Variable noch einmal festlegen.

    Clientbibliothek

    Google Cloud Game Servers können mithilfe einer Clientbibliothek programmatisch gesteuert werden. Wie Sie die Bibliothek und die Authentifizierung verwenden, erfahren Sie in der Übersicht zu Clientbibliotheken.

Cluster registrieren

Sie müssen einen Game Servers-Bereich erstellt haben.

Wenn Sie keinen GKE-Cluster (Google Kubernetes Engine) mit Agones haben, gehen Sie so vor:

  1. Erstellen Sie einen öffentlichen Google Kubernetes Engine-Cluster. Aktivieren Sie die Kubernetes Engine API.

    Wichtige Hinweise:

  2. Agones installieren.

  3. Achten Sie darauf, dass die Versionen von Agones und Ihrem Kubernetes-Cluster kompatibel sind und Sie Agones im Namespace agones-system installiert haben.

Gameserver-Cluster registrieren

Console

  1. Rufen Sie in der Cloud Console die Seite Bereich & Cluster auf.

    Zu Game Servers

  2. Klicken Sie auf Game Servers-Cluster hinzufügen.

  3. Wählen Sie in der Liste Auswahlmöglichkeiten von Realms den Bereich aus, zu dem der Gameservers-Cluster gehört. Sie können auf die Schaltfläche Bereich erstellen klicken, um gegebenenfalls einen Bereich zu erstellen.

  4. Klicken Sie auf Weiter.

  5. Geben Sie im Feld Game Server-Cluster-ID eine eindeutige Kennzeichnung für den Gameservers-Cluster ein.

  6. Wählen Sie in der Liste Kubernetes-Cluster einen Kubernetes-Cluster mit installiertem Agones aus.

  7. Klicken Sie auf Erstellen.

gcloud

Sie können einen Game Servers-Cluster mit dem gcloud-Befehlszeilentool in einem Bereich registrieren.

Globalen Gameserver-Cluster registrieren

So registrieren Sie einen globalen Gameserver-Cluster:

  1. Führen Sie den folgenden Befehl aus und ersetzen Sie die Platzhalterwerte wie realmID durch die entsprechenden Werte:

    gcloud game servers clusters create gscID --realm=realmID --gke-cluster=gkeCluster --namespace=default --dry-run
    

    Die Ausgabe gibt den targetState zurück, sodass Sie vor der Registrierung eine Vorschau des neuen Clusters anzeigen können.

  2. Führen Sie den folgenden Befehl aus, um den globalen Cluster zu registrieren und zu erstellen:

    gcloud game servers clusters create gscID --realm=realmID --gke-cluster gkeCluster --namespace=default --no-dry-run
    

Regionalen Gameserver-Cluster registrieren

So registrieren Sie einen regionalen Gameserver-Cluster:

  1. Führen Sie den folgenden Befehl aus und ersetzen Sie die Platzhalterwerte wie realmID durch die entsprechenden Werte:

    gcloud game servers clusters create gscID --realm=realmID --gke-cluster gkeCluster --location=region --namespace=default --dry-run
    

    Die Ausgabe gibt den targetState zurück, sodass Sie vor der Erstellung eine Vorschau des neuen Clusters anzeigen können.

  2. Führen Sie den folgenden Befehl aus, um den regionalen Cluster zu registrieren und zu erstellen:

    gcloud game servers clusters create gscID --realm=realmID --gke-cluster gkeCluster --location=region --namespace=default --no-dry-run
    

Wenn Game Servers den Cluster, den Sie anhängen möchten, nicht validieren kann, wird möglicherweise der folgende Fehler angezeigt:

Cannot connect to the provided Kubernetes cluster "projects/project/locations/location/clusters/gkeCluster, check the name and make sure that the cluster exists

Achten Sie in diesem Fall darauf, dass gkeCluster richtig formatiert ist und der Cluster in project und location vorhanden ist.

Die Variablenplatzhalter entsprechen den folgenden Beschreibungen:

  • gscID ist eine eindeutige Kennung, die Sie für diesen Cluster angeben können.
  • realmID ist die eindeutige Kennung für den Bereich, in dem Sie den Cluster speichern möchten.
  • gkeCluster ist der voll qualifizierte Ressourcenpfad eines GKE-Clusters, z. B. projects/<projectId>/locations/<location>/clusters/<clusterId>.
  • region ist die Region des Clusters. Wählen Sie dieselbe Region aus wie die des übergeordneten Bereichs.

REST UND BEFEHLSZEILE

Ersetzen Sie diese Werte in den folgenden Anfragedaten:

  • PROJECT_ID: Ihre Google Cloud-Projekt-ID, die in den IAM-Einstellungen aufgeführt ist
  • REALM_LOCATION: Region für den Bereich oder global, in der dieser Cluster gespeichert werden soll
  • REALM_ID: die Kennung für den Bereich, in dem dieser Cluster gespeichert werden soll
  • GS_CLUSTER_ID: eine benutzerdefinierte Kennung für den Cluster
  • GKE_CLUSTER_LOCATION: Die Region des GKE-Clusters.
  • GKE_CLUSTER_ID: die Kennung für einen GKE-Cluster

JSON-Text der Anfrage:

{
  "name": "projects/PROJECT_ID/locations/REALM_LOCATION/realms/REALM_ID/gameServerClusters/GS_CLUSTER_ID",
  "connectionInfo": {
    "namespace": "default",
    "gkeClusterReference": {
      "cluster": "projects/PROJECT_ID/locations/GKE_CLUSTER_LOCATION/clusters/GKE_CLUSTER_ID"
    }
  }
}

Wenn Sie die Anfrage senden möchten, maximieren Sie eine der folgenden Optionen:

Sie sollten in etwa folgende JSON-Antwort erhalten:

{
  "name": "projects/PROJECT_ID/locations/REALM_LOCATION/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.gaming.v1.OperationMetadata",
    "createTime": CREATE_TIME,
    "target": "projects/PROJECT_ID/locations/REALM_LOCATION/realms/REALM_ID/gameServerClusters/GS_CLUSTER_ID",
    "verb": "create",
    "requestedCancellation": false,
    "apiVersion": "v1"
  },
  "done": false
}

Go

Informationen zum Installieren und Verwenden der Clientbibliothek für Game Servers finden Sie unter Game Servers-Clientbibliotheken.


import (
	"context"
	"fmt"
	"io"

	gaming "cloud.google.com/go/gaming/apiv1"
	gamingpb "google.golang.org/genproto/googleapis/cloud/gaming/v1"
)

// createCluster registers a game server cluster.
func createCluster(w io.Writer, projectID, location, realmID, clusterID, gkeClusterName string) error {
	// projectID := "my-project"
	// location := "global"
	// realmID := "myrealm"
	// clusterID := "mycluster"
	// gkeClusterName := "projects/1234/locations/us-central1/clusters/gke-cluster"
	ctx := context.Background()
	client, err := gaming.NewGameServerClustersClient(ctx)
	if err != nil {
		return fmt.Errorf("NewGameServerClustersClient: %v", err)
	}
	defer client.Close()

	req := &gamingpb.CreateGameServerClusterRequest{
		Parent:              fmt.Sprintf("projects/%s/locations/%s/realms/%s", projectID, location, realmID),
		GameServerClusterId: clusterID,
		GameServerCluster: &gamingpb.GameServerCluster{
			ConnectionInfo: &gamingpb.GameServerClusterConnectionInfo{
				Namespace: "default",
				ClusterReference: &gamingpb.GameServerClusterConnectionInfo_GkeClusterReference{
					GkeClusterReference: &gamingpb.GkeClusterReference{
						Cluster: gkeClusterName,
					},
				},
			},
			Description: "My Game Server Cluster",
		},
	}

	op, err := client.CreateGameServerCluster(ctx, req)
	if err != nil {
		return fmt.Errorf("CreateGameServerCluster: %v", err)
	}
	resp, err := op.Wait(ctx)
	if err != nil {
		return fmt.Errorf("Wait: %v", err)
	}

	fmt.Fprintf(w, "Cluster created: %v", resp.Name)
	return nil
}

Java

Informationen zum Installieren und Verwenden der Clientbibliothek für Game Servers finden Sie unter Game Servers-Clientbibliotheken.


import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.gaming.v1.CreateGameServerClusterRequest;
import com.google.cloud.gaming.v1.GameServerCluster;
import com.google.cloud.gaming.v1.GameServerClusterConnectionInfo;
import com.google.cloud.gaming.v1.GameServerClustersServiceClient;
import com.google.cloud.gaming.v1.GkeClusterReference;
import com.google.cloud.gaming.v1.OperationMetadata;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateCluster {

  public static void createGameServerCluster(
      String projectId, String regionId, String realmId, String clusterId, String gkeName)
      throws InterruptedException, ExecutionException, TimeoutException, IOException {
    // String projectId = "your-project-id";
    // String regionId = "us-central1-f";
    // String realmId = "your-realm-id";
    // String clusterId = "your-game-server-cluster-id";
    // String gkeName = "projects/your-project-id/locations/us-central1/clusters/test";
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (GameServerClustersServiceClient client = GameServerClustersServiceClient.create()) {
      String parent =
          String.format("projects/%s/locations/%s/realms/%s", projectId, regionId, realmId);
      String clusterName = String.format("%s/gameServerClusters/%s", parent, clusterId);

      GameServerCluster gameServerCluster =
          GameServerCluster.newBuilder()
              .setName(clusterName)
              .setConnectionInfo(
                  GameServerClusterConnectionInfo.newBuilder()
                      .setGkeClusterReference(
                          GkeClusterReference.newBuilder().setCluster(gkeName).build())
                      .setNamespace("default"))
              .build();

      CreateGameServerClusterRequest request =
          CreateGameServerClusterRequest.newBuilder()
              .setParent(parent)
              .setGameServerClusterId(clusterId)
              .setGameServerCluster(gameServerCluster)
              .build();

      OperationFuture<GameServerCluster, OperationMetadata> call =
          client.createGameServerClusterAsync(request);

      GameServerCluster created = call.get(1, TimeUnit.MINUTES);
      System.out.println("Game Server Cluster created: " + created.getName());
    }
  }
}

Node.js

Informationen zum Installieren und Verwenden der Clientbibliothek für Game Servers finden Sie unter Game Servers-Clientbibliotheken.

const {
  GameServerClustersServiceClient,
} = require('@google-cloud/game-servers');

const client = new GameServerClustersServiceClient();

async function createGameServerCluster() {
  /**
   * TODO(developer): Uncomment these variables before running the sample.
   */
  // const projectId = 'Your Google Cloud Project ID';
  // const location = 'A Compute Engine region, e.g. "us-central1"';
  // const realmId = 'The ID of the realm to locate this cluster in';
  // const gameClusterId = 'A unique ID for this Game Server Cluster';
  // const gkeClusterName= 'The full resource name of the GKE cluster to use';
  const request = {
    // Provide full resource name of a Game Server Realm
    parent: client.realmPath(projectId, location, realmId),
    gameServerClusterId: gameClusterId,
    gameServerCluster: {
      description: 'My Game Server Cluster',
      connectionInfo: {
        gkeClusterReference: {
          // Provide full resource name of a Kubernetes Engine cluster
          // In the form of 'projects/<project-id>/locations/<location>/clusters/<gke-cluster-name>'
          cluster: gkeClusterName,
        },
        namespace: 'default',
      },
    },
  };

  const [operation] = await client.createGameServerCluster(request);
  const [result] = await operation.promise();

  console.log('Game Server Cluster created:');
  console.log(`\tCluster name: ${result.name}`);
  console.log(`\tCluster description: ${result.description}`);
  console.log(
    `\tGKE cluster: ${result.connectionInfo.gkeClusterReference.cluster}`
  );
}

createGameServerCluster();

Python

Informationen zum Installieren und Verwenden der Clientbibliothek für Game Servers finden Sie unter Game Servers-Clientbibliotheken.

def create_cluster(project_id, location, realm_id, cluster_id, gke_cluster_name):
    """Creates a game server cluster."""

    client = gaming.GameServerClustersServiceClient()

    gke_cluster_reference = game_server_clusters.GkeClusterReference(
        cluster=gke_cluster_name,
    )
    request = game_server_clusters.CreateGameServerClusterRequest(
        parent=f"projects/{project_id}/locations/{location}/realms/{realm_id}",
        game_server_cluster_id=cluster_id,
        game_server_cluster=game_server_clusters.GameServerCluster(
            description="My Game Server Cluster",
            connection_info=game_server_clusters.GameServerClusterConnectionInfo(
                gke_cluster_reference=gke_cluster_reference,
                namespace="default",
            ),
        ),
    )

    operation = client.create_game_server_cluster(request)
    print(f"Create cluster operation: {operation.operation.name}")
    operation.result(timeout=120)

Nachdem Sie einen Gameserver-Cluster erstellt haben, erstellt Game Servers nach Bedarf Agones Fleets und Autoscaler. Game Servers ändert die manuell erstellten Agones Fleets nicht.

Cluster auflisten

Console

  1. Rufen Sie in der Cloud Console die Seite Bereich & Cluster auf.

    Zu Game Servers

  2. Erweitern Sie einen Bereich, um die Game Server-Cluster anzuzeigen, zu denen sie gehören.

  3. Mit dem Filterfeld können Sie die Bereiche und Clusterliste nach verschiedenen Attributen filtern.

gcloud

Mit dem gcloud-Befehlszeilentool können Sie globale oder regionale Cluster auflisten.

Führen Sie den folgenden Befehl aus, um sowohl globale als auch regionale Cluster aufzulisten:

gcloud game servers clusters list

Um Cluster nur einer Region aufzulisten, führen Sie den folgenden Befehl aus und ersetzen Sie region durch die Region, für die Sie die Cluster auflisten möchten.

gcloud game servers clusters list --location=region

Führen Sie den folgenden Befehl aus, um alle Cluster in einem Bereich aufzulisten, und ersetzen Sie realmID durch den übergeordneten Bereich und region durch die Region, für die Sie die Cluster auflisten möchten:

gcloud game servers clusters list --realm=realmID --location=region

REST UND BEFEHLSZEILE

Ersetzen Sie diese Werte in den folgenden Anfragedaten:

  • PROJECT_ID: Ihre Google Cloud-Projekt-ID, die in den IAM-Einstellungen aufgeführt ist
  • REALM_LOCATION: Region für den Bereich oder global
  • REALM_ID: die benutzerdefinierte Kennung für den Bereich

Wenn Sie die Anfrage senden möchten, maximieren Sie eine der folgenden Optionen:

Sie sollten in etwa folgende JSON-Antwort erhalten:

{
  "gameServerClusters": [
    {
      "name": "projects/PROJECT_ID/locations/REALM_LOCATION/realms/REALM_ID/gameServerClusters/my-gs-cluster-1",
      "createTime": CREATE_TIME,
      "updateTime": UPDATE_TIME,
      "connectionInfo": {
        "namespace": "default",
        "gkeClusterReference": {
          "cluster": "projects/PROJECT_ID/locations/GKE_CLUSTER_LOCATION/clusters/my-gke-cluster-1"
        }
      },
      "etag": "8mBC7IJJFvY40k-rBabOOaGR6sSRG3dP6pI-frTuu9Y",
      "clusterState": {
        "agonesVersionInstalled": "1.15.0",
        "kubernetesVersionInstalled": "1.18.20-gke.900",
        "installationState": "AGONES_KUBERNETES_VERSION_SUPPORTED",
        "provider": "gke"
      }
    },
    {
      "name": "projects/PROJECT_ID/locations/REALM_LOCATION/realms/REALM_ID/gameServerClusters/my-gs-cluster-2",
      "createTime": CREATE_TIME,
      "updateTime": UPDATE_TIME,
      "connectionInfo": {
        "namespace": "default",
        "gkeClusterReference": {
          "cluster": "projects/PROJECT_ID/locations/GKE_CLUSTER_LOCATION/clusters/my-gke-cluster-2"
        }
      },
      "etag": "8mBC7IJJFvY40k-rBabOOaGR6sSRG3dP6pI-frTuu9Y",
      "clusterState": {
        "agonesVersionInstalled": "1.15.0",
        "kubernetesVersionInstalled": "1.18.20-gke.900",
        "installationState": "AGONES_KUBERNETES_VERSION_SUPPORTED",
        "provider": "gke"
      }
    }
  ]
}

Go

Informationen zum Installieren und Verwenden der Clientbibliothek für Game Servers finden Sie unter Game Servers-Clientbibliotheken.


import (
	"context"
	"fmt"
	"io"

	gaming "cloud.google.com/go/gaming/apiv1"
	"google.golang.org/api/iterator"
	gamingpb "google.golang.org/genproto/googleapis/cloud/gaming/v1"
)

// listGameServerClusters lists the clusters registered with a realm.
func listGameServerClusters(w io.Writer, projectID, location, realmID string) error {
	// projectID := "my-project"
	// location := "global"
	// realmID := "myrealm"
	ctx := context.Background()
	client, err := gaming.NewGameServerClustersClient(ctx)
	if err != nil {
		return fmt.Errorf("NewGameServerClustersClient: %v", err)
	}
	defer client.Close()

	req := &gamingpb.ListGameServerClustersRequest{
		Parent: fmt.Sprintf("projects/%s/locations/%s/realms/%s", projectID, location, realmID),
	}

	it := client.ListGameServerClusters(ctx, req)
	for {
		resp, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return fmt.Errorf("Next: %v", err)
		}

		fmt.Fprintf(w, "Cluster listed: %v\n", resp.Name)
	}

	return nil
}

Java

Informationen zum Installieren und Verwenden der Clientbibliothek für Game Servers finden Sie unter Game Servers-Clientbibliotheken.


import com.google.cloud.gaming.v1.GameServerCluster;
import com.google.cloud.gaming.v1.GameServerClusterView;
import com.google.cloud.gaming.v1.GameServerClustersServiceClient;
import com.google.cloud.gaming.v1.GameServerClustersServiceClient.ListGameServerClustersPagedResponse;
import com.google.cloud.gaming.v1.ListGameServerClustersRequest;
import com.google.cloud.gaming.v1.RealmName;
import com.google.common.base.Strings;
import java.io.IOException;

public class ListClusters {

  public static void listGameServerClusters(String projectId, String regionId, String realmId)
      throws IOException {
    // String projectId = "your-project-id";
    // String regionId = "us-central1-f";
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (GameServerClustersServiceClient client = GameServerClustersServiceClient.create()) {
      ListGameServerClustersRequest request =
          ListGameServerClustersRequest.newBuilder()
              .setParent(RealmName.of(projectId, regionId, realmId).toString())
              .setView(GameServerClusterView.FULL)
              .build();
      ListGameServerClustersPagedResponse response = client.listGameServerClusters(request);
      for (GameServerCluster cluster : response.iterateAll()) {
        System.out.println("Game Server Cluster found: " + cluster.getName());
        System.out.println(
            "Cluster installed Agones version: "
                + cluster.getClusterState().getAgonesVersionInstalled());
        System.out.println(
            "Cluster installed Kubernetes version: "
                + cluster.getClusterState().getKubernetesVersionInstalled());
        System.out.println(
            "Cluster installation state: " + cluster.getClusterState().getInstallationState());
      }

      while (!Strings.isNullOrEmpty(response.getNextPageToken())) {
        ListGameServerClustersRequest request2 =
            ListGameServerClustersRequest.newBuilder()
                .setParent(RealmName.of(projectId, regionId, realmId).toString())
                .setPageToken(response.getNextPageToken())
                .build();
        response = client.listGameServerClusters(request2);
        for (GameServerCluster cluster : response.iterateAll()) {
          System.out.println("Game Server Cluster found: " + cluster.getName());
          System.out.println(
              "Cluster installed Agones version: "
                  + cluster.getClusterState().getAgonesVersionInstalled());
          System.out.println(
              "Cluster installed Kubernetes version: "
                  + cluster.getClusterState().getKubernetesVersionInstalled());
          System.out.println(
              "Cluster installation state: " + cluster.getClusterState().getInstallationState());
        }
      }
    }
  }
}

Node.js

Informationen zum Installieren und Verwenden der Clientbibliothek für Game Servers finden Sie unter Game Servers-Clientbibliotheken.

const {
  GameServerClustersServiceClient,
} = require('@google-cloud/game-servers');

const client = new GameServerClustersServiceClient();

async function listGameServerClusters() {
  /**
   * TODO(developer): Uncomment these variables before running the sample.
   */
  // const projectId = 'Your Google Cloud Project ID';
  // const location = 'A Compute Engine region, e.g. "us-central1"';
  // const realmId = 'The ID of the realm to locate this cluster in';
  const request = {
    // Provide full resource name of a Game Server Realm
    parent: client.realmPath(projectId, location, realmId),
    view: 'FULL',
  };

  const results = await client.listGameServerClusters(request);
  const [clusters] = results;

  for (const cluster of clusters) {
    console.log('Game Server Cluster:');
    console.log(`\tCluster name: ${cluster.name}`);
    console.log(`\tCluster description: ${cluster.description}`);
    console.log(
      `\tCluster installed Agones version: ${cluster.clusterState.agonesVersionInstalled}`
    );
    console.log(
      `\tCluster installed Kubernetes version: ${cluster.clusterState.kubernetesVersionInstalled}`
    );
    console.log(
      `\tCluster installation state: ${cluster.clusterState.installationState}`
    );
    console.log(
      `\tGKE cluster: ${cluster.connectionInfo.gkeClusterReference.cluster}`
    );
  }
}

listGameServerClusters();

Python

Informationen zum Installieren und Verwenden der Clientbibliothek für Game Servers finden Sie unter Game Servers-Clientbibliotheken.

def list_clusters(project_id, location, realm_id):
    """Lists the existing game server clusters."""

    client = gaming.GameServerClustersServiceClient()

    response = client.list_game_server_clusters(
        parent=f"projects/{project_id}/locations/{location}/realms/{realm_id}"
    )

    for cluster in response.game_server_clusters:
        print(f"Name: {cluster.name}")

    return response.game_server_clusters

Details zu einem Cluster ansehen

Console

  1. Rufen Sie in der Cloud Console die Seite Bereich & Cluster auf.

    Zu Game Servers

  2. Erweitern Sie einen Bereich, um die Game Server-Cluster anzuzeigen, zu denen sie gehören.

  3. Klicken Sie in der letzten Tabellenspalte für den Bereich auf die drei Punkte und wählen Sie Details ansehen aus.

gcloud

Mit dem gcloud-Befehlszeilentool erhalten Sie Details zu einem Cluster oder GKE-Cluster, z. B. die Erstellungszeit:

Führen Sie den folgenden Befehl aus, um die Details eines Clusters aufzurufen, und ersetzen Sie die Platzhalterwerte wie realmID durch die entsprechenden Werte:

gcloud game servers clusters describe gscID --realm realmID --location=region

Die Ausgabe enthält die Details des Clusters.

Die Variablenplatzhalter entsprechen den folgenden Beschreibungen:

  • gscID ist die eindeutige Kennung, die Sie für diesen Gameserver-Cluster angegeben haben.
  • realmID ist eine eindeutige Kennung für den Bereich, in dem Ihr Cluster gespeichert ist.
  • region ist die Region des Clusters. Wählen Sie dieselbe Region aus wie die des übergeordneten Bereichs.

REST UND BEFEHLSZEILE

Ersetzen Sie diese Werte in den folgenden Anfragedaten:

  • PROJECT_ID: Ihre Google Cloud-Projekt-ID, die in den IAM-Einstellungen aufgeführt ist
  • REALM_LOCATION: Region für den Bereich oder global
  • REALM_ID: die benutzerdefinierte Kennung für den Bereich
  • GS_CLUSTER_ID: die benutzerdefinierte Kennung für den Cluster

Wenn Sie die Anfrage senden möchten, maximieren Sie eine der folgenden Optionen:

Sie sollten in etwa folgende JSON-Antwort erhalten:

{
  "name": "projects/PROJECT_ID/locations/REALM_LOCATION/realms/REALM_ID/gameServerClusters/GS_CLUSTER_ID",
  "createTime": CREATE_TIME,
  "updateTime": UPDATE_TIME,
  "connectionInfo": {
    "namespace": "default",
    "gkeClusterReference": {
      "cluster": "projects/PROJECT_ID/locations/GKE_CLUSTER_LOCATION/clusters/MY_GKE_CLUSTER"
    }
  },
  "etag": "8mBC7IJJFvY40k-rBabOOaGR6sSRG3dP6pI-frTuu9Y",
  "clusterState": {
    "agonesVersionInstalled": "1.15.0",
    "kubernetesVersionInstalled": "1.18.20-gke.900",
    "installationState": "AGONES_KUBERNETES_VERSION_SUPPORTED",
    "provider": "gke"
  }
}

Go

Informationen zum Installieren und Verwenden der Clientbibliothek für Game Servers finden Sie unter Game Servers-Clientbibliotheken.


import (
	"context"
	"fmt"
	"io"

	gaming "cloud.google.com/go/gaming/apiv1"
	gamingpb "google.golang.org/genproto/googleapis/cloud/gaming/v1"
)

// getGameServerCluster retrieves info on a game server cluster.
func getGameServerCluster(w io.Writer, projectID, location, realmID, clusterID string) error {
	// projectID := "my-project"
	// location := "global"
	// realmID := "myrealm"
	// clusterID := "mycluster"
	ctx := context.Background()
	client, err := gaming.NewGameServerClustersClient(ctx)
	if err != nil {
		return fmt.Errorf("NewGameServerClustersClient: %v", err)
	}
	defer client.Close()

	req := &gamingpb.GetGameServerClusterRequest{
		Name: fmt.Sprintf("projects/%s/locations/%s/realms/%s/gameServerClusters/%s", projectID, location, realmID, clusterID),
	}

	resp, err := client.GetGameServerCluster(ctx, req)
	if err != nil {
		return fmt.Errorf("GetGameServerCluster: %v", err)
	}

	fmt.Fprintf(w, "Cluster retrieved: %v", resp.Name)
	return nil
}

Java

Informationen zum Installieren und Verwenden der Clientbibliothek für Game Servers finden Sie unter Game Servers-Clientbibliotheken.


import com.google.cloud.gaming.v1.GameServerCluster;
import com.google.cloud.gaming.v1.GameServerClusterName;
import com.google.cloud.gaming.v1.GameServerClusterView;
import com.google.cloud.gaming.v1.GameServerClustersServiceClient;
import com.google.cloud.gaming.v1.GetGameServerClusterRequest;
import java.io.IOException;

public class GetCluster {

  public static void getGameServerCluster(
      String projectId, String regionId, String realmId, String clusterId) throws IOException {
    // String projectId = "your-project-id";
    // String regionId = "us-central1-f";
    // String realmId = "your-realm-id";
    // String clusterId = "your-game-server-cluster-id";
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (GameServerClustersServiceClient client = GameServerClustersServiceClient.create()) {
      GetGameServerClusterRequest request =
          GetGameServerClusterRequest.newBuilder()
              .setName(GameServerClusterName.of(projectId, regionId, realmId, clusterId).toString())
              .setView(GameServerClusterView.FULL)
              .build();
      GameServerCluster cluster = client.getGameServerCluster(request);

      System.out.println("Game Server Cluster found: " + cluster.getName());
      System.out.println(
          "Cluster installed Agones version: "
              + cluster.getClusterState().getAgonesVersionInstalled());
      System.out.println(
          "Cluster installed Kubernetes version: "
              + cluster.getClusterState().getKubernetesVersionInstalled());
      System.out.println(
          "Cluster installation state: " + cluster.getClusterState().getInstallationState());
    }
  }
}

Node.js

Informationen zum Installieren und Verwenden der Clientbibliothek für Game Servers finden Sie unter Game Servers-Clientbibliotheken.

const {
  GameServerClustersServiceClient,
} = require('@google-cloud/game-servers');

const client = new GameServerClustersServiceClient();

async function getGameServerCluster() {
  /**
   * TODO(developer): Uncomment these variables before running the sample.
   */
  // const projectId = 'Your Google Cloud Project ID';
  // const location = 'A Compute Engine region, e.g. "us-central1"';
  // const realmId = 'The ID of the realm to locate this cluster in';
  // const gameClusterId = 'The unique ID for this Game Server Cluster';
  const request = {
    // Provide full resource name of a Game Server Realm
    name: client.gameServerClusterPath(
      projectId,
      location,
      realmId,
      gameClusterId
    ),
    view: 'FULL',
  };

  const [cluster] = await client.getGameServerCluster(request);

  console.log('Game Server Cluster:');
  console.log(`\tCluster name: ${cluster.name}`);
  console.log(`\tCluster description: ${cluster.description}`);
  console.log(
    `\tCluster installed Agones version: ${cluster.clusterState.agonesVersionInstalled}`
  );
  console.log(
    `\tCluster installed Kubernetes version: ${cluster.clusterState.kubernetesVersionInstalled}`
  );
  console.log(
    `\tCluster installation state: ${cluster.clusterState.installationState}`
  );
  console.log(
    `\tGKE cluster: ${cluster.connectionInfo.gkeClusterReference.cluster}`
  );
}

getGameServerCluster();

Python

Informationen zum Installieren und Verwenden der Clientbibliothek für Game Servers finden Sie unter Game Servers-Clientbibliotheken.

def get_cluster(project_id, location, realm_id, cluster_id):
    """Gets a game server cluster."""

    client = gaming.GameServerClustersServiceClient()

    request = game_server_clusters.GetGameServerClusterRequest(
        name=f"projects/{project_id}/locations/{location}/realms/{realm_id}/gameServerClusters/{cluster_id}",
    )

    response = client.get_game_server_cluster(request)
    print(f"Get cluster response:\n{response}")
    return response

Fehlerbehebung

IAM-Berechtigungsfehler

Wenn die Berechtigungen nicht richtig festgelegt wurden, wird folgende Fehlermeldung angezeigt:

Cannot connect to the provided Kubernetes cluster "projects/projectId/locations/location/clusters/gkeCluster", make sure that "service-projectNumber@gcp-sa-gameservices.iam.gserviceaccount.com" has been granted the required permissions to access the cluster

Führen Sie in diesem Fall den in diesem Abschnitt beschriebenen Schritt zum Festlegen von IAM-Berechtigungen aus.

Wenn Sie Game Servers-Ressourcen in einem Google Cloud-Projekt erstellen, erstellt Game Servers auch ein von Google verwaltetes Dienstkonto im Format serviceAccount:service-projectNumber@gcp-sa-gameservices.iam.gserviceaccount.com. Diesem Dienstkonto wird automatisch die vordefinierte Game Servers-Rolle roles/gameservices.serviceAgent zugewiesen. Diese Rolle gibt dem von Google verwalteten Dienstkonto die erforderlichen Berechtigungen zum Verwalten des GKE-Clusters, den Sie registrieren. Wenn Sie dies widerrufen, wird die obige Fehlermeldung angezeigt.

Der folgende Befehl zeigt die nötige Syntax, um dem Dienstkonto die Game Servers-Rolle roles/gameservices.serviceAgent zuzuweisen:

gcloud projects add-iam-policy-binding projectId --role roles/gameservices.serviceAgent --member serviceAccount:service-projectNumber@gcp-sa-gameservices.iam.gserviceaccount.com

wobei

  • projectId ist die ID des Projekts. Sie erhalten projectId, indem Sie gcloud config get-value project ausführen.
  • projectNumber kann durch Ausführen von gcloud projects describe projectId abgerufen werden.

Nächste Schritte

Cluster löschen