Como excluir uma implantação

Esta página explica como excluir uma implantação do Game Servers.

Antes de começar

Antes de começar, recomendamos que você se familiarize com os principais conceitos na Visão geral do Game Servers. Verifique se você também realizou as seguintes tarefas:

  • Verifique se você ativou a API Game Services.
    • Ativar a API Game Services
  • Escolha um shell com a CLI gcloud instalada ou use um cliente de API:

    • Cloud Shell

    Para iniciar o Cloud Shell, execute os seguintes passos:

    1. Acesse o Console do Google Cloud.

      Console do Google Cloud

    2. No canto superior direito do console, clique no botão Ativar Cloud Shell:

    Uma sessão do Cloud Shell é aberta dentro de um quadro inferior no console. Use esse shell para executar comandos gcloud.

    Shell local

    Instale a CLI gcloud.

    Verifique se você definiu o projeto padrão desejado para a CLI do Google Cloud. Caso contrário, será necessário especificar a sinalização --project explicitamente para cada comando mais tarde:

    gcloud config list project

    Caso contrário, execute o seguinte comando para definir um projeto padrão, substituindo PROJECT_ID pelo ID do projeto que você quer:

    gcloud config set project PROJECT_ID

    Execute o comando a seguir para verificar a versão da CLI do Google Cloud. O Game Servers requer a versão 306.0.0 ou mais recente da CLI gcloud. 

    gcloud version

    Para atualizar a instalação, execute o seguinte comando:

    gcloud components update

    curl / PowerShell

    Para usar a API REST com curl ou o Windows PowerShell, faça o seguinte:

    1. Crie uma conta de serviço.
    2. Faça o download de uma chave privada como um arquivo JSON.

    3. Defina a variável de ambiente GOOGLE_APPLICATION_CREDENTIALS como o caminho do arquivo JSON que contém a chave da conta de serviço. Essa variável só se aplica à sessão de shell atual. Dessa maneira, se você abrir uma nova sessão, defina a variável novamente.

    Biblioteca de cliente

    O Game Servers do Google Cloud pode ser controlado de maneira programática usando uma biblioteca de cliente. Consulte Visão geral das bibliotecas de cliente para instruções sobre como usar a biblioteca e fazer a autenticação.

Como excluir uma implantação

Antes de excluir uma implantação do Game Servers, exclua todas as configurações dela.

Console

  1. No Console do Cloud, acesse a página Implantações do servidor de jogos.

    Acessar o Game Servers

  2. É possível usar a caixa de filtro para filtrar a lista de implantações por propriedades diferentes.

  3. Na última coluna da tabela, clique nas reticências e selecione Remover implantação.

gcloud

É possível excluir uma implantação usando a CLI do Google Cloud.

Para excluir uma implantação, execute o seguinte comando e substitua deploymentID pelo identificador de uma implantação que você criou anteriormente:

gcloud game servers deployments delete deploymentID

REST e linha de comando

Antes de usar qualquer um dos dados da solicitação, faça as seguintes substituições:

  • PROJECT_ID: o ID do projeto do Google Cloud listado nas Configurações do IAM
  • DEPLOYMENT_ID: o identificador definido pelo usuário para a implantação

Para enviar a solicitação, expanda uma destas opções:

Você receberá uma resposta JSON semelhante a esta:

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

C#

Para saber como instalar e usar a biblioteca de cliente do Game Servers, consulte as Bibliotecas de cliente do Game Servers. 


using Google.Cloud.Gaming.V1;
using Google.LongRunning;
using Google.Protobuf.WellKnownTypes;

public class DeleteDeploymentSample
{
    public void DeleteDeployment(
        string projectId, string deploymentId)
    {
        // Create the client.
        GameServerDeploymentsServiceClient client = GameServerDeploymentsServiceClient.Create();

        DeleteGameServerDeploymentRequest request = new DeleteGameServerDeploymentRequest
        {
            GameServerDeploymentName = GameServerDeploymentName.FromProjectLocationDeployment(projectId, "global", deploymentId)
        };

        // Make the request.
        Operation<Empty, OperationMetadata> response = client.DeleteGameServerDeployment(request);

        // Poll until the returned long-running operation is complete.
        response.PollUntilCompleted();
    }
}

Go

Para saber como instalar e usar a biblioteca de cliente do Game Servers, consulte as Bibliotecas de cliente do Game Servers. 


import (
	"context"
	"fmt"
	"io"

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

// deleteGameServerDeployment deletes a game server deployment.
func deleteGameServerDeployment(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.DeleteGameServerDeploymentRequest{
		Name: fmt.Sprintf("projects/%s/locations/global/gameServerDeployments/%s", projectID, deploymentID),
	}

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

	fmt.Fprintf(w, "Deployment deleted.")
	return nil
}

Java

Para saber como instalar e usar a biblioteca de cliente do Game Servers, consulte as Bibliotecas de cliente do Game Servers. 


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

public class DeleteDeployment {
  public static void deleteGameServerDeployment(String projectId, String deploymentId)
      throws InterruptedException, ExecutionException, TimeoutException, IOException {
    // String projectId = "your-project-id";
    // String deploymentId = "your-game-server-deployment-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 (GameServerDeploymentsServiceClient client = GameServerDeploymentsServiceClient.create()) {
      String parent = String.format("projects/%s/locations/global", projectId);
      String deploymentName = String.format("%s/gameServerDeployments/%s", parent, deploymentId);

      OperationFuture<Empty, OperationMetadata> call =
          client.deleteGameServerDeploymentAsync(deploymentName);
      call.get(1, TimeUnit.MINUTES);
      System.out.println("Game Server Deployment deleted: " + deploymentName);
    }
  }
}

Node.js

Para saber como instalar e usar a biblioteca de cliente do Game Servers, consulte as Bibliotecas de cliente do Game Servers. 

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

const client = new GameServerDeploymentsServiceClient();

async function deleteGameServerDeployment() {
  /**
   * 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 [operation] = await client.deleteGameServerDeployment(request);
  await operation.promise();

  console.log(`Deployment with name ${request.name} deleted.`);
}

deleteGameServerDeployment();

Python

Para saber como instalar e usar a biblioteca de cliente do Game Servers, consulte as Bibliotecas de cliente do Game Servers. 

def delete_deployment(project_id, deployment_id):
    """Deletes 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.DeleteGameServerDeploymentRequest(
        name=f"projects/{project_id}/locations/global/gameServerDeployments/{deployment_id}",
    )

    operation = client.delete_game_server_deployment(request)
    print(f"Delete deployment operation: {operation.operation.name}")
    operation.result(timeout=120)

Como verificar se a implantação foi excluída

Para verificar se você excluiu a implantação, liste-as usando a CLI do Google Cloud.

Para listar todas as implantações, execute o seguinte comando:

gcloud game servers deployments list

A implantação excluída não aparece mais no resultado do comando.

A seguir

Veja informações sobre registros de auditoria do Game Servers.