クラスタの登録

このページでは、レルムの Game Servers クラスタの登録、一覧表示、詳細表示を行う方法について説明します。

始める前に

始める前に、Game Servers の概要の主なコンセプトを理解しておくことをおすすめします。次のタスクも完了していることを確認してください。

  • Game Services API が有効になっていることを確認します。
  • Game Services API を有効にする
  • Cloud SDK がインストールされたシェルを選択するか、API クライアントを使用します。
  • Cloud Shell

    Cloud Shell を起動するには、次の手順に従います。

    1. Google Cloud Console に移動します。

      Google Cloud Console

    2. コンソールの右上隅にある [Cloud Shell をアクティブにする] ボタン をクリックします。

    コンソールの下部にあるフレーム内で Cloud Shell セッションが開きます。このシェルで gcloud コマンドを実行します。

    ローカルシェル

    gcloud をインストールするには、Cloud SDK をインストールします。これには、gcloud コマンドライン ツールが含まれています。

    gcloud コマンドライン ツールに必要なデフォルトのプロジェクトが設定されていることを確認します(設定されていない場合、後でコマンドごとに --project フラグを明示的に指定する必要があります)。

    gcloud config list project
    

    デフォルト プロジェクトを設定していない場合は、次のコマンドを実行して、デフォルト プロジェクトを設定します。PROJECT_ID は、設定するプロジェクト ID に置き換えてください。

    gcloud config set project PROJECT_ID
    

    次のコマンドを実行して、Cloud SDK のバージョンを確認します。Game Servers では、バージョン 306.0.0 以降の SDK が必要です。

    gcloud version
    

    インストールを更新するには、次のコマンドを実行します。

    gcloud components update
    

    curl / PowerShell

    REST API を curl または Windows PowerShell で使用するには、次の操作を行います。

    1. サービス アカウントを作成する。
    2. 秘密鍵を JSON ファイルとしてダウンロードします。
    3. 環境変数 GOOGLE_APPLICATION_CREDENTIALS を、サービス アカウント キーが含まれる JSON ファイルのパスに設定します。 この変数は現在のシェル セッションにのみ適用されるため、新しいセッションを開く場合は、変数を再度設定します。

    クライアント ライブラリ

    Google Cloud Game Servers は、クライアント ライブラリを使用して、プログラムで制御できます。ライブラリと認証の手順については、クライアント ライブラリの概要をご覧ください。

クラスタの登録

Game Servers のレルムを作成していることを確認します。

Agones がインストールされている Google Kubernetes Engine(GKE)クラスタがない場合は、次の手順を実行します。

  1. Agones 用の公開 Google Kubernetes Engine クラスタとファイアウォール ルールを作成しますKubernetes Engine API を有効にしてください。

    なお、Game Servers では、限定公開クラスタはサポートされていません。

  2. Agones のファイアウォール ルールが有効になっていることを確認します。

    gcloud compute firewall-rules list --filter="name~'game-server.*'"
    

    次の出力が表示されます。

    NAME                               NETWORK  DIRECTION  PRIORITY  ALLOW    DENY  DISABLED
    game-server-firewall-test-cluster  default  INGRESS    1000      udp:7000-8000  False
    
  3. Agones をインストールします。

  4. Agones と Kubernetes クラスタのバージョンが準拠していることと、Agones がagones-system名前空間にインストールされていることを確認します(Agones のインストールの確認をご覧ください)。

Game Servers クラスタの登録

Console

  1. Cloud Console で、[レルムとクラスタ] ページに移動します。

    Game Servers に移動

  2. [Add Game Server Cluster] をクリックします。

  3. [Realms to choose from] リストから、ゲームサーバー クラスタが属するレルムを選択します。[Create a Realm] ボタンをクリックすると、必要に応じてレルムを作成できます。

  4. [続行] をクリックします。

  5. [Game server cluster ID] ボックスに、このゲームサーバー クラスタの一意の識別子を入力します。

  6. [Kubernetes クラスタ] リストで、Agones がインストールされている Kubernetes クラスタを選択します。

  7. [作成] をクリックします。

gcloud

Game Servers クラスタをレルムに登録するには、gcloud コマンドライン ツールを使用します。

グローバル Game Servers クラスタの登録

グローバル Game Servers クラスタを登録するには:

  1. 次のコマンドを実行します。realmID などのプレースホルダの値は、適切な値に置き換えます。

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

    登録する前に新しいクラスタをプレビューできるように、出力では targetState が返されます。

  2. グローバル クラスタを登録して作成するには、次のコマンドを実行します。

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

リージョン Game Servers クラスタの登録

リージョン Game Servers クラスタを登録するには:

  1. 次のコマンドを実行します。realmID などのプレースホルダの値は、適切な値に置き換えます。

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

    新しいクラスタを作成する前にプレビューできるように、出力では targetState が返されます。

  2. リージョン クラスタを登録して作成するには、次のコマンドを実行します。

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

接続しようとしているクラスタを Game Servers が検証できない場合、次のエラーが表示されることがあります。

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

その場合は、gkeCluster の形式が正しいこと、クラスタが projectlocation で存在することを確認してください。

変数のプレースホルダは、次の説明のとおりです。

  • gscID は、このクラスタに指定できる一意の ID です。
  • realmID は、クラスタを保存するレルムの一意の ID です。
  • gkeCluster は、GKE クラスタの完全修飾されたリソースパスです(たとえば、projects/<projectId>/locations/<location>/clusters/<clusterId>)。
  • region は、クラスタのリージョンです。親レルムと同じリージョンを選択します。

REST とコマンドライン

リクエストのデータを使用する前に、次のように置き換えます。

  • PROJECT_ID: IAM 設定に載っている Google Cloud プロジェクト ID。
  • REALM_LOCATION: このクラスタを保存するレルムのリージョンまたは global
  • REALM_ID: このクラスタを保存するレルムの識別子。
  • GS_CLUSTER_ID: クラスタのユーザー定義の識別子。
  • GKE_CLUSTER_LOCATION: GKE クラスタのリージョン
  • GKE_CLUSTER_ID: GKE クラスタの識別子。

JSON 本文をリクエストします。

{
  "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"
    }
  }
}

リクエストを送信するには、次のいずれかのオプションを展開します。

次のような JSON レスポンスが返されます。

{
  "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
}

C#

Game Servers のクライアント ライブラリをインストールして使用する方法については、Game Servers クライアント ライブラリをご覧ください。


using Google.Cloud.Gaming.V1;
using Google.LongRunning;
using System.Threading.Tasks;

public class CreateClusterSample
{
    public async Task<GameServerCluster> CreateClusterAsync(
        string projectId, string regionId, string realmId, string clusterId, string gkeName)
    {
        // Create the client.
        GameServerClustersServiceClient client = await GameServerClustersServiceClient.CreateAsync();

        GameServerCluster cluster = new GameServerCluster()
        {
            GameServerClusterName = GameServerClusterName.FromProjectLocationRealmCluster(projectId, regionId, realmId, clusterId),
            ConnectionInfo = new GameServerClusterConnectionInfo
            {
                GkeClusterReference = new GkeClusterReference
                {
                    Cluster = gkeName
                },
                Namespace = "default"
            }
        };
        CreateGameServerClusterRequest request = new CreateGameServerClusterRequest
        {
            ParentAsRealmName = RealmName.FromProjectLocationRealm(projectId, regionId, realmId),
            GameServerClusterId = clusterId,
            GameServerCluster = cluster
        };

        // Make the request.
        Operation<GameServerCluster, OperationMetadata> response = await client.CreateGameServerClusterAsync(request);

        // Poll until the returned long-running operation is complete.
        Operation<GameServerCluster, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();

        // Retrieve the operation result.
        return completedResponse.Result;
    }
}

Go

Game Servers のクライアント ライブラリをインストールして使用する方法については、Game Servers クライアント ライブラリをご覧ください。


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

Game Servers のクライアント ライブラリをインストールして使用する方法については、Game Servers クライアント ライブラリをご覧ください。


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

Game Servers のクライアント ライブラリをインストールして使用する方法については、Game Servers クライアント ライブラリをご覧ください。

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

Game Servers のクライアント ライブラリをインストールして使用する方法については、Game Servers クライアント ライブラリをご覧ください。

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)

Game Servers クラスタを作成すると、Game Servers によって Agones フリートオートスケーラーが必要に応じて作成されます。Game Servers では、手動で作成された Agones フリートは変更されません。

クラスタの一覧表示

Console

  1. Cloud Console で、[レルムとクラスタ] ページに移動します。

    Game Servers に移動

  2. レルムを展開して、レルムに所属するゲームサーバー クラスタを確認します。

  3. フィルタ ボックスを使用すると、レルムとクラスタのリストをさまざまなプロパティでフィルタリングできます。

gcloud

グローバルまたはリージョンのクラスタの一覧を表示するには、gcloud コマンドライン ツールを使用します。

グローバルとリージョンの両方のクラスタを一覧表示するには、次のコマンドを実行します。オプションの --view=FULL フラグを追加して、クラスタにインストールされている Agones と Kubernetes のバージョンを表示します。

gcloud game servers clusters list [--view=FULL; default="BASIC"]

リージョン内のクラスタのみを一覧表示するには、次のコマンドを実行します。region は、クラスタを一覧表示するリージョンに置き換えます。

gcloud game servers clusters list --location=region [--view=FULL; default="BASIC"]

レルム内のすべてのクラスタを一覧表示するには、次のコマンドを実行します。realmID は、親のレルムに、region は、クラスタを一覧表示するリージョンに置き換えます。

gcloud game servers clusters list --realm=realmID --location=region [--view=FULL; default="BASIC"]

REST とコマンドライン

リクエストのデータを使用する前に、次のように置き換えます。

  • PROJECT_ID: IAM 設定に載っている Google Cloud プロジェクト ID。
  • REALM_LOCATION: レルムのリージョンまたは global
  • REALM_ID: レルムのユーザー定義の識別子。

リクエストを送信するには、次のいずれかのオプションを展開します。

次のような JSON レスポンスが返されます。

{
  "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"
      }
    }
  ]
}

C#

Game Servers のクライアント ライブラリをインストールして使用する方法については、Game Servers クライアント ライブラリをご覧ください。


using Google.Api.Gax;
using Google.Cloud.Gaming.V1;
using System.Collections.Generic;
using System.Linq;

public class ListClustersSample
{
    public IList<GameServerCluster> ListClusters(
        string projectId, string regionId, string realmId)
    {
        // Create the client.
        GameServerClustersServiceClient client = GameServerClustersServiceClient.Create();

        ListGameServerClustersRequest request = new ListGameServerClustersRequest
        {
            ParentAsRealmName = RealmName.FromProjectLocationRealm(projectId, regionId, realmId),
            View = GameServerClusterView.Full
        };

        // Make the request.
        PagedEnumerable<ListGameServerClustersResponse, GameServerCluster> response = client.ListGameServerClusters(request);

        // You could iterate through response and write the cluster.Name and
        // cluster.ClusterState to the console to see the installed versions of Agones
        // and Kubernetes on each cluster.

        // The returned sequence will lazily perform RPCs as it's being iterated over.
        return response.ToList();
    }
}

Go

Game Servers のクライアント ライブラリをインストールして使用する方法については、Game Servers クライアント ライブラリをご覧ください。


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),
		View:   gamingpb.GameServerClusterView_FULL,
	}

	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)
		fmt.Fprintf(w, "Cluster installed Agones version: %v\n", resp.ClusterState.AgonesVersionInstalled)
		fmt.Fprintf(w, "Cluster installed Kubernetes version: %v\n", resp.ClusterState.KubernetesVersionInstalled)
		fmt.Fprintf(w, "Cluster installation state: %v\n", resp.ClusterState.InstallationState)
	}

	return nil
}

Java

Game Servers のクライアント ライブラリをインストールして使用する方法については、Game Servers クライアント ライブラリをご覧ください。


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

Game Servers のクライアント ライブラリをインストールして使用する方法については、Game Servers クライアント ライブラリをご覧ください。

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

Game Servers のクライアント ライブラリをインストールして使用する方法については、Game Servers クライアント ライブラリをご覧ください。

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

    client = gaming.GameServerClustersServiceClient()

    response = client.list_game_server_clusters(
        request=game_server_clusters.ListGameServerClustersRequest(
            parent=f"projects/{project_id}/locations/{location}/realms/{realm_id}",
            view=game_server_clusters.GameServerClusterView.FULL,
        )
    )

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

    return response.game_server_clusters

クラスタの詳細表示

Console

  1. Cloud Console で、[レルムとクラスタ] ページに移動します。

    Game Servers に移動

  2. レルムを展開して、レルムに所属するゲームサーバー クラスタを確認します。

  3. レルムの最後のテーブル列で、省略記号 をクリックして、[詳細を表示] を選択します。

gcloud

作成時間や GKE クラスタの詳細など、クラスタの詳細を表示するには、gcloud コマンドライン ツールを使用します。

クラスタの詳細を表示するには、次のコマンドを実行します。realmID などのプレースホルダ値は、適切な値に置き換えます。

gcloud game servers clusters describe gscID --realm realmID --location=region [--view=FULL; default="BASIC"]

クラスタの詳細が出力に表示されます。オプションの --view=FULL フラグを追加して、クラスタにインストールされている Agones と Kubernetes のバージョンを表示します。

変数のプレースホルダは、次の説明のとおりです。

  • gscID は、この Game Servers クラスタ用に指定した一意の ID です。
  • realmID は、クラスタが保存されているレルムの一意の ID です。
  • region は、クラスタのリージョンです。親レルムと同じリージョンを選択します。

REST とコマンドライン

リクエストのデータを使用する前に、次のように置き換えます。

  • PROJECT_ID: IAM 設定に載っている Google Cloud プロジェクト ID。
  • REALM_LOCATION: レルムのリージョンまたは global
  • REALM_ID: レルムのユーザー定義の識別子。
  • GS_CLUSTER_ID: クラスタのユーザー定義の識別子。

リクエストを送信するには、次のいずれかのオプションを展開します。

次のような JSON レスポンスが返されます。

{
  "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"
  }
}

C#

Game Servers のクライアント ライブラリをインストールして使用する方法については、Game Servers クライアント ライブラリをご覧ください。


using Google.Cloud.Gaming.V1;

public class GetClusterSample
{
    public GameServerCluster GetCluster(
        string projectId, string regionId, string realmId, string clusterId)
    {
        // Create the client.
        GameServerClustersServiceClient client = GameServerClustersServiceClient.Create();

        GetGameServerClusterRequest request = new GetGameServerClusterRequest
        {
            GameServerClusterName = GameServerClusterName.FromProjectLocationRealmCluster(projectId, regionId, realmId, clusterId),
            View = GameServerClusterView.Full
        };

        // Make the request.
        GameServerCluster response = client.GetGameServerCluster(request);

        // You could write response.Name and response.ClusterState to the console
        // to see the installed versions of Agones and Kubernetes on the cluster.

        return response;
    }
}

Go

Game Servers のクライアント ライブラリをインストールして使用する方法については、Game Servers クライアント ライブラリをご覧ください。


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),
		View: gamingpb.GameServerClusterView_FULL,
	}

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

	fmt.Fprintf(w, "Cluster retrieved: %v\n", resp.Name)
	fmt.Fprintf(w, "Cluster installed Agones version: %v\n", resp.ClusterState.AgonesVersionInstalled)
	fmt.Fprintf(w, "Cluster installed Kubernetes version: %v\n", resp.ClusterState.KubernetesVersionInstalled)
	fmt.Fprintf(w, "Cluster installation state: %v\n", resp.ClusterState.InstallationState)
	return nil
}

Java

Game Servers のクライアント ライブラリをインストールして使用する方法については、Game Servers クライアント ライブラリをご覧ください。


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

Game Servers のクライアント ライブラリをインストールして使用する方法については、Game Servers クライアント ライブラリをご覧ください。

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

Game Servers のクライアント ライブラリをインストールして使用する方法については、Game Servers クライアント ライブラリをご覧ください。

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}",
        view=game_server_clusters.GameServerClusterView.FULL,
    )

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

クラスタの更新

gcloud

クラスタのフィールドを更新するには、既存のクラスタの識別子を置き換えてから gcloud game servers clusters update コマンドを実行します。次のコマンドは、クラスタの説明フィールドを更新します。

gcloud game servers clusters update gscID \
    --realm=realmID --location=region \
    --description="My updated description" --no-dry-run

他のクラスタ フィールドのフラグを確認するには、gcloud リファレンスをご覧ください。

REST とコマンドライン

次のサンプルでは、description フィールドを更新します。他のフィールドを更新するには、フィールド名を ?updateMask= クエリ パラメータに追加して、JSON 本文をリクエストします。

リクエストのデータを使用する前に、次のように置き換えます。

  • PROJECT_ID: IAM 設定に載っている Google Cloud プロジェクト ID。
  • REALM_LOCATION: レルムのリージョンまたは global
  • REALM_ID: レルムの識別子。
  • GS_CLUSTER_ID: クラスタのユーザー定義の識別子。

JSON 本文のリクエスト:

{
  "description": "My updated description"
}

リクエストを送信するには、次のいずれかのオプションを展開します。

次のような JSON レスポンスが返されます。

{
  "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": "update",
    "requestedCancellation": false,
    "apiVersion": "v1"
  },
  "done": false
}

C#

Game Servers のクライアント ライブラリをインストールして使用する方法については、Game Servers クライアント ライブラリをご覧ください。


using Google.Cloud.Gaming.V1;
using Google.LongRunning;
using Google.Protobuf.WellKnownTypes;
using System.Threading.Tasks;

public class UpdateClusterSample
{
    public async Task<GameServerCluster> UpdateClusterAsync(
        string projectId, string regionId, string realmId, string clusterId)
    {
        // Create the client.
        GameServerClustersServiceClient client = await GameServerClustersServiceClient.CreateAsync();

        GameServerCluster cluster = new GameServerCluster()
        {
            GameServerClusterName = GameServerClusterName.FromProjectLocationRealmCluster(projectId, regionId, realmId, clusterId)
        };
        cluster.Labels.Add("label-key-1", "label-value-1");
        cluster.Labels.Add("label-key-2", "label-value-2");

        UpdateGameServerClusterRequest request = new UpdateGameServerClusterRequest
        {
            GameServerCluster = cluster,
            UpdateMask = new FieldMask { Paths = { "labels" } }
        };

        // Make the request.
        Operation<GameServerCluster, OperationMetadata> response = await client.UpdateGameServerClusterAsync(request);
        Operation<GameServerCluster, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();

        // Retrieve the operation result. This result will NOT contain the updated labels.
        // If you want to get the updated resource, use a GET request on the resource.
        return completedResponse.Result;
    }
}

Java

Game Servers のクライアント ライブラリをインストールして使用する方法については、Game Servers クライアント ライブラリをご覧ください。


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

public class UpdateCluster {
  public static void updateGameServerCluster(
      String projectId, String regionId, String realmId, String clusterId)
      throws IOException, InterruptedException, ExecutionException, TimeoutException {
    // 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()) {
      String parent =
          String.format("projects/%s/locations/%s/realms/%s", projectId, regionId, realmId);
      String clusterName = String.format("%s/gameServerClusters/%s", parent, clusterId);

      GameServerCluster cluster =
          GameServerCluster.newBuilder().setName(clusterName).putLabels("key", "value").build();

      FieldMask fieldMask = FieldMask.newBuilder().addPaths("labels").build();
      OperationFuture<GameServerCluster, OperationMetadata> call =
          client.updateGameServerClusterAsync(cluster, fieldMask);

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

Node.js

Game Servers のクライアント ライブラリをインストールして使用する方法については、Game Servers クライアント ライブラリをご覧ください。

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

const client = new GameServerClustersServiceClient();

async function updateGameServerCluster() {
  /**
   * 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 of this cluster';
  // const gameClusterId = 'A unique ID for this Game Server Cluster';
  const request = {
    // Provide full resource name of a Game Server Cluster
    gameServerCluster: {
      name: client.gameServerClusterPath(
        projectId,
        location,
        realmId,
        gameClusterId
      ),
      labels: {
        'label-key-1': 'label-value-1',
      },
      description: 'My updated Game Server Cluster',
    },
    updateMask: {
      paths: ['labels', 'description'],
    },
  };

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

  console.log(`Cluster updated: ${result.name}`);
}

updateGameServerCluster();

Python

Game Servers のクライアント ライブラリをインストールして使用する方法については、Game Servers クライアント ライブラリをご覧ください。

def update_cluster(project_id, location, realm_id, cluster_id):
    """Updates a game server cluster."""

    client = gaming.GameServerClustersServiceClient()

    request = game_server_clusters.UpdateGameServerClusterRequest(
        game_server_cluster=game_server_clusters.GameServerCluster(
            name=f"projects/{project_id}/locations/{location}/realms/{realm_id}/gameServerClusters/{cluster_id}",
            labels={"label-key-1": "label-value-1", "label-key-2": "label-value-2"},
        ),
        update_mask=field_mask.FieldMask(paths=["labels"]),
    )

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

トラブルシューティング

IAM 権限エラー

権限が正しく設定されていない場合、次のエラーが表示されます。

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

このエラーが発生した場合は、このセクションの手順に従って IAM 権限を設定してください。

Google Cloud プロジェクトで Game Servers リソースを作成すると、Game Servers によって Game Servers の Google マネージド サービス アカウントserviceAccount:service-projectNumber@gcp-sa-gameservices.iam.gserviceaccount.com という形式をとる)が作成されます。このサービス アカウントには、事前定義された Game Servers roles/gameservices.serviceAgent ロールが自動的に付与されます。このロールにより、登録する GKE クラスタを管理するために必要な権限が Google マネージド サービス アカウントに付与されます。このロールを取り消すと、上記のエラー メッセージが表示されます。

次のコマンドは、サービス アカウントに Game Servers roles/gameservices.serviceAgent のロールを付与する構文を示しています。

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

ここで

  • projectId はプロジェクト ID です。projectId は、gcloud config get-value project を実行して取得できます。
  • gcloud projects describe projectId を実行すると、projectNumber を取得できます。

次のステップ

クラスタを削除する方法を確認する。