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

Um cluster do Serviço Gerenciado para Apache Kafka oferece um ambiente para armazenar e processar fluxos de mensagens organizados em tópicos.

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

Antes de começar

Verifique se você tem familiaridade com o seguinte:

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

Para receber as permissões necessárias para criar um cluster, peça ao administrador para conceder a você o papel do IAM de Editor de cluster gerenciado do Kafka (roles/managedkafka.clusterEditor) no 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 criar um cluster. Para acessar as permissões exatas necessárias, expanda a seção Permissões necessárias:

Permissões necessárias

As seguintes permissões são necessárias para criar um cluster:

  • Crie um cluster: managedkafka.clusters.create

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

A função de editor do cluster gerenciado do Kafka não permite criar, excluir ou modificar tópicos e grupos de consumidores em clusters do Serviço gerenciado para Apache Kafka. Também não permite que o plano de dados publique ou consuma mensagens em clusters. Para mais informações sobre essa função, consulte Funções predefinidas do Managed Service para Apache Kafka.

Propriedades de um cluster do serviço gerenciado para Apache Kafka

Ao criar ou atualizar um cluster do Serviço gerenciado para Apache Kafka, é necessário especificar as seguintes propriedades.

Nome do cluster

O nome ou ID do cluster do serviço gerenciado para Apache Kafka que você está criando. Para conferir as diretrizes de nomeação de clusters, acesse Diretrizes de nomeação de recursos do Serviço gerenciado para Apache Kafka. O nome de um cluster é imutável.

Local

O local em que você está criando o disco. O local precisa ser uma das regiões Google Cloud compatíveis. Ele não pode ser modificado depois. Para uma lista de locais disponíveis, consulte Locais do Serviço gerenciado para Apache Kafka.

Configuração de capacidade

A configuração da capacidade exige que você defina o número de vCPUs e a quantidade de memória para sua configuração do Kafka. Para mais informações sobre como configurar a capacidade de um cluster, consulte Planejar o tamanho do cluster do Kafka.

Estas são as propriedades para configuração de capacidade:

  • vCPUs: o número de vCPUs no cluster. São necessárias pelo menos três vCPUs por cluster.

  • Memória: a quantidade de memória atribuída ao cluster. É necessário provisionar entre 1 GiB e 8 GiB por vCPU.

    Por exemplo, se você criar um cluster com 6 vCPUs, a memória mínima que poderá ser alocada será de 6 GiB (1 GiB por vCPU) e a máxima será de 48 GiB (8 GiB por vCPU).

Para mais informações sobre como mudar a memória e o número de vCPUs depois que um cluster é criado, consulte Atualizar o tamanho do cluster.

Configuração de rede

A configuração de rede é uma lista de sub-redes VPC em que o cluster está acessível. Para produzir ou consumir mensagens, os clientes precisam acessar uma dessas sub-redes.

Confira algumas diretrizes para a configuração de rede:

  • É necessário ter pelo menos uma sub-rede para um cluster. O máximo é 10.

  • É permitida exatamente uma sub-rede por rede para qualquer cluster.

  • Cada sub-rede precisa estar na mesma região que o cluster. O projeto e a rede podem ser diferentes.

  • Os endereços IP dos brokers e do servidor bootstrap são alocados automaticamente em cada sub-rede. Além disso, as entradas de DNS para esses endereços IP são criadas nas redes VPC correspondentes.

  • Se você adicionar uma sub-rede de um projeto diferente, conceda permissões à conta de serviço gerenciado pelo Google associada ao cluster. Para mais informações, consulte Conectar um cluster entre projetos.

Depois de criar o cluster, é possível atualizar a lista de sub-redes. Para mais informações sobre rede, consulte Configurar rede para o serviço gerenciado para Apache Kafka.

Rótulos

Os rótulos são pares de chave-valor que ajudam na organização e identificação. Os rótulos permitem categorizar recursos com base no ambiente. Exemplos são "env:production" e "owner:data-engineering".

É possível filtrar e pesquisar recursos com base nos rótulos deles. Por exemplo, suponha que você tenha vários clusters do Managed Service para Apache Kafka em diferentes departamentos. Você pode configurar e pesquisar clusters com o rótulo "department:marketing" para encontrar o relevante rapidamente.

Configuração de reequilíbrio

Essa configuração determina se o serviço rebalanceia automaticamente as réplicas de partição entre os brokers.

Os modos disponíveis são:

  • Rebalanceamento automático ao aumentar a escala: quando essa opção está ativada, o serviço aciona automaticamente um rebalanceamento de réplicas quando você escalonar verticalmente do cluster. Esse modo ajuda a manter uma distribuição de carga uniforme, mas pode afetar temporariamente o desempenho durante a operação de rebalanceamento.

  • Sem rebalanceamento: quando essa opção está ativada, o serviço não rebalanceia as réplicas automaticamente.

Criptografia

O Serviço gerenciado para Apache Kafka pode criptografar mensagens com Google-owned and Google-managed encryption keys (padrão) ou chaves de criptografia gerenciadas pelo cliente (CMEK). Todas as mensagens são criptografadas em repouso e em trânsito. O tipo de criptografia de um cluster é imutável.

Google-owned and Google-managed encryption keys são usados por padrão. Essas chaves são criadas, gerenciadas e armazenadas totalmente pelo Google Cloud na infraestrutura dele.

As CMEKs são chaves de criptografia gerenciadas pelo Cloud Key Management Service. Com esse recurso, você tem mais controle sobre as chaves usadas para criptografar dados em repouso nos serviços compatíveis do Google Cloud . O uso da CMEK gera custos adicionais relacionados ao Cloud Key Management Service. Para usar a CMEK, seu keyring precisa estar no mesmo local dos recursos com que você o usa. Para mais informações, consulte Configurar a criptografia de mensagens.

Configuração de mTLS

Como opção, você pode configurar o mTLS como um método de autenticação alternativo que usa certificados do cliente. A configuração inclui o seguinte:

  • Pools de CA: uma lista de um a dez pools do Certificate Authority Service (CAS) em que o cluster confia para autenticação do cliente.

  • Regras de mapeamento principal do SSL: uma propriedade do broker ssl.principal.mapping.rules opcional, mas recomendada, para simplificar nomes principais de certificados longos para uso em ACLs do Kafka.

Para mais informações sobre o mTLS, consulte Configurar a autenticação mTLS.

Criar um cluster

Antes de criar um cluster, consulte a documentação de propriedades do cluster.

A criação de um cluster geralmente leva de 20 a 30 minutos.

Para criar um cluster, siga estas etapas:

Console

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

    Acessar Clusters

  2. Selecione Criar.

    A página Criar cluster do Kafka é aberta.

  3. Em Nome do cluster, insira uma string.

    Para mais informações sobre como nomear um cluster, consulte Diretrizes de nomeação de um recurso do Serviço gerenciado para Apache Kafka.

  4. Em Local, insira um local compatível.

    Para mais informações sobre os locais compatíveis, consulte Locais compatíveis com o Serviço gerenciado para Apache Kafka.

  5. Em Configuração de capacidade, insira valores para Memória e vCPUs.

    Para mais informações sobre como dimensionar um cluster do Serviço gerenciado para Apache Kafka, consulte Planejar o tamanho do cluster do Kafka.

  6. Em Configuração de rede, insira os seguintes detalhes:

    1. Projeto: o projeto em que a sub-rede está localizada. A sub-rede precisa estar na mesma região do cluster, mas o projeto pode ser diferente.
    2. Rede: a rede a que a sub-rede está conectada.
    3. Sub-rede: o nome da sub-rede.
    4. Caminho de URI da sub-rede: este campo é preenchido automaticamente. Ou insira o caminho da sub-rede aqui. O nome da sub-rede precisa estar no formato: projects/PROJECT_ID/regions/REGION/subnetworks/SUBNET_ID.
    5. Clique em Concluído.

  7. (Opcional) Adicione outras sub-redes clicando em Adicionar uma sub-rede conectada.

    É possível adicionar até 10 sub-redes.

  8. Mantenha os outros valores padrão.

  9. Clique em Criar.

gcloud

  1. In the Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

    At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

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

    gcloud managed-kafka clusters create CLUSTER_ID \
    --location=LOCATION \
    --cpu=CPU \
    --memory=MEMORY \
    --subnets=SUBNETS \
    --auto-rebalance \
    --encryption-key=ENCRYPTION_KEY \
    --async \
    --labels=LABELS

    Substitua:

    • CLUSTER_ID: o ID ou nome do cluster.

      Para mais informações sobre como nomear um cluster, consulte Diretrizes de nomeação de um recurso do Serviço gerenciado para Apache Kafka.

    • LOCATION: o local do cluster.

      Para mais informações sobre os locais compatíveis, consulte Locais do Serviço gerenciado para Apache Kafka.

    • CPU: o número de vCPUs do cluster.

      Para mais informações sobre como dimensionar um cluster do Serviço gerenciado para Apache Kafka, consulte Planejar o tamanho do cluster do Kafka.

    • MEMORY: a quantidade de memória para o cluster. Use as unidades "MB", "MiB", "GB", "GiB", "TB" ou "TiB". Por exemplo, "10GiB".

    • SUBNETS: a lista de sub-redes a serem conectadas. Use vírgulas para separar vários valores de sub-rede.

      O formato da sub-rede é projects/PROJECT_ID/regions/REGION/subnetworks/SUBNET_ID.

    • auto-rebalance: ativa o reequilíbrio automático de partições de tópicos entre os agentes quando o número de CPUs no cluster muda. Essa opção fica ativada por padrão.

    • ENCRYPTION_KEY: ID da chave de criptografia gerenciada pelo cliente a ser usada no cluster.

      O formato é projects/PROJECT_ID/locations/LOCATION/keyRings/KEY_RING/cryptoKeys/CRYPTO_KEY.

    • --async: permite que o sistema envie a solicitação de criação e retorne imediatamente uma resposta, sem aguardar a conclusão da operação. Com a flag --async, você pode continuar com outras tarefas enquanto a criação do cluster acontece em segundo plano. Se você não usar a flag, o sistema vai aguardar a conclusão da operação antes de retornar uma resposta. Aguarde até que o cluster seja totalmente atualizado antes de continuar com outras tarefas.

    • LABELS: rótulos a serem associados ao cluster.

      Para mais informações sobre o formato dos rótulos, consulte Rótulos.

    Você vai receber uma resposta semelhante a esta:

    Create request issued for: [CLUSTER_ID]
Check operation [projects/PROJECT_ID/locations/LOCATION/operations/OPERATION_ID] for status.

    Armazene o OPERATION_ID para rastrear progress.

    3. REST

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

    • PROJECT_ID: o ID do projeto do Google Cloud
    • LOCATION: o local do cluster
    • CLUSTER_ID: o ID do cluster
    • CPU_COUNT: o número de vCPUs para o cluster
    • MEMORY: a quantidade de memória para o cluster, em bytes. Exemplo: 3221225472.
    • SUBNET_ID: ID da sub-rede a ser conectada. Exemplo: default.

    Método HTTP e URL: 

    POST https://managedkafka.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/clusters?clusterId=CLUSTER_ID

    Corpo JSON da solicitação:

    {
  "capacityConfig": {
    "vcpuCount": CPU_COUNT,
    "memoryBytes": MEMORY
  },
  "gcpConfig": {
    "accessConfig": {
      "networkConfigs": [
        {
          "subnet": "projects/PROJECT_ID/regions/LOCATION/subnetworks/SUBNET_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": "create",
    "requestedCancellation": false,
    "apiVersion": "v1"
  },
  "done": false
}

    Terraform

    É possível usar um recurso do Terraform para criar um cluster.

    resource "google_managed_kafka_cluster" "default" {
  project    = data.google_project.default.project_id # Replace this with your project ID in quotes
  cluster_id = "my-cluster-id"
  location   = "us-central1"
  capacity_config {
    vcpu_count   = 3
    memory_bytes = 3221225472
  }
  gcp_config {
    access_config {
      network_configs {
        subnet = google_compute_subnetwork.default.id
      }
    }
  }
}

    Para saber como aplicar ou remover uma configuração do Terraform, consulte Comandos básicos do Terraform.

    Go

    Antes de testar esta amostra, siga as instruções de configuração do 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 autenticar o Managed Service para Apache Kafka, configure o Application Default Credentials(ADC). Para mais informações, consulte Configurar o ADC 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 createCluster(w io.Writer, projectID, region, clusterID, subnet string, cpu, memoryBytes int64, opts ...option.ClientOption) error {
	// projectID := "my-project-id"
	// region := "us-central1"
	// clusterID := "my-cluster"
	// subnet := "projects/my-project-id/regions/us-central1/subnetworks/default"
	// cpu := 3
	// memoryBytes := 3221225472
	ctx := context.Background()
	client, err := managedkafka.NewClient(ctx, opts...)
	if err != nil {
		return fmt.Errorf("managedkafka.NewClient got err: %w", err)
	}
	defer client.Close()

	locationPath := fmt.Sprintf("projects/%s/locations/%s", projectID, region)
	clusterPath := fmt.Sprintf("%s/clusters/%s", locationPath, clusterID)

	// Memory must be between 1 GiB and 8 GiB per CPU.
	capacityConfig := &managedkafkapb.CapacityConfig{
		VcpuCount:   cpu,
		MemoryBytes: memoryBytes,
	}
	var networkConfig []*managedkafkapb.NetworkConfig
	networkConfig = append(networkConfig, &managedkafkapb.NetworkConfig{
		Subnet: subnet,
	})
	platformConfig := &managedkafkapb.Cluster_GcpConfig{
		GcpConfig: &managedkafkapb.GcpConfig{
			AccessConfig: &managedkafkapb.AccessConfig{
				NetworkConfigs: networkConfig,
			},
		},
	}
	rebalanceConfig := &managedkafkapb.RebalanceConfig{
		Mode: managedkafkapb.RebalanceConfig_AUTO_REBALANCE_ON_SCALE_UP,
	}
	cluster := &managedkafkapb.Cluster{
		Name:            clusterPath,
		CapacityConfig:  capacityConfig,
		PlatformConfig:  platformConfig,
		RebalanceConfig: rebalanceConfig,
	}

	req := &managedkafkapb.CreateClusterRequest{
		Parent:    locationPath,
		ClusterId: clusterID,
		Cluster:   cluster,
	}
	op, err := client.CreateCluster(ctx, req)
	if err != nil {
		return fmt.Errorf("client.CreateCluster got err: %w", err)
	}
	// The duration of this operation can vary considerably, typically taking 10-40 minutes.
	resp, err := op.Wait(ctx)
	if err != nil {
		return fmt.Errorf("op.Wait got err: %w", err)
	}
	fmt.Fprintf(w, "Created cluster: %s\n", resp.Name)
	return nil
}

    Java

    Antes de testar esta amostra, siga as instruções de configuração do 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 autenticar o serviço gerenciado para Apache Kafka, configure o Application Default Credentials. Para mais informações, consulte Configurar o ADC 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.RetryingFuture;
import com.google.api.gax.retrying.TimedRetryAlgorithm;
import com.google.cloud.managedkafka.v1.AccessConfig;
import com.google.cloud.managedkafka.v1.CapacityConfig;
import com.google.cloud.managedkafka.v1.Cluster;
import com.google.cloud.managedkafka.v1.CreateClusterRequest;
import com.google.cloud.managedkafka.v1.GcpConfig;
import com.google.cloud.managedkafka.v1.LocationName;
import com.google.cloud.managedkafka.v1.ManagedKafkaClient;
import com.google.cloud.managedkafka.v1.ManagedKafkaSettings;
import com.google.cloud.managedkafka.v1.NetworkConfig;
import com.google.cloud.managedkafka.v1.OperationMetadata;
import com.google.cloud.managedkafka.v1.RebalanceConfig;
import java.time.Duration;
import java.util.concurrent.ExecutionException;

public class CreateCluster {

  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";
    String subnet = "my-subnet"; // e.g. projects/my-project/regions/my-region/subnetworks/my-subnet
    int cpu = 3;
    long memoryBytes = 3221225472L; // 3 GiB
    createCluster(projectId, region, clusterId, subnet, cpu, memoryBytes);
  }

  public static void createCluster(
      String projectId, String region, String clusterId, String subnet, int cpu, long memoryBytes)
      throws Exception {
    CapacityConfig capacityConfig =
        CapacityConfig.newBuilder().setVcpuCount(cpu).setMemoryBytes(memoryBytes).build();
    NetworkConfig networkConfig = NetworkConfig.newBuilder().setSubnet(subnet).build();
    GcpConfig gcpConfig =
        GcpConfig.newBuilder()
            .setAccessConfig(AccessConfig.newBuilder().addNetworkConfigs(networkConfig).build())
            .build();
    RebalanceConfig rebalanceConfig =
        RebalanceConfig.newBuilder()
            .setMode(RebalanceConfig.Mode.AUTO_REBALANCE_ON_SCALE_UP)
            .build();
    Cluster cluster =
        Cluster.newBuilder()
            .setCapacityConfig(capacityConfig)
            .setGcpConfig(gcpConfig)
            .setRebalanceConfig(rebalanceConfig)
            .build();

    // 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.createClusterOperationSettings()
        .setPollingAlgorithm(timedRetryAlgorithm);

    try (ManagedKafkaClient managedKafkaClient = ManagedKafkaClient.create(
        settingsBuilder.build())) {

      CreateClusterRequest request =
          CreateClusterRequest.newBuilder()
              .setParent(LocationName.of(projectId, region).toString())
              .setClusterId(clusterId)
              .setCluster(cluster)
              .build();

      // The duration of this operation can vary considerably, typically taking between 10-40
      // minutes.
      OperationFuture<Cluster, OperationMetadata> future =
          managedKafkaClient.createClusterOperationCallable().futureCall(request);

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

      while (!future.isDone()) {
        // The pollingFuture gives us the most recent status of the operation
        RetryingFuture<OperationSnapshot> pollingFuture = future.getPollingFuture();
        OperationSnapshot currentOp = pollingFuture.getAttemptResult().get();
        System.out.printf("Polling Operation:\nName: %s\n Done: %s\n",
            currentOp.getName(),
            currentOp.isDone());
      }

      // NOTE: future.get() blocks completion until the operation is complete (isDone =  True)
      Cluster response = future.get();
      System.out.printf("Created cluster: %s\n", response.getName());
    } catch (ExecutionException e) {
      System.err.printf("managedKafkaClient.createCluster got err: %s", e.getMessage());
    }
  }
}

    Python

    Antes de testar esta amostra, siga as instruções de configuração do 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 autenticar o serviço gerenciado para Apache Kafka, configure o Application Default Credentials. Para mais informações, consulte Configurar o ADC 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"
# subnet = "projects/my-project-id/regions/us-central1/subnetworks/default"
# cpu = 3
# memory_bytes = 3221225472

client = managedkafka_v1.ManagedKafkaClient()

cluster = managedkafka_v1.Cluster()
cluster.name = client.cluster_path(project_id, region, cluster_id)
cluster.capacity_config.vcpu_count = cpu
cluster.capacity_config.memory_bytes = memory_bytes
cluster.gcp_config.access_config.network_configs = [
    managedkafka_v1.NetworkConfig(subnet=subnet)
]
cluster.rebalance_config.mode = (
    managedkafka_v1.RebalanceConfig.Mode.AUTO_REBALANCE_ON_SCALE_UP
)

request = managedkafka_v1.CreateClusterRequest(
    parent=client.common_location_path(project_id, region),
    cluster_id=cluster_id,
    cluster=cluster,
)

try:
    operation = client.create_cluster(request=request)
    print(f"Waiting for operation {operation.operation.name} to complete...")
    # The duration of this operation can vary considerably, typically taking 10-40 minutes.
    # We can set a timeout of 3000s (50 minutes).
    response = operation.result(timeout=3000)
    print("Created cluster:", response)
except GoogleAPICallError as e:
    print(f"The operation failed with error: {e.message}")

Monitorar a operação de criação do cluster

Só é possível executar o comando a seguir se você tiver executado a CLI gcloud para criar o cluster.

  • A criação de um cluster geralmente leva de 20 a 30 minutos. Para acompanhar o progresso da criação do cluster, o comando gcloud managed-kafka clusters create usa uma operação de longa duração (LRO, na sigla em inglês), que pode ser monitorada com o seguinte comando:

    gcloud managed-kafka operations describe OPERATION_ID \
    --location=LOCATION

    Substitua:

    • OPERATION_ID com o valor do ID da operação da seção anterior.
    • LOCATION com o valor do local da seção anterior.

Solução de problemas

Confira a seguir alguns erros que podem ocorrer ao criar clusters.

Service agent service-${PROJECT_NUMBER}@gcp-sa-managedkafka.iam.gserviceaccount.com has not been granted the required role cloudkms.cryptoKeyEncrypterDecrypter to encrypt data using the KMS key.

O agente de serviço do Managed Service para Apache Kafka não tem a permissão necessária para acessar a chave do Cloud KMS. Consulte a documentação sobre papéis necessários para configurar a CMEK.

Service does not have permission to retrieve subnet. Please grant service-${PROJECT_NUMBER}@gcp-sa-managedkafka.iam.gserviceaccount.com the managedkafka.serviceAgent role in the IAM policy of the project ${SUBNET_PROJECT} and ensure the Compute Engine API is enabled in project ${SUBNET_PROJECT}

O agente de serviço do Managed Service para Apache Kafka não tem a função necessária para configurar a rede na rede VPC em que os clientes do Kafka são executados. Para mais informações, consulte Conectar um cluster entre projetos.

A seguir

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