Créer ou mettre à jour un déploiement

Cette page explique comment créer, mettre à jour et afficher les détails d'un déploiement de Game Servers dans un déploiement. Un déploiement mappe les configurations de serveur de jeu aux domaines cibles. Pour voir un exemple de bout en bout de la création d'un déploiement, ajouter une configuration, puis la déployer, consultez la section Configurer le comportement du scaling du cluster.


Figure 1. La version 1.0 de Config a été déployée dans les domaines américains, et la version 1.1 a été déployée en Europe et au Japon.

Pour en savoir plus, consultez la page Présentation de Game Servers.

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
    

    curl / PowerShell

    Pour utiliser l'API REST avec curl ou Windows PowerShell, procédez comme suit:

    1. Créer un compte de service
    2. Téléchargez une clé privée en tant que fichier JSON.
    3. Définissez la variable d'environnement GOOGLE_APPLICATION_CREDENTIALS pour qu'elle pointe vers le chemin du fichier JSON contenant la clé de votre compte de service. Cette variable ne s'applique qu'à la session de shell actuelle. Par conséquent, si vous ouvrez une nouvelle session, vous devez de nouveau la définir.

    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.

Mettre à jour un déploiement

Le processus de mise à jour et de création est le même que pour les déploiements classiques. Tout d'abord, assurez-vous d'avoir créé une configuration Game Servers. Si vous souhaitez cibler des domaines spécifiques avec une configuration différente, créez une configuration de remplacement distincte.

Mettre à jour la configuration par défaut d'un déploiement

La configuration du serveur de jeu par défaut est déployée dans tous les domaines. Pour cibler des domaines spécifiques avec une configuration différente, consultez la section Remplacer la configuration pour certains domaines.

Console

  1. Dans Cloud Console, accédez à la page Déploiements de Game Server.

    Accéder à Game Servers

  2. Recherchez un déploiement dans le tableau. Dans la dernière colonne du tableau, cliquez sur les points de suspension , puis sélectionnez Répertorier les configurations. Cette page affiche les configurations actives et inactives du déploiement.

  3. Cliquez sur Gérer le déploiement.

  4. (Facultatif) Dans la liste Sélectionner une configuration, choisissez une configuration par défaut qui s'applique à tous les domaines.

  5. Cliquez sur Enregistrer.

gcloud

Pour mettre à jour la configuration par défaut d'un déploiement de Game Servers à l'aide de l'outil de ligne de commande gcloud, procédez comme suit :

  1. Exécutez la commande suivante après avoir remplacé les valeurs d'espace réservé suivantes :

    • deploymentID est l'identifiant unique du déploiement.
    • configID est un identifiant unique pour la configuration.
    gcloud game servers deployments update-rollout deploymentID --default-config configID --dry-run
    

    Le résultat affiche la valeur targetState afin que vous puissiez prévisualiser les modifications.

  2. Pour appliquer les modifications, exécutez la commande suivante :

    gcloud game servers deployments update-rollout deploymentID --default-config configID --no-dry-run
    

API REST et ligne de commande

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

  • PROJECT_ID: ID de votre projet Google Cloud, répertorié dans les paramètres IAM.
  • DEPLOYMENT_ID: identifiant défini par l'utilisateur pour le déploiement
  • CONFIG_ID: identifiant défini par l'utilisateur pour la configuration

Corps JSON de la requête :

{
  "name": "projects/PROJECT_ID/locations/global/gameServerDeployments/DEPLOYMENT_ID",
  "defaultGameServerConfig": "CONFIG_ID"
}

Pour envoyer votre requête, développez l'une des options suivantes :

Vous devriez recevoir une réponse JSON de ce type :

{
  "name": "projects/PROJECT_ID/locations/global/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.gaming.v1.OperationMetadata",
    "createTime": CREATE_TIME,
    "target": "projects/PROJECT_ID/locations/global/gameServerDeployments/DEPLOYMENT_ID",
    "verb": "update",
    "requestedCancellation": false,
    "apiVersion": "v1"
  },
  "done": false
}

Go

Pour savoir comment installer et utiliser la bibliothèque cliente pour Game Servers, consultez la section Bibliothèques clientes Game Servers.


import (
	"context"
	"fmt"
	"io"

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

// updateRolloutDefaultConfig sets the default config for a game deployment.
func updateRolloutDefaultConfig(w io.Writer, projectID, deploymentID, configID string) error {
	// projectID := "my-project"
	// deploymentID := "mydeployment"
	// configID := "myconfig"
	ctx := context.Background()
	client, err := gaming.NewGameServerDeploymentsClient(ctx)
	if err != nil {
		return fmt.Errorf("NewGameServerDeploymentsClient: %v", err)
	}
	defer client.Close()

	req := &gamingpb.UpdateGameServerDeploymentRolloutRequest{
		Rollout: &gamingpb.GameServerDeploymentRollout{
			Name: fmt.Sprintf("projects/%s/locations/global/gameServerDeployments/%s", projectID, deploymentID),

			DefaultGameServerConfig: configID,
		},
		UpdateMask: &fieldmaskpb.FieldMask{
			Paths: []string{
				"default_game_server_config",
			},
		},
	}

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

	fmt.Fprintf(w, "Deployment rollout updated: %v", resp.Name)
	return nil
}

Node.js

Pour savoir comment installer et utiliser la bibliothèque cliente pour Game Servers, consultez la section Bibliothèques clientes Game Servers.

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

const client = new GameServerDeploymentsServiceClient();

async function rolloutDefaultGameServerDeployment() {
  /**
   * TODO(developer): Uncomment these variables before running the sample.
   */
  // const projectId = 'Your Google Cloud Project ID';
  // const deploymentId = 'A unique ID for the Game Server Deployment';
  // const configId = 'A unique ID for the Game Server Config';
  const request = {
    rollout: {
      name: client.gameServerDeploymentPath(
        projectId,
        'global',
        deploymentId
      ),
      defaultGameServerConfig: configId,
    },
    updateMask: {
      paths: ['default_game_server_config'],
    },
  };

  const [operation] = await client.updateGameServerDeploymentRollout(request);
  const [deployment] = await operation.promise();

  console.log(`Deployment updated: ${deployment.name}`);
}

rolloutDefaultGameServerDeployment();

Python

Pour savoir comment installer et utiliser la bibliothèque cliente pour Game Servers, consultez la section Bibliothèques clientes Game Servers.

def update_rollout_default(project_id, deployment_id, config_id):
    """Update the rollout of a game server deployment to set the default config."""

    client = gaming.GameServerDeploymentsServiceClient()

    # Location is hard coded as global, as game server deployments can
    # only be created in global.  This is done for all operations on
    # game Server deployments, as well as for its child resource types.
    request = game_server_deployments.UpdateGameServerDeploymentRolloutRequest()
    request.rollout.name = f"projects/{project_id}/locations/global/gameServerDeployments/{deployment_id}"
    request.rollout.default_game_server_config = config_id
    request.update_mask = field_mask.FieldMask(paths=["default_game_server_config"])

    operation = client.update_game_server_deployment_rollout(request)
    print(f"Update deployment rollout operation: {operation.operation.name}")
    operation.result(timeout=120)

Effacer la configuration par défaut d'un déploiement

Supprimez la configuration par défaut pour supprimer la configuration de parc pour ce déploiement de tous les clusters Game Servers.

Console

  1. Dans Cloud Console, accédez à la page Déploiements de Game Server.

    Accéder à Game Servers

  2. Recherchez un déploiement dans le tableau. Dans la dernière colonne du tableau, cliquez sur les points de suspension , puis sélectionnez Répertorier les configurations. Cette page affiche les configurations actives et inactives du déploiement.

  3. Cliquez sur Gérer le déploiement.

  4. Dans la liste Sélectionner une configuration, sélectionnez (aucune configuration par défaut).

  5. Cliquez sur Enregistrer.

gcloud

Pour effacer la configuration par défaut d'un déploiement de Game Servers à l'aide de l'outil de ligne de commande gcloud, procédez comme suit :

  1. Exécutez la commande suivante après avoir remplacé la valeur d'espace réservé suivante :

    • deploymentID est l'identifiant unique du déploiement.
    gcloud game servers deployments update-rollout deploymentID --clear-default-config --dry-run
    

    Le résultat affiche la valeur targetState afin que vous puissiez prévisualiser les modifications.

  2. Pour appliquer les modifications, exécutez la commande suivante :

    gcloud game servers deployments update-rollout deploymentID --clear-default-config --no-dry-run
    

API REST et ligne de commande

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

  • PROJECT_ID: ID de votre projet Google Cloud, répertorié dans les paramètres IAM.
  • DEPLOYMENT_ID: identifiant défini par l'utilisateur pour le déploiement

Corps JSON de la requête :

{
  "name": "projects/PROJECT_ID/locations/global/gameServerDeployments/DEPLOYMENT_ID",
  "defaultGameServerConfig": ""
}

Pour envoyer votre requête, développez l'une des options suivantes :

Vous devriez recevoir une réponse JSON de ce type :

{
  "name": "projects/PROJECT_ID/locations/global/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.gaming.v1.OperationMetadata",
    "createTime": CREATE_TIME,
    "target": "projects/PROJECT_ID/locations/global/gameServerDeployments/DEPLOYMENT_ID",
    "verb": "update",
    "requestedCancellation": false,
    "apiVersion": "v1"
  },
  "done": false
}

Go

Pour savoir comment installer et utiliser la bibliothèque cliente pour Game Servers, consultez la section Bibliothèques clientes Game Servers.


import (
	"context"
	"fmt"
	"io"

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

// updateRolloutClearDefaultConfig removes the default config for a game deployment.
func updateRolloutClearDefaultConfig(w io.Writer, projectID, deploymentID string) error {
	// projectID := "my-project"
	// deploymentID := "mydeployment"
	ctx := context.Background()
	client, err := gaming.NewGameServerDeploymentsClient(ctx)
	if err != nil {
		return fmt.Errorf("NewGameServerDeploymentsClient: %v", err)
	}
	defer client.Close()

	req := &gamingpb.UpdateGameServerDeploymentRolloutRequest{
		Rollout: &gamingpb.GameServerDeploymentRollout{
			Name: fmt.Sprintf("projects/%s/locations/global/gameServerDeployments/%s", projectID, deploymentID),

			DefaultGameServerConfig: "",
		},
		UpdateMask: &fieldmaskpb.FieldMask{
			Paths: []string{
				"default_game_server_config",
			},
		},
	}

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

	fmt.Fprintf(w, "Deployment rollout updated: %v", resp.Name)
	return nil
}

Node.js

Pour savoir comment installer et utiliser la bibliothèque cliente pour Game Servers, consultez la section Bibliothèques clientes Game Servers.

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

const client = new GameServerDeploymentsServiceClient();

async function removeRolloutDefaultGameServerDeployment() {
  /**
   * TODO(developer): Uncomment these variables before running the sample.
   */
  // const projectId = 'Your Google Cloud Project ID';
  // const deploymentId = 'A unique ID for the Game Server Deployment';
  const request = {
    rollout: {
      name: client.gameServerDeploymentPath(
        projectId,
        'global',
        deploymentId
      ),
      defaultGameServerConfig: '',
    },
    updateMask: {
      paths: ['default_game_server_config'],
    },
  };

  const [operation] = await client.updateGameServerDeploymentRollout(request);
  const [deployment] = await operation.promise();

  console.log(`Deployment updated: ${deployment.name}`);
}

removeRolloutDefaultGameServerDeployment();

Python

Pour savoir comment installer et utiliser la bibliothèque cliente pour Game Servers, consultez la section Bibliothèques clientes Game Servers.

def update_rollout_remove_default(project_id, deployment_id):
    """Update the rollout of a game server deployment to remove the default config."""

    client = gaming.GameServerDeploymentsServiceClient()

    # Location is hard coded as global, as game server deployments can
    # only be created in global.  This is done for all operations on
    # game server deployments, as well as for its child resource types.
    request = game_server_deployments.UpdateGameServerDeploymentRolloutRequest()
    request.rollout.name = f"projects/{project_id}/locations/global/gameServerDeployments/{deployment_id}"
    request.rollout.default_game_server_config = ""
    request.update_mask = field_mask.FieldMask(paths=["default_game_server_config"])

    operation = client.update_game_server_deployment_rollout(request)
    print(f"Update deployment rollout operation: {operation.operation.name}")
    operation.result(timeout=120)

Remplacer la configuration pour certains domaines

Si vous souhaitez cibler des domaines spécifiques avec une configuration différente, créez une configuration de remplacement distincte, puis sélectionnez un ou plusieurs domaines qui recevront cette configuration de remplacement (et non la configuration par défaut).

Console

  1. Dans Cloud Console, accédez à la page Déploiements de Game Server.

    Accéder à Game Servers

  2. Recherchez un déploiement dans le tableau. Dans la dernière colonne du tableau, cliquez sur les points de suspension , puis sélectionnez Répertorier les configurations. Cette page affiche les configurations actives et inactives du déploiement.

  3. Cliquez sur Gérer le déploiement.

  4. (Facultatif) Dans la liste Sélectionner une configuration, choisissez une configuration par défaut qui s'applique à tous les domaines qui ne correspondent pas à une configuration de remplacement.

  5. Sous Remplacer les configurations, vous pouvez spécifier une ou plusieurs configurations de remplacement ainsi que les domaines à associer.

    1. Sélectionnez une configuration de remplacement dans la liste Config et le domaine à associer à celle-ci dans la liste Realm.
    2. Utilisez les flèches pour modifier l'ordre de priorité des configurations de remplacement dans la liste.
    3. Cliquez sur Ajouter.
  6. Cliquez sur Enregistrer.

gcloud

Pour appliquer des remplacements de configuration à des domaines particuliers à l'aide de l'outil de ligne de commande gcloud, procédez comme suit :

  1. Copiez le code suivant dans un fichier et remplacez les espaces réservés suivants :

    • realmID est l'identifiant complet d'un domaine, tel que projects/<projectID>/locations/<region>/realms/<realmID2>.
    • configID est un identifiant unique pour la configuration.
    - realmsSelector:
        realms:
            - realmID
      configVersion: configID
    
  2. Exécutez la commande suivante après avoir remplacé les valeurs d'espace réservé suivantes :

    • deploymentID est l'identifiant unique du déploiement.
    • configOverrideFile est le chemin d'accès au fichier avec la configuration de remplacement.
    gcloud game servers deployments update-rollout deploymentID --config-overrides-file configOverrideFile --dry-run
    

    Le résultat affiche la valeur targetState afin que vous puissiez prévisualiser les modifications.

  3. Pour appliquer les modifications, exécutez la commande suivante :

    gcloud game servers deployments update-rollout deploymentID --config-overrides-file configOverrideFile  --no-dry-run
    

API REST et ligne de commande

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

  • PROJECT_ID: ID de votre projet Google Cloud, répertorié dans les paramètres IAM.
  • LOCATION: région du domaine (ou global)
  • DEPLOYMENT_ID: identifiant défini par l'utilisateur pour le déploiement
  • REALM_ID: identifiant défini par l'utilisateur pour le domaine
  • OVERRIDE_CONFIG_ID: identifiant défini par l'utilisateur pour la configuration du remplacement.

Corps JSON de la requête :

{
  "name": "projects/PROJECT_ID/locations/global/gameServerDeployments/DEPLOYMENT_ID",
  "gameServerConfigOverrides": [
  {
    "realmsSelector": {
      "realms": [
        "projects/PROJECT_ID/locations/LOCATION/realms/REALM_ID"
      ]
    },
    "configVersion": "OVERRIDE_CONFIG_ID"
  }
  ]
}

Pour envoyer votre requête, développez l'une des options suivantes :

Vous devriez recevoir une réponse JSON de ce type :

{
  "name": "projects/PROJECT_ID/locations/global/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.gaming.v1.OperationMetadata",
    "createTime": CREATE_TIME,
    "target": "projects/PROJECT_ID/locations/global/gameServerDeployments/DEPLOYMENT_ID",
    "verb": "update",
    "requestedCancellation": false,
    "apiVersion": "v1"
  },
  "done": false
}

Go

Pour savoir comment installer et utiliser la bibliothèque cliente pour Game Servers, consultez la section Bibliothèques clientes Game Servers.


import (
	"context"
	"fmt"
	"io"

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

// updateRolloutOverrideConfig sets the override config for a realm.
func updateRolloutOverrideConfig(w io.Writer, projectID, realmLocation, realmID, deploymentID, configID string) error {
	// projectID := "my-project"
	// realmLocation := "global"
	// realmID := "myrealm"
	// deploymentID := "mydeployment"
	// configID := "myconfig"
	ctx := context.Background()
	client, err := gaming.NewGameServerDeploymentsClient(ctx)
	if err != nil {
		return fmt.Errorf("NewGameServerDeploymentsClient: %v", err)
	}
	defer client.Close()

	req := &gamingpb.UpdateGameServerDeploymentRolloutRequest{
		Rollout: &gamingpb.GameServerDeploymentRollout{
			Name: fmt.Sprintf("projects/%s/locations/global/gameServerDeployments/%s", projectID, deploymentID),

			GameServerConfigOverrides: []*gamingpb.GameServerConfigOverride{
				&gamingpb.GameServerConfigOverride{
					Selector: &gamingpb.GameServerConfigOverride_RealmsSelector{
						RealmsSelector: &gamingpb.RealmSelector{
							Realms: []string{
								fmt.Sprintf("projects/%s/locations/%s/realms/%s", projectID, realmLocation, realmID),
							},
						},
					},
					Change: &gamingpb.GameServerConfigOverride_ConfigVersion{
						ConfigVersion: configID,
					},
				},
			},
		},
		UpdateMask: &fieldmaskpb.FieldMask{
			Paths: []string{
				"game_server_config_overrides",
			},
		},
	}

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

	fmt.Fprintf(w, "Deployment rollout updated: %v", resp.Name)
	return nil
}

Node.js

Pour savoir comment installer et utiliser la bibliothèque cliente pour Game Servers, consultez la section Bibliothèques clientes Game Servers.

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

const client = new GameServerDeploymentsServiceClient();

async function rolloutGameServerDeploymentOverride() {
  /**
   * TODO(developer): Uncomment these variables before running the sample.
   */
  // const projectId = 'Your Google Cloud Project ID';
  // const deploymentId = 'A unique ID for the Game Server Deployment';
  // const configId = 'A unique ID for the Game Server Config';
  // const realmId = 'A unique ID for the realm'
  // const realmLocation = 'compute engine region for realm location'
  const request = {
    rollout: {
      name: client.gameServerDeploymentPath(
        projectId,
        'global',
        deploymentId
      ),
      gameServerConfigOverrides: [
        {
          realmsSelector: {
            realms: [client.realmPath(projectId, realmLocation, realmId)],
          },
          configVersion: configId,
        },
      ],
    },
    updateMask: {
      paths: ['game_server_config_overrides'],
    },
  };

  const [operation] = await client.updateGameServerDeploymentRollout(request);
  const [deployment] = await operation.promise();

  console.log(`Deployment updated: ${deployment.name}`);
}

rolloutGameServerDeploymentOverride();

Python

Pour savoir comment installer et utiliser la bibliothèque cliente pour Game Servers, consultez la section Bibliothèques clientes Game Servers.

def update_rollout_override(project_id, deployment_id, config_id, realm_location, realm_id):
    """Update the rollout of a game server deployment to set the override config."""

    client = gaming.GameServerDeploymentsServiceClient()

    # Location is hard coded as global, as game server deployments can
    # only be created in global.  This is done for all operations on
    # game Server deployments, as well as for its child resource types.
    request = game_server_deployments.UpdateGameServerDeploymentRolloutRequest()
    request.rollout.name = f"projects/{project_id}/locations/global/gameServerDeployments/{deployment_id}"
    realm_name = f"projects/{project_id}/locations/{realm_location}/realms/{realm_id}"
    config_override = game_server_deployments.GameServerConfigOverride(
        realms_selector=common.RealmSelector(realms=[realm_name]),
        config_version=config_id,
    )
    request.rollout.game_server_config_overrides = [config_override]
    request.update_mask = field_mask.FieldMask(paths=["game_server_config_overrides"])

    operation = client.update_game_server_deployment_rollout(request)
    print(f"Update deployment rollout operation: {operation.operation.name}")
    operation.result(timeout=120)

Effacer les remplacements de configuration

Supprimez la configuration de remplacement afin de supprimer la configuration de parc pour ce déploiement des domaines ciblés.

Console

  1. Dans Cloud Console, accédez à la page Déploiements de Game Server.

    Accéder à Game Servers

  2. Recherchez un déploiement dans le tableau. Dans la dernière colonne du tableau, cliquez sur les points de suspension , puis sélectionnez Répertorier les configurations. Cette page affiche les configurations actives et inactives du déploiement.

  3. Cliquez sur Gérer le déploiement.

  4. Sous Remplacer les configurations, cliquez sur l'icône de corbeille à côté des configurations de remplacement que vous souhaitez effacer.

  5. Cliquez sur Enregistrer.

gcloud

Pour effacer les remplacements de configuration d'un déploiement de Game Servers à l'aide de l'outil de ligne de commande gcloud :

  1. Exécutez la commande suivante après avoir remplacé la valeur d'espace réservé suivante :

    • deploymentID est l'identifiant unique du déploiement.
    gcloud game servers deployments update-rollout deploymentID --clear-config-overrides --dry-run
    

    Le résultat affiche la valeur targetState afin que vous puissiez prévisualiser les modifications.

  2. Pour appliquer les modifications, exécutez la commande suivante :

    gcloud game servers deployments update-rollout deploymentID --clear-config-overrides --no-dry-run
    

API REST et ligne de commande

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

  • PROJECT_ID: ID de votre projet Google Cloud, répertorié dans les paramètres IAM.
  • DEPLOYMENT_ID: identifiant défini par l'utilisateur pour le déploiement

Corps JSON de la requête :

{
  "name": "projects/PROJECT_ID/locations/global/gameServerDeployments/DEPLOYMENT_ID",
  "gameServerConfigOverrides": []
}

Pour envoyer votre requête, développez l'une des options suivantes :

Vous devriez recevoir une réponse JSON de ce type :

{
  "name": "projects/PROJECT_ID/locations/global/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.gaming.v1.OperationMetadata",
    "createTime": CREATE_TIME,
    "target": "projects/PROJECT_ID/locations/global/gameServerDeployments/DEPLOYMENT_ID",
    "verb": "update",
    "requestedCancellation": false,
    "apiVersion": "v1"
  },
  "done": false
}

Go

Pour savoir comment installer et utiliser la bibliothèque cliente pour Game Servers, consultez la section Bibliothèques clientes Game Servers.


import (
	"context"
	"fmt"
	"io"

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

// updateRolloutClearOverrideConfig removes any config overrides on a game
// server deployment.
func updateRolloutClearOverrideConfig(w io.Writer, projectID, deploymentID string) error {
	// projectID := "my-project"
	// deploymentID := "mydeployment"
	ctx := context.Background()
	client, err := gaming.NewGameServerDeploymentsClient(ctx)
	if err != nil {
		return fmt.Errorf("NewGameServerDeploymentsClient: %v", err)
	}
	defer client.Close()

	req := &gamingpb.UpdateGameServerDeploymentRolloutRequest{
		Rollout: &gamingpb.GameServerDeploymentRollout{
			Name: fmt.Sprintf("projects/%s/locations/global/gameServerDeployments/%s", projectID, deploymentID),
		},
		UpdateMask: &fieldmaskpb.FieldMask{
			Paths: []string{
				"game_server_config_overrides",
			},
		},
	}

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

	fmt.Fprintf(w, "Deployment rollout updated: %v", resp.Name)
	return nil
}

Node.js

Pour savoir comment installer et utiliser la bibliothèque cliente pour Game Servers, consultez la section Bibliothèques clientes Game Servers.

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

const client = new GameServerDeploymentsServiceClient();

async function removeRolloutGameServerDeploymentOverride() {
  /**
   * TODO(developer): Uncomment these variables before running the sample.
   */
  // const projectId = 'Your Google Cloud Project ID';
  // const deploymentId = 'A unique ID for the Game Server Deployment';
  const request = {
    rollout: {
      name: client.gameServerDeploymentPath(
        projectId,
        'global',
        deploymentId
      ),
    },
    updateMask: {
      paths: ['game_server_config_overrides'],
    },
  };

  const [operation] = await client.updateGameServerDeploymentRollout(request);
  const [deployment] = await operation.promise();

  console.log(`Deployment updated: ${deployment.name}`);
}

removeRolloutGameServerDeploymentOverride();

Python

Pour savoir comment installer et utiliser la bibliothèque cliente pour Game Servers, consultez la section Bibliothèques clientes Game Servers.

def update_rollout_remove_override(project_id, deployment_id):
    """Update the rollout of a game server deployment to remove the override config."""

    client = gaming.GameServerDeploymentsServiceClient()

    # Location is hard coded as global, as game server deployments can
    # only be created in global.  This is done for all operations on
    # game Server deployments, as well as for its child resource types.
    request = game_server_deployments.UpdateGameServerDeploymentRolloutRequest()
    request.rollout.name = f"projects/{project_id}/locations/global/gameServerDeployments/{deployment_id}"
    request.rollout.game_server_config_overrides = []
    request.update_mask = field_mask.FieldMask(paths=["game_server_config_overrides"])

    operation = client.update_game_server_deployment_rollout(request)
    print(f"Update deployment rollout operation: {operation.operation.name}")
    operation.result(timeout=120)

Afficher les détails d'un déploiement

Console

  1. Dans Cloud Console, accédez à la page Déploiements de Game Server.

    Accéder à Game Servers

  2. Recherchez un déploiement dans le tableau. Dans la dernière colonne du tableau, cliquez sur les points de suspension , puis sélectionnez Répertorier les configurations. Cette page affiche les configurations actives et inactives du déploiement.

  3. Cliquez sur Gérer le déploiement.

gcloud

Vous pouvez afficher des détails sur un déploiement, tels que les configurations en cours, à l'aide de l'outil de ligne de commande gcloud :

Pour afficher les détails d'un déploiement, exécutez la commande suivante après avoir remplacé la valeur de l'espace réservé suivant :

  • deploymentID est l'identifiant unique pour le déploiement parent.
gcloud game servers deployments describe-rollout deploymentID

Le résultat affiche les détails du déploiement.

Vous pouvez également afficher l'état des clusters du serveur de jeu une fois le déploiement appliqué, à l'aide de l'outil de ligne de commande gcloud :

gcloud game servers deployments fetch-state deploymentID

Le résultat affiche les modifications appliquées par le déploiement sur chaque cluster de serveurs de jeu.

API REST et ligne de commande

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

  • PROJECT_ID: ID de votre projet Google Cloud, répertorié dans les paramètres IAM.
  • DEPLOYMENT_ID: identifiant défini par l'utilisateur pour le déploiement

Pour envoyer votre requête, développez l'une des options suivantes :

Vous devriez recevoir une réponse JSON de ce type :

{
  "name": "projects/PROJECT_ID/locations/global/gameServerDeployments/DEPLOYMENT_ID/rollout",
  "createTime": CREATE_TIME,
  "updateTime": UPDATE_TIME,
  "defaultGameServerConfig": "projects/PROJECT_ID/locations/global/gameServerDeployments/DEPLOYMENT_ID/configs/CONFIG_ID",
  "gameServerConfigOverrides": [
    {
      "realmsSelector": {
        "realms": [
          "projects/PROJECT_ID/locations/LOCATION/realms/REALM_ID"
        ]
      },
      "configVersion": "projects/PROJECT_ID/locations/global/gameServerDeployments/DEPLOYMENT_ID/configs/OVERRIDE_CONFIG_ID"
    }
  ],
  "etag": "cN31kxa6fWHtaZWUnUZ7LfamUN7Ggz13DWS58Sc5jIQ"
}

Go

Pour savoir comment installer et utiliser la bibliothèque cliente pour Game Servers, consultez la section Bibliothèques clientes Game Servers.


import (
	"context"
	"fmt"
	"io"

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

// getGameServerDeploymentRollout retrieves info on a game server deployment's rollout.
func getGameServerDeploymentRollout(w io.Writer, projectID, deploymentID string) error {
	// projectID := "my-project"
	// deploymentID := "mydeployment"
	ctx := context.Background()
	client, err := gaming.NewGameServerDeploymentsClient(ctx)
	if err != nil {
		return fmt.Errorf("NewGameServerDeploymentsClient: %v", err)
	}
	defer client.Close()

	req := &gamingpb.GetGameServerDeploymentRolloutRequest{
		Name: fmt.Sprintf("projects/%s/locations/global/gameServerDeployments/%s", projectID, deploymentID),
	}

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

	fmt.Fprintf(w, "Rollout default: %v\n", resp.DefaultGameServerConfig)
	for _, override := range resp.GameServerConfigOverrides {
		switch override.Selector.(type) {
		case *gamingpb.GameServerConfigOverride_RealmsSelector:
			fmt.Fprint(w, "Override these realms ", override.GetRealmsSelector().Realms)
		default:
			fmt.Fprint(w, "Unknown override selector")
		}

		switch override.Change.(type) {
		case *gamingpb.GameServerConfigOverride_ConfigVersion:
			fmt.Fprint(w, "with this config: ", override.GetConfigVersion())
		default:
			fmt.Fprint(w, "with an unknown override")
		}
		fmt.Fprintln(w)
	}
	return nil
}

Node.js

Pour savoir comment installer et utiliser la bibliothèque cliente pour Game Servers, consultez la section Bibliothèques clientes Game Servers.

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

const client = new GameServerDeploymentsServiceClient();

async function getGameServerDeploymentRollout() {
  /**
   * TODO(developer): Uncomment these variables before running the sample.
   */
  // const projectId = 'Your Google Cloud Project ID';
  // const deploymentId = 'A unique ID for the Game Server Deployment';
  const request = {
    // The full resource name
    name: client.gameServerDeploymentPath(projectId, 'global', deploymentId),
  };

  const [rollout] = await client.getGameServerDeploymentRollout(request);
  console.log(`Rollout name: ${rollout.name}`);
  console.log(`Rollout default: ${rollout.defaultGameServerConfig}`);
  for (const override of rollout.gameServerConfigOverrides) {
    console.log(`Rollout config overrides: ${override.configVersion}`);
    console.log(
      `Rollout realm overrides: ${JSON.stringify(override.realmsSelector)}`
    );
  }

  const updateTime = rollout.updateTime;
  const updateDate = new Date(updateTime.seconds * 1000);
  console.log(`Rollout updated on: ${updateDate.toLocaleDateString()}\n`);
}

getGameServerDeploymentRollout();

Python

Pour savoir comment installer et utiliser la bibliothèque cliente pour Game Servers, consultez la section Bibliothèques clientes Game Servers.

def get_rollout(project_id, deployment_id):
    """Gets the rollout of a game server deployment."""

    client = gaming.GameServerDeploymentsServiceClient()

    # Location is hard coded as global, as game server deployments can
    # only be created in global.  This is done for all operations on
    # game server deployments, as well as for its child resource types.
    request = game_server_deployments.GetGameServerDeploymentRolloutRequest(
        name=f"projects/{project_id}/locations/global/gameServerDeployments/{deployment_id}",
    )

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

Résoudre des problèmes de déploiement

Cette section explique pourquoi Game Servers ne peut pas mettre à jour les clusters de serveurs de jeux. Le problème est souvent dû à une mauvaise configuration Game Servers ou des clusters de serveurs de jeu. Vous pouvez suivre la checklist suivante pour diagnostiquer les problèmes potentiels que vous rencontrez :

  • Vérifiez que les conditions préalables suivantes pour un cluster Agones sont remplies :
    1. Assurez-vous que le cluster est en cours d'exécution et qu'Agones est installé. Pour vérifier que le pod agones-controller est à l'état Running, exécutez la commande suivante :
      kubectl get pods -n agones-system -l agones.dev/role=controller
      
    2. Assurez-vous que l'espace de noms du serveur de jeu dispose des autorisations de contrôle d'accès (RBAC) requises pour le contrôleur Agones.
    3. Assurez-vous que la version installée d'Agones est compatible avec Game Servers.
  • Consultez le guide de dépannage d'Agones.
  • Vérifiez que la ressource de déploiement de Game Servers est correctement configurée :
    1. Si vous utilisez une configuration de remplacement, assurez-vous que le déploiement s'applique au domaine associé au cluster cible.
    2. Assurez-vous que la spécification de parc est correctement configurée. Pour valider les spécifications de votre parc, essayez d'ouvrir manuellement un serveur de jeu.
    3. Si une modification planifiée n'a pas eu lieu, assurez-vous qu'elle est correctement configurée. Le fuseau horaire d'une programmation suit le fuseau horaire du domaine.

Étape suivante

Découvrez comment supprimer une configuration.