Crea un clúster de Google Cloud Managed Service para Apache Kafka

Un clúster de Managed Service para Apache Kafka proporciona un entorno para almacenar y procesar flujos de mensajes organizados en temas.

Para crear un clúster, puedes usar la consola de Google Cloud , Google Cloud CLI, la biblioteca cliente o la API de Kafka administrado. No puedes usar la API de Apache Kafka de código abierto para crear un clúster.

Antes de comenzar

Verifica que conozcas los siguientes conceptos:

Roles y permisos obligatorios para crear un clúster

Para obtener los permisos que necesitas para crear un clúster, pídele a tu administrador que te otorgue el rol de IAM Editor de clústeres de Kafka administrados (roles/managedkafka.clusterEditor) en tu proyecto. Para obtener más información sobre cómo otorgar roles, consulta Administra el acceso a proyectos, carpetas y organizaciones.

Este rol predefinido contiene los permisos necesarios para crear un clúster. Para ver los permisos exactos que son necesarios, expande la sección Permisos requeridos:

Permisos necesarios

Se requieren los siguientes permisos para crear un clúster:

  • Crea un clúster: managedkafka.clusters.create

También puedes obtener estos permisos con roles personalizados o con otros roles predefinidos.

El rol de editor del clúster de Kafka administrado no te permite crear, borrar ni modificar temas ni grupos de consumidores en los clústeres de Managed Service para Apache Kafka. Tampoco permite el acceso al plano de datos para publicar o consumir mensajes dentro de los clústeres. Para obtener más información sobre este rol, consulta Roles predefinidos de Managed Service para Apache Kafka.

Propiedades de un clúster de Managed Service para Apache Kafka

Cuando creas o actualizas un clúster de Managed Service para Apache Kafka, debes especificar las siguientes propiedades.

Nombre del clúster

Es el nombre o ID del clúster de Servicio administrado para Apache Kafka que estás creando. Si necesitas ayuda para asignarle un nombre a un clúster, consulta los Lineamientos para asignarles nombres a los recursos de Servicio administrado para Apache Kafka. Los nombres de clústeres son inmutables.

Ubicación

Es la ubicación donde se creará el clúster. La ubicación debe ser una de las regiones admitidas Google Cloud . No podrás cambiarla más adelante. Para ver la lista de ubicaciones disponibles, consulta las ubicaciones de Managed Service para Apache Kafka.

Configuración de capacidad

La configuración de capacidad requiere que establezcas la cantidad de CPU virtuales y de memoria para tu instancia de Kafka. Si deseas obtener más información para configurar la capacidad de un clúster, consulta Planifica el tamaño de tu clúster de Kafka.

A continuación, se indican las propiedades de la configuración de capacidad:

  • vCPUs: Es la cantidad de CPU virtuales en el clúster. Se requieren al menos 3 CPU virtuales por clúster.

  • Memoria: Es la cantidad de memoria que se asigna al clúster. Debes aprovisionar entre 1 GiB y 8 GiB por CPU virtual.

    Por ejemplo, si creas un clúster con 6 CPU virtuales, la memoria mínima que puedes asignar al clúster es de 6 GiB (1 GiB por CPU virtual) y la máxima es de 48 GiB (8 GiB por CPU virtual).

Para obtener más información sobre cómo cambiar la memoria y la cantidad de CPU virtuales después de crear un clúster, consulta Actualiza el tamaño del clúster.

Configuración de red

La configuración de red es una lista de subredes de VPC donde el clúster es accesible. Para producir o consumir mensajes, los clientes deben poder acceder a una de estas subredes.

A continuación, se incluyen algunos lineamientos para la configuración de tu red:

  • Se requiere un mínimo de una subred para un clúster. La cantidad máxima es diez.

  • Se permite exactamente una subred por red para cualquier clúster determinado.

  • Cada subred debe estar en la misma región que el clúster. El proyecto y la red pueden ser diferentes.

  • Las direcciones IP de los agentes y el servidor de arranque se asignan automáticamente en cada subred. Además, las entradas del DNS para estas direcciones IP se crean en las redes de VPC correspondientes.

  • Si agregas una subred de un proyecto diferente, debes otorgar permisos a la cuenta de servicio administrada por Google que está asociada al clúster. Para obtener más información, consulta Conecta un clúster entre proyectos.

Después de crear el clúster, puedes actualizar la lista de subredes. Para obtener más información sobre las redes, consulta Configura las redes para Managed Service for Apache Kafka.

Etiquetas

Las etiquetas son pares clave-valor que te ayudan con la organización y la identificación. Las etiquetas permiten categorizar los recursos según el entorno. Algunos ejemplos son "env:production" y "owner:data-engineering".

Puedes filtrar y buscar recursos según sus etiquetas. Por ejemplo, supongamos que tienes varios clústeres de Managed Service para Apache Kafka para diferentes departamentos. Puedes configurar y buscar clústeres con la etiqueta "department:marketing" para encontrar rápidamente el que sea pertinente.

Configuración de rebalanceo

Este parámetro de configuración determina si el servicio reequilibra automáticamente las réplicas de particiones entre los intermediarios.

Los modos disponibles son los siguientes:

  • Rebalance automático en el aumento de escala: Cuando esta opción está habilitada, el servicio activa automáticamente un rebalance de las réplicas cuando aumentas la escala del clúster. Este modo ayuda a mantener una distribución uniforme de la carga, pero es posible que afecte temporalmente el rendimiento durante la operación de rebalanceo.

  • No rebalance: Cuando esta opción está habilitada, el servicio no reequilibra automáticamente las réplicas.

Encriptación

Managed Service for Apache Kafka puede encriptar mensajes conGoogle-owned and Google-managed encryption keys (opción predeterminada) o con claves de encriptación administradas por el cliente (CMEK). Todos los mensajes se encriptan en reposo y en tránsito. El tipo de encriptación de un clúster es inmutable.

Google-owned and Google-managed encryption keys se usan de forma predeterminada. Google Cloud crea, administra y almacena estas claves por completo dentro de su infraestructura.

Las CMEK son claves de encriptación que administras con Cloud Key Management Service. Esta función te permite tener un mayor control sobre las claves que se usan para encriptar los datos en reposo en los Google Cloud servicios compatibles. El uso de CMEK genera costos adicionales relacionados con Cloud Key Management Service. Para el uso de CMEK, tu llavero de claves debe estar en la misma ubicación que los recursos con los que lo usas. Para obtener más información, consulta Configura la encriptación de mensajes.

Configuración de mTLS

De manera opcional, puedes configurar mTLS como un método de autenticación alternativo que usa certificados de cliente. La configuración incluye lo siguiente:

  • Grupos de CA: Es una lista de uno a diez grupos de Certificate Authority Service (CAS) en los que confía el clúster para la autenticación del cliente.

  • Reglas de asignación de principal de SSL: Es una propiedad del intermediario ssl.principal.mapping.rules opcional, pero recomendada, para simplificar los nombres principales de certificados largos para su uso en las LCA de Kafka.

Para obtener más información sobre mTLS, consulta Configura la autenticación mTLS.

Crea un clúster

Antes de crear un clúster, revisa la documentación de las propiedades del clúster.

Por lo general, la creación de un clúster tarda entre 20 y 30 minutos.

Para crear un clúster, sigue estos pasos:

Console

  1. En la consola de Google Cloud , ve a la página Clústeres.

    Ir a los clústeres

  2. Selecciona Crear.

    Se abre la página Crear clúster de Kafka.

  3. En Nombre del clúster, ingresa una cadena.

    Si necesitas más información para asignarle un nombre a un clúster, consulta los Lineamientos para asignarles nombres a los recursos de Servicio administrado para Apache Kafka.

  4. En Ubicación, ingresa una ubicación compatible.

    Para obtener más información sobre las ubicaciones admitidas, consulta Ubicaciones admitidas de Managed Service para Apache Kafka.

  5. En Configuración de capacidad, ingresa valores para Memoria y CPU virtuales.

    Si deseas obtener más información para determinar el tamaño de un clúster de Managed Service para Apache Kafka, consulta Planifica el tamaño de tu clúster de Kafka.

  6. En Configuración de red, ingresa los siguientes detalles:

    1. Proyecto: Es el proyecto en el que se encuentra la subred. La subred debe estar ubicada en la misma región que el clúster, pero el proyecto podría ser diferente.
    2. Red: Es la red a la que está conectada la subred.
    3. Subred: Es el nombre de la subred.
    4. Ruta URI de la subred: Este campo se completa automáticamente. También puedes ingresar la ruta de la subred aquí. El nombre de la subred debe tener el siguiente formato: projects/PROJECT_ID/regions/REGION/subnetworks/SUBNET_ID.
    5. Haz clic en Listo.

  7. Opcional: Haz clic en Agregar una subred conectada para agregar subredes adicionales.

    Puedes agregar subredes adicionales, hasta un valor máximo de diez.

  8. Opcional: Establece una clave de encriptación administrada por el cliente (CMEK).

    1. En Encriptación, selecciona Clave de Cloud KMS.

    2. En Tipo de clave, selecciona Cloud KMS.

    3. En Selecciona una clave administrada por el cliente, selecciona o ingresa la CMEK.

      Si no ves esta opción, asegúrate de haber habilitado la API de Cloud KMS para el proyecto.

    Para obtener más información, consulta Configura la encriptación de mensajes.

  9. Haz clic en Crear.

gcloud

  1. En la consola de Google Cloud , activa Cloud Shell.

    Activa Cloud Shell

    En la parte inferior de la consola de Google Cloud , se inicia una sesión de Cloud Shell que muestra una ventana emergente con una línea de comandos. Cloud Shell es un entorno de shell con Google Cloud CLI ya instalada y con valores ya establecidos para el proyecto actual. La sesión puede tardar unos segundos en inicializarse.

  2. Ejecuta el 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

    Reemplaza lo siguiente:

    • CLUSTER_ID: Es el ID o el nombre del clúster.

      Si necesitas más información para asignarle un nombre a un clúster, consulta los Lineamientos para asignarles nombres a los recursos de Servicio administrado para Apache Kafka.

    • LOCATION: Es la ubicación del clúster.

      Para obtener más información sobre las ubicaciones admitidas, consulta Ubicaciones del Servicio administrado para Apache Kafka.

    • CPU: Es la cantidad de CPU virtuales para el clúster.

      Si deseas obtener más información para determinar el tamaño de un clúster de Managed Service para Apache Kafka, consulta Planifica el tamaño de tu clúster de Kafka.

    • MEMORY: Es la cantidad de memoria del clúster. Usa las unidades "MB", "MiB", "GB", "GiB", "TB" o "TiB". Por ejemplo, "10 GiB".

    • SUBNETS: Es la lista de subredes a las que se conectará. Usa comas para separar varios valores de subred.

      El formato de la subred es projects/PROJECT_ID/regions/REGION/subnetworks/SUBNET_ID.

    • auto-rebalance: Habilita el rebalanceo automático de las particiones de temas entre los agentes cuando cambia la cantidad de CPU en el clúster. Esta opción está habilitada de forma predeterminada.

    • ENCRYPTION_KEY: Es el ID de la clave de encriptación administrada por el cliente que se usará para el clúster.

      El formato es projects/PROJECT_ID/locations/LOCATION/keyRings/KEY_RING/cryptoKeys/CRYPTO_KEY.

    • --async: Permite que el sistema envíe la solicitud de creación y muestre una respuesta de inmediato, sin esperar a que se complete la operación. Con la marca --async, puedes continuar con otras tareas mientras se crea el clúster en segundo plano. Si no usas la marca, el sistema espera a que se complete la operación antes de devolver una respuesta. Debes esperar a que el clúster se actualice por completo antes de continuar con otras tareas.

    • LABELS: Son las etiquetas que se asociarán con el clúster.

      Para obtener más información sobre el formato de las etiquetas, consulta Etiquetas.

    Obtendrás una respuesta similar a la siguiente:

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

    Almacena el OPERATION_ID para hacer un seguimiento de progress.

REST

Antes de usar cualquiera de los datos de solicitud a continuación, realiza los siguientes reemplazos:

  • PROJECT_ID: El ID de tu proyecto de Google Cloud
  • LOCATION: Es la ubicación del clúster.
  • CLUSTER_ID: ID del clúster
  • CPU_COUNT: Es la cantidad de CPU virtuales del clúster.
  • MEMORY: Es la cantidad de memoria del clúster, en bytes. Ejemplo: 3221225472.
  • SUBNET_ID: ID de la subred a la que se conectará. Ejemplo: default.

Método HTTP y URL: 

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

Cuerpo JSON de la solicitud:

{
  "capacityConfig": {
    "vcpuCount": CPU_COUNT,
    "memoryBytes": MEMORY
  },
  "gcpConfig": {
    "accessConfig": {
      "networkConfigs": [
        {
          "subnet": "projects/PROJECT_ID/regions/LOCATION/subnetworks/SUBNET_ID"
        }
      ]
    }
  }
}

Para enviar tu solicitud, expande una de estas opciones:

Deberías recibir una respuesta JSON similar a la que se muestra a continuación:

{
  "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

Puedes usar un recurso de Terraform para crear un clúster.

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
      }
    }
  }
}

Si deseas obtener más información para aplicar o quitar una configuración de Terraform, consulta los comandos básicos de Terraform.

Go

Antes de probar este ejemplo, sigue las instrucciones de configuración de Go en Instala las bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de Managed Service para Apache Kafka para Go.

Para autenticarte en Managed Service for Apache Kafka, configura las credenciales predeterminadas de la aplicación(ADC). Para obtener más información, consulta Configura ADC para un entorno de desarrollo 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 probar este ejemplo, sigue las instrucciones de configuración de Java en Instala las bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de Java de Managed Service for Apache Kafka.

Para autenticarte en el servicio administrado para Apache Kafka, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Configura ADC para un entorno de desarrollo 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 probar este ejemplo, sigue las instrucciones de configuración de Python en Instala las bibliotecas cliente. Si deseas obtener más información, consulta la documentación de referencia de la API de Python de Managed Service for Apache Kafka.

Para autenticarte en el servicio administrado para Apache Kafka, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Configura ADC para un entorno de desarrollo 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}")

Supervisa la operación de creación del clúster

Solo puedes ejecutar el siguiente comando si ejecutaste gcloud CLI para crear el clúster.

  • Por lo general, la creación de un clúster tarda entre 20 y 30 minutos. Para hacer un seguimiento del progreso de la creación del clúster, el comando gcloud managed-kafka clusters create usa una operación de larga duración (LRO), que puedes supervisar con el siguiente comando:

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

    Reemplaza lo siguiente:

    • OPERATION_ID con el valor del ID de operación de la sección anterior
    • LOCATION con el valor de la ubicación de la sección anterior

Soluciona problemas

A continuación, se muestran algunos errores que puedes encontrar cuando creas clústeres.

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.

Al agente de servicio de Managed Service para Apache Kafka le falta el permiso necesario para acceder a la clave de Cloud KMS. Consulta la documentación sobre los roles necesarios para configurar la 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}

El agente de servicio de Managed Service para Apache Kafka no tiene el rol necesario para configurar la red en la red de VPC en la que se ejecutan los clientes de Kafka. Para obtener más información, consulta Cómo conectar un clúster entre proyectos.

Próximos pasos

Apache Kafka® es una marca registrada de The Apache Software Foundation o sus afiliados en Estados Unidos y otros países.