Enregistrer un cluster

Cette page explique comment enregistrer, répertorier et afficher les détails d'un cluster Game Servers dans un domaine.

Avant de commencer

Avant de commencer, nous vous recommandons de vous familiariser avec les concepts clés de la page Présentation de Game Servers. Assurez-vous également que vous avez également effectué les tâches suivantes :

  • Assurez-vous d'avoir activé l'API des services de jeux.
  • Activer l'API des services de jeux
  • Choisissez une interface système sur laquelle le SDK Cloud est installé, ou utilisez un client API :
  • Cloud Shell

    Pour lancer Cloud Shell, procédez comme suit :

    1. Accédez à Google Cloud Console.

      Google Cloud Console

    2. Dans l'angle supérieur droit de la console, cliquez sur le bouton Activer Cloud Shell :

    Une session Cloud Shell s'ouvre dans un cadre situé en bas de la console. Cette interface système vous permet d'exécuter les commandes gcloud.

    Interface système locale

    Pour installer gcloud, installez le SDK Cloud, qui inclut l'outil de ligne de commande gcloud.

    Vérifiez que vous avez défini le projet par défaut souhaité pour l'outil de ligne de commande gcloud. Sinon, vous devrez spécifier explicitement l'option --project pour chaque commande ultérieurement :

    gcloud config list project
    

    Si non, vous pouvez exécuter la commande suivante pour définir un projet par défaut, en remplaçant project-id par l'ID de projet souhaité :

    gcloud config set project project-id
    

    Exécutez la commande suivante pour vérifier votre version du SDK Google Cloud. Game Servers nécessite la version 306.0.0 ou une version ultérieure du SDK.

    gcloud version
    

    Pour mettre à jour votre installation, exécutez la commande suivante :

    gcloud components update
    

    Bibliothèque cliente

    Google Cloud Game Servers peut être contrôlé par programmation à l'aide d'une bibliothèque cliente. Pour obtenir des instructions sur l'utilisation de la bibliothèque et l'authentification, consultez la page Présentation des bibliothèques clientes.

Enregistrer un cluster

Assurez-vous d'avoir créé un domaine Game Servers.

Si vous n'avez pas de cluster Google Kubernetes Engine (GKE) avec Agones installé, suivez les guides Créer un cluster Google Kubernetes Engine et Installer Agones. Assurez-vous que les versions de cluster Agones et Kubernetes sont conformes et que vous avez installé Agones dans l'espace de noms agones-system.

Enregistrer un cluster de serveurs de jeu

Commande gcloud

Vous pouvez enregistrer un cluster Game Servers dans un domaine réel à l'aide de l'outil de ligne de commande gcloud.

Enregistrer un cluster global de serveur de jeu

Pour enregistrer un cluster global de serveur de jeu, procédez comme suit :

  1. Exécutez la commande suivante et remplacez les valeurs des espaces réservés tels que realmID par les valeurs appropriées :

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

    Le résultat renvoie le targetState pour vous permettre d'afficher un aperçu du nouveau cluster avant de l'enregistrer.

  2. Pour enregistrer et créer le cluster global, exécutez la commande suivante :

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

Enregistrer un cluster régional de serveur de jeux

Pour enregistrer un cluster régional de serveur de jeux, procédez comme suit :

  1. Exécutez la commande suivante et remplacez les valeurs des espaces réservés tels que realmID par les valeurs appropriées :

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

    Le résultat renvoie le targetState pour vous permettre d'afficher un aperçu du nouveau cluster avant de le créer.

  2. Pour enregistrer et créer le cluster régional, exécutez la commande suivante :

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

Si Game Servers ne parvient pas à valider le cluster que vous essayez d'associer, vous pouvez rencontrer l'erreur suivante :

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

Dans ce cas, assurez-vous que gkeCluster est au format correct, et que le cluster existe dans project et à location.

Les espaces réservés de variables correspondent aux descriptions suivantes :

  • gscID est un identifiant unique que vous pouvez spécifier pour ce cluster.
  • realmID est l'identifiant unique du domaine dans lequel vous souhaitez stocker le cluster.
  • gkeCluster est le chemin d'accès complet à la ressource d'un cluster GKE, tel que projects/<projectId>/locations/<location>/clusters/<clusterId>.
  • region est la région du cluster. Choisissez la même région que le domaine parent.

Go


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
}

Node.js

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

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)

Après avoir créé un cluster de serveurs de jeux, Game Servers crée des flottes Agones et des autoscalers, si nécessaire. Game Servers ne modifie pas les flottes Agones créées manuellement.

Répertorier les clusters

Commande gcloud

Vous pouvez répertorier les clusters globaux ou régionaux à l'aide de l'outil de ligne de commande gcloud.

Pour répertorier les clusters globaux et régionaux, exécutez la commande suivante :

gcloud game servers clusters list

Pour répertorier uniquement les clusters d'une région, exécutez la commande suivante et remplacez region par la région dans laquelle vous souhaitez répertorier les clusters :

gcloud game servers clusters list --location=region

Pour répertorier tous les clusters d'un domaine, exécutez la commande suivante et remplacez realmID par le domaine parent et region par la région dans laquelle vous souhaitez répertorier les clusters :

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

Go


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
}

Node.js

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),
  };

  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(
      `\tGKE cluster: ${cluster.connectionInfo.gkeClusterReference.cluster}`
    );
  }
}

listGameServerClusters();

Python

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

Afficher les détails d'un cluster

Commande gcloud

L'outil de ligne de commande gcloud permet d'obtenir des informations sur un cluster, telles que l'heure de création ou les détails du cluster GKE.

Pour afficher les détails d'un cluster, exécutez la commande suivante en remplaçant les valeurs d'espace réservé, telles que realmID par les valeurs appropriées :

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

Le résultat vous donne les détails du cluster.

Les espaces réservés de variables correspondent aux descriptions suivantes :

  • gscID est l'identifiant unique que vous avez spécifié pour ce cluster de serveur de jeux.
  • realmID est un identifiant unique pour le domaine dans lequel votre cluster est stocké.
  • region est la région du cluster. Choisissez la même région que le domaine parent.

Go


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
}

Node.js

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
    ),
  };

  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(
    `\tGKE cluster: ${cluster.connectionInfo.gkeClusterReference.cluster}`
  );
}

getGameServerCluster();

Python

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

Dépannage

Erreur d'autorisation IAM

Si les autorisations ne sont pas définies correctement, le message d'erreur suivant s'affiche :

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

Dans ce cas, effectuez l'étape décrite dans cette section pour définir les autorisations IAM.

Lorsque vous créez des ressources Game Servers dans un projet Google Cloud, Game Servers crée également un Compte de service géré par Google Game Servers qui se présente sous la forme serviceAccount:service-projectNumber@gcp-sa-gameservices.iam.gserviceaccount.com. Le rôle prédéfini Game Servers roles/gameservices.serviceAgent est automatiquement attribué à ce compte de service. Ce rôle fournit au compte de service géré par Google les autorisations nécessaires pour gérer le cluster GKE que vous enregistrez. Si vous le révoquez, le message d'erreur ci-dessus s'affiche.

La commande suivante illustre la syntaxe permettant d'accorder au compte de service le rôle roles/gameservices.serviceAgent Game Servers :

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

où :

  • projectId est l'ID du projet. Vous pouvez obtenir projectId en exécutant la commande gcloud config get-value project.
  • projectNumber peut être récupéré en exécutant la commande gcloud projects describe projectId.

Étape suivante

Découvrez comment supprimer un cluster.