Excluir um cluster do serviço gerenciado do Google Cloud para Apache Kafka

Para excluir um cluster, use o Google Cloud console, a Google Cloud CLI, as bibliotecas de cliente ou a API Managed Kafka. Não é possível usar a API Apache Kafka de código aberto para excluir um cluster.

Papéis e permissões necessários para excluir um cluster

Para receber as permissões necessárias para excluir um cluster, peça ao administrador para conceder a você o papel do IAM de editor de cluster do Kafka gerenciado (roles/managedkafka.clusterEditor) no seu projeto. Para mais informações sobre a concessão de papéis, consulte Gerenciar o acesso a projetos, pastas e organizações.

Esse papel predefinido contém as permissões necessárias para excluir um cluster. Para acessar as permissões exatas que são necessárias, expanda a seção Permissões necessárias:

Permissões necessárias

As permissões a seguir são necessárias para excluir um cluster:

  • Permissão para excluir um cluster: managedkafka.clusters.delete
  • Permissão para listar todos os clusters no local que contém o cluster. Essa permissão só é necessária ao excluir clusters usando o Google Cloud: managedkafka.clusters.list

Essas permissões também podem ser concedidas com funções personalizadas ou outros papéis predefinidos.

O papel de editor de cluster do Kafka gerenciado não permite criar, excluir ou modificar tópicos e grupos de consumidores em clusters do Serviço Gerenciado para Apache Kafka. Ele também não permite o acesso ao plano de dados para publicar ou consumir mensagens em clusters. Para mais informações sobre esse papel, consulte Papéis predefinidos do Serviço Gerenciado para Apache Kafka.

Excluir um cluster

Confira a seguir uma lista de considerações importantes antes de excluir um cluster:

  • Perda de dados: a exclusão de um cluster apaga todos os dados armazenados nele, incluindo tópicos, mensagens, configurações e outros recursos associados. Essa ação é irreversível.

  • Interrupção do serviço: todos os aplicativos ou serviços que dependem do cluster perdem o acesso e sofrem interrupções. Tenha um plano para lidar com essa dependência antes de excluir o cluster.

  • Faturamento: você deixa de receber cobranças pelo cluster depois que ele é excluído. No entanto, ainda é possível que você receba cobranças pelos recursos usados até o momento da exclusão.

  • Operação assíncrona: por padrão, o comando de exclusão opera de forma assíncrona. Ele retorna imediatamente, e você pode acompanhar o progresso da exclusão separadamente.

Para excluir um cluster, siga estas etapas:

Console

  1. No Google Cloud console, acesse a página Clusters.

    Acessar Clusters

  2. Na lista de clusters, selecione o cluster ou os clusters que você quer excluir.

  3. Clique em Excluir.

gcloud

  1. No Google Cloud console, ative o Cloud Shell.

    Ativar o Cloud Shell

    Na parte de baixo do Google Cloud console, uma sessão do Cloud Shell é iniciada e exibe um prompt de linha de comando. O Cloud Shell é um ambiente shell com a Google Cloud CLI já instalada e com valores já definidos para o projeto atual. A inicialização da sessão pode levar alguns segundos.

  2. Execute o gcloud managed-kafka clusters delete comando:

    gcloud managed-kafka clusters delete CLUSTER_ID \
    --location=LOCATION

    Substitua:

    • CLUSTER_ID: o ID ou nome do cluster.
    • LOCATION: o local do cluster.

REST

Antes de usar os dados da solicitação abaixo, faça as substituições a seguir:

  • PROJECT_ID: seu Google Cloud ID do projeto
  • LOCATION: o local do cluster
  • CLUSTER_ID: o ID do cluster

Método HTTP e URL: 

DELETE https://managedkafka.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/clusters/CLUSTER_ID

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

Você receberá uma resposta JSON semelhante a esta:

{
  "name": "projects/PROJECT_ID/locations/LOCATION/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.managedkafka.v1.OperationMetadata",
    "createTime": "CREATE_TIME",
    "target": "projects/PROJECT_ID/locations/LOCATION/clusters/CLUSTER_ID",
    "verb": "delete",
    "requestedCancellation": false,
    "apiVersion": "v1"
  },
  "done": false
}

Go

Antes de testar esta amostra, siga as instruções de configuração para Go em Instalar as bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Go do Serviço Gerenciado para Apache Kafka.

Para fazer a autenticação no Serviço Gerenciado para Apache Kafka, configure as Application Default Credentials(ADC). Para mais informações, consulte Configurar as ADCs para um ambiente de desenvolvimento local.

import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/managedkafka/apiv1/managedkafkapb"
	"google.golang.org/api/option"

	managedkafka "cloud.google.com/go/managedkafka/apiv1"
)

func deleteCluster(w io.Writer, projectID, region, clusterID string, opts ...option.ClientOption) error {
	// projectID := "my-project-id"
	// region := "us-central1"
	// clusterID := "my-cluster"
	ctx := context.Background()
	client, err := managedkafka.NewClient(ctx, opts...)
	if err != nil {
		return fmt.Errorf("managedkafka.NewClient got err: %w", err)
	}
	defer client.Close()

	clusterPath := fmt.Sprintf("projects/%s/locations/%s/clusters/%s", projectID, region, clusterID)
	req := &managedkafkapb.DeleteClusterRequest{
		Name: clusterPath,
	}
	op, err := client.DeleteCluster(ctx, req)
	if err != nil {
		return fmt.Errorf("client.DeleteCluster got err: %w", err)
	}
	err = op.Wait(ctx)
	if err != nil {
		return fmt.Errorf("op.Wait got err: %w", err)
	}
	fmt.Fprint(w, "Deleted cluster\n")
	return nil
}

Java

Antes de testar esta amostra, siga as instruções de configuração para Java em Instalar as bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Java do Serviço Gerenciado para Apache Kafka.

Para fazer a autenticação no Serviço Gerenciado para Apache Kafka, configure as Application Default Credentials. Para mais informações, consulte Configurar as ADCs para um ambiente de desenvolvimento local.


import com.google.api.gax.longrunning.OperationFuture;
import com.google.api.gax.longrunning.OperationSnapshot;
import com.google.api.gax.longrunning.OperationTimedPollAlgorithm;
import com.google.api.gax.retrying.RetrySettings;
import com.google.api.gax.retrying.TimedRetryAlgorithm;
import com.google.api.gax.rpc.ApiException;
import com.google.cloud.managedkafka.v1.ClusterName;
import com.google.cloud.managedkafka.v1.DeleteClusterRequest;
import com.google.cloud.managedkafka.v1.ManagedKafkaClient;
import com.google.cloud.managedkafka.v1.ManagedKafkaSettings;
import com.google.cloud.managedkafka.v1.OperationMetadata;
import com.google.protobuf.Empty;
import java.io.IOException;
import java.time.Duration;

public class DeleteCluster {

  public static void main(String[] args) throws Exception {
    // TODO(developer): Replace these variables before running the example.
    String projectId = "my-project-id";
    String region = "my-region"; // e.g. us-east1
    String clusterId = "my-cluster";
    deleteCluster(projectId, region, clusterId);
  }

  public static void deleteCluster(String projectId, String region, String clusterId)
      throws Exception {

    // Create the settings to configure the timeout for polling operations
    ManagedKafkaSettings.Builder settingsBuilder = ManagedKafkaSettings.newBuilder();
    TimedRetryAlgorithm timedRetryAlgorithm = OperationTimedPollAlgorithm.create(
        RetrySettings.newBuilder()
            .setTotalTimeoutDuration(Duration.ofHours(1L))
            .build());
    settingsBuilder.deleteClusterOperationSettings()
        .setPollingAlgorithm(timedRetryAlgorithm);

    try (ManagedKafkaClient managedKafkaClient = ManagedKafkaClient.create(
        settingsBuilder.build())) {
      DeleteClusterRequest request =
          DeleteClusterRequest.newBuilder()
              .setName(ClusterName.of(projectId, region, clusterId).toString())
              .build();
      OperationFuture<Empty, OperationMetadata> future =
          managedKafkaClient.deleteClusterOperationCallable().futureCall(request);

      // Get the initial LRO and print details. CreateCluster contains sample code for polling logs.
      OperationSnapshot operation = future.getInitialFuture().get();
      System.out.printf("Cluster deletion started. Operation name: %s\nDone: %s\nMetadata: %s\n",
          operation.getName(),
          operation.isDone(),
          future.getMetadata().get().toString());

      future.get();
      System.out.println("Deleted cluster");
    } catch (IOException | ApiException e) {
      System.err.printf("managedKafkaClient.deleteCluster got err: %s", e.getMessage());
    }
  }
}

Python

Antes de testar esta amostra, siga as instruções de configuração para Python em Instalar as bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Python do Serviço Gerenciado para Apache Kafka.

Para fazer a autenticação no Serviço Gerenciado para Apache Kafka, configure as Application Default Credentials. Para mais informações, consulte Configurar as ADCs para um ambiente de desenvolvimento local.

from google.api_core.exceptions import GoogleAPICallError
from google.cloud import managedkafka_v1

# TODO(developer)
# project_id = "my-project-id"
# region = "us-central1"
# cluster_id = "my-cluster"

client = managedkafka_v1.ManagedKafkaClient()

request = managedkafka_v1.DeleteClusterRequest(
    name=client.cluster_path(project_id, region, cluster_id),
)

try:
    operation = client.delete_cluster(request=request)
    print(f"Waiting for operation {operation.operation.name} to complete...")
    operation.result()
    print("Deleted cluster")
except GoogleAPICallError as e:
    print(f"The operation failed with error: {e.message}")

A seguir

Apache Kafka® é uma marca registrada da The Apache Software Foundation ou afiliadas nos Estados Unidos e/ou em outros países.