Crea un cluster Google Cloud Managed Service per Apache Kafka

Un cluster Managed Service per Apache Kafka fornisce un ambiente per l'archiviazione e l'elaborazione di flussi di messaggi organizzati in argomenti.

Per creare un cluster, puoi utilizzare la console Google Cloud , Google Cloud CLI, la libreria client o l'API Managed Kafka. Non puoi utilizzare l'API Apache Kafka open source per creare un cluster.

Prima di iniziare

Verifica di conoscere quanto segue:

Ruoli e autorizzazioni richiesti per creare un cluster

Per ottenere le autorizzazioni necessarie per creare un cluster, chiedi all'amministratore di concederti il ruolo IAM Editor cluster Kafka gestito (roles/managedkafka.clusterEditor) nel progetto. Per saperne di più sulla concessione dei ruoli, consulta Gestisci l'accesso a progetti, cartelle e organizzazioni.

Questo ruolo predefinito contiene le autorizzazioni necessarie per creare un cluster. Per vedere quali sono esattamente le autorizzazioni richieste, espandi la sezione Autorizzazioni obbligatorie:

Autorizzazioni obbligatorie

Per creare un cluster sono necessarie le seguenti autorizzazioni:

  • Crea un cluster: managedkafka.clusters.create

Potresti anche ottenere queste autorizzazioni con ruoli personalizzati o altri ruoli predefiniti.

Il ruolo Editor cluster Kafka gestito non consente di creare, eliminare o modificare argomenti e gruppi di consumatori nei cluster Managed Service per Apache Kafka. Né consente l'accesso al piano dati per pubblicare o utilizzare messaggi all'interno dei cluster. Per saperne di più su questo ruolo, consulta Ruoli predefiniti di Managed Service per Apache Kafka.

Proprietà di un cluster Managed Service per Apache Kafka

Quando crei o aggiorni un cluster Managed Service per Apache Kafka, devi specificare le seguenti proprietà.

Nome del cluster

Il nome o l'ID del cluster Managed Service per Apache Kafka che stai creando. Per linee guida su come assegnare un nome a un cluster, consulta Linee guida per assegnare un nome a una risorsa Managed Service per Apache Kafka. Il nome di un cluster è immutabile.

Località

La località in cui stai creando il cluster. La località deve essere una delle regioni Google Cloud supportate. La località di un cluster non può essere modificata in un secondo momento. Per un elenco di località disponibili, consulta le località di Managed Service per Apache Kafka.

Configurazione della capacità

La configurazione della capacità richiede di impostare il numero di vCPU e la quantità di memoria richiesta per la configurazione di Kafka. Per maggiori informazioni su come configurare la capacità di un cluster, consulta Pianificare le dimensioni del cluster Kafka.

Di seguito sono riportate le proprietà per la configurazione della capacità:

  • vCPUs: il numero di vCPU nel cluster. Sono richieste almeno 3 vCPU per cluster.

  • Memoria: la quantità di memoria assegnata al cluster. Devi eseguire il provisioning tra 1 GiB e 8 GiB per vCPU.

    Ad esempio, se crei un cluster con 6 vCPU, la memoria minima che puoi allocare al cluster è 6 GiB (1 GiB per vCPU) e la massima è 48 GiB (8 GiB per vCPU).

Per ulteriori informazioni su come modificare la memoria e il numero di vCPU dopo la creazione di un cluster, consulta Aggiornare le dimensioni del cluster.

Configurazione di rete

La configurazione di rete è un elenco di subnet VPC in cui il cluster è accessibile. Per produrre o utilizzare i messaggi, i client devono essere in grado di raggiungere una di queste subnet.

Di seguito sono riportate alcune linee guida per la configurazione di rete:

  • Per un cluster è richiesta almeno una subnet. Il valore massimo è dieci.

  • Per un determinato cluster è consentita una sola subnet per rete.

  • Ogni subnet deve trovarsi nella stessa regione del cluster. Il progetto e la rete possono essere diversi.

  • Gli indirizzi IP dei broker e del server di bootstrap vengono allocati automaticamente in ogni subnet. Inoltre, le voci DNS per questi indirizzi IP vengono create nelle reti VPC corrispondenti.

  • Se aggiungi una subnet di un altro progetto, devi concedere le autorizzazioni al account di servizio gestito da Google associato al cluster. Per maggiori informazioni, consulta Connettere un cluster a più progetti.

Dopo aver creato il cluster, puoi aggiornare l'elenco delle subnet. Per saperne di più sul networking, consulta Configura il networking per Managed Service per Apache Kafka.

Etichette

Le etichette sono coppie chiave-valore che ti aiutano con l'organizzazione e l'identificazione. Le etichette consentono di classificare le risorse in base all'ambiente. Esempi sono "env:production" e "owner:data-engineering".

Puoi filtrare e cercare le risorse in base alle etichette. Ad esempio, supponiamo che tu abbia più cluster Managed Service per Apache Kafka per dipartimenti diversi. Puoi configurare e cercare i cluster con l'etichetta "department:marketing" per trovare rapidamente quello pertinente.

Configurazione del ribilanciamento

Questa impostazione determina se il servizio ribilancia automaticamente le repliche delle partizioni tra i broker.

Le modalità disponibili sono:

  • Bilanciamento automatico in caso di scalabilità verticale: quando questa opzione è attivata, il servizio attiva automaticamente un ribilanciamento delle repliche quando aumenti la scalabilità verticale del cluster. Questa modalità consente di mantenere una distribuzione uniforme del carico, ma potrebbe influire temporaneamente sulle prestazioni durante l'operazione di ribilanciamento.

  • Nessun ribilanciamento: se questa opzione è abilitata, il servizio non ribilancia automaticamente le repliche.

Crittografia

Managed Service per Apache Kafka può criptare i messaggi con Google-owned and Google-managed encryption keys (impostazione predefinita) o chiavi di crittografia gestite dal cliente (CMEK). Ogni messaggio è criptato at-rest e in transito. Il tipo di crittografia per un cluster è immutabile.

Google-owned and Google-managed encryption keys vengono utilizzati per impostazione predefinita. Queste chiavi vengono create, gestite e archiviate interamente da Google Cloud all'interno della sua infrastruttura.

Le CMEK sono chiavi di crittografia che gestisci utilizzando Cloud Key Management Service. Questa funzionalità ti consente di avere un maggiore controllo sulle chiavi utilizzate per criptare i dati inattivi all'interno dei servizi Google Cloud supportati. L'utilizzo di CMEK comporta costi aggiuntivi correlati a Cloud Key Management Service. Per l'utilizzo di CMEK, il portachiavi deve trovarsi nella stessa posizione delle risorse con cui lo utilizzi. Per saperne di più, consulta Configura la crittografia dei messaggi.

Configurazione mTLS

Se vuoi, puoi configurare mTLS come metodo di autenticazione alternativo che utilizza i certificati client. La configurazione include quanto segue:

  • Pool di CA: un elenco da 1 a 10 pool di Certificate Authority Service (CAS) considerati attendibili dal cluster per l'autenticazione client.

  • Regole di mapping dell'entità SSL: una proprietà del broker ssl.principal.mapping.rules facoltativa, ma consigliata, per semplificare i nomi delle entità dei certificati lunghi da utilizzare negli ACL Kafka.

Per saperne di più su mTLS, consulta Configurare l'autenticazione mTLS.

Crea un cluster

Prima di creare un cluster, consulta la documentazione delle proprietà del cluster.

La creazione di un cluster richiede in genere 20-30 minuti.

Per creare un cluster:

Console

  1. Nella console Google Cloud , vai alla pagina Cluster.

    Vai a Cluster

  2. Seleziona Crea.

    Viene visualizzata la pagina Crea cluster Kafka.

  3. Per Nome cluster, inserisci una stringa.

    Per maggiori informazioni su come assegnare un nome a un cluster, consulta le linee guida per assegnare un nome a una risorsa Managed Service per Apache Kafka.

  4. In Posizione, inserisci una posizione supportata.

    Per saperne di più sulle località supportate, consulta Località di Managed Service per Apache Kafka supportate.

  5. Per la configurazione della capacità, inserisci i valori per Memoria e vCPU.

    Per maggiori informazioni su come dimensionare un cluster Managed Service per Apache Kafka, consulta Pianificare le dimensioni del cluster Kafka.

  6. Per Configurazione di rete, inserisci i seguenti dettagli:

    1. Progetto: il progetto in cui si trova la subnet. La subnet deve trovarsi nella stessa regione del cluster, ma il progetto potrebbe essere diverso.
    2. Rete: la rete a cui è connessa la subnet.
    3. Subnet: il nome della subnet.
    4. Percorso URI subnet: questo campo viene compilato automaticamente. In alternativa, puoi inserire qui il percorso della subnet. Il nome della subnet deve essere nel formato: projects/PROJECT_ID/regions/REGION/subnetworks/SUBNET_ID.
    5. Fai clic su Fine.

  7. (Facoltativo) Aggiungi altre subnet facendo clic su Aggiungi una subnet connessa.

    Puoi aggiungere altre subnet, fino a un massimo di dieci.

  8. Mantieni gli altri valori predefiniti.

  9. Fai clic su Crea.

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. Esegui il 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

    Sostituisci quanto segue:

    • CLUSTER_ID: l'ID o il nome del cluster.

      Per maggiori informazioni su come assegnare un nome a un cluster, consulta le linee guida per assegnare un nome a una risorsa Managed Service per Apache Kafka.

    • LOCATION: la posizione del cluster.

      Per saperne di più sulle località supportate, consulta Località di Managed Service per Apache Kafka.

    • CPU: Il numero di vCPU per il cluster.

      Per maggiori informazioni su come dimensionare un cluster Managed Service per Apache Kafka, consulta Pianificare le dimensioni del cluster Kafka.

    • MEMORY: La quantità di memoria per il cluster. Utilizza le unità "MB", "MiB", "GB", "GiB", "TB" o "TiB". Ad esempio, "10 GiB".

    • SUBNETS: l'elenco delle subnet a cui connettersi. Utilizza le virgole per separare più valori di subnet.

      Il formato della subnet è projects/PROJECT_ID/regions/REGION/subnetworks/SUBNET_ID.

    • auto-rebalance: consente il ribilanciamento automatico delle partizioni degli argomenti tra i broker quando cambia il numero di CPU nel cluster. Questa opzione è attiva per impostazione predefinita.

    • ENCRYPTION_KEY: l'ID della chiave di crittografia gestita dal cliente da utilizzare per il cluster.

      Il formato è projects/PROJECT_ID/locations/LOCATION/keyRings/KEY_RING/cryptoKeys/CRYPTO_KEY.

    • --async: consente al sistema di inviare la richiesta di creazione e restituire immediatamente una risposta, senza attendere il completamento dell'operazione. Con il flag --async, puoi continuare con altre attività mentre la creazione del cluster avviene in background. Se non utilizzi il flag, il sistema attende il completamento dell'operazione prima di restituire una risposta. Devi attendere il completamento dell'aggiornamento del cluster prima di poter continuare con altre attività.

    • LABELS: le etichette da associare al cluster.

      Per saperne di più sul formato delle etichette, consulta Etichette.

    Ricevi una risposta simile alla seguente:

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

    Memorizza OPERATION_ID per monitorare progress.

    3. REST

    Prima di utilizzare i dati della richiesta, apporta le sostituzioni seguenti:

    • PROJECT_ID: il tuo Google Cloud ID progetto
    • LOCATION: la posizione del cluster
    • CLUSTER_ID: l'ID del cluster
    • CPU_COUNT: il numero di vCPU per il cluster
    • MEMORY: la quantità di memoria per il cluster, in byte. Esempio: 3221225472.
    • SUBNET_ID: l'ID subnet della subnet a cui connettersi. Esempio: default.

    Metodo HTTP e URL: 

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

    Corpo JSON della richiesta: 

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

    Per inviare la richiesta, espandi una di queste opzioni:

    Dovresti ricevere una risposta JSON simile alla seguente:

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

    Puoi utilizzare una risorsa Terraform per creare un 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
      }
    }
  }
}

    Per scoprire come applicare o rimuovere una configurazione Terraform, consulta Comandi Terraform di base.

    Go

    Prima di provare questo esempio, segui le istruzioni di configurazione di Go in Installare le librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API Go di Managed Service per Apache Kafka.

    Per eseguire l'autenticazione in Managed Service per Apache Kafka, configura le Credenziali predefinite dell'applicazione(ADC). Per saperne di più, vedi Configura ADC per un ambiente di sviluppo locale.

    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

    Prima di provare questo esempio, segui le istruzioni di configurazione di Java in Installare le librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API Java di Managed Service per Apache Kafka.

    Per eseguire l'autenticazione in Managed Service per Apache Kafka, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura ADC per un ambiente di sviluppo locale.

    
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

    Prima di provare questo esempio, segui le istruzioni di configurazione di Python in Installare le librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API Python di Managed Service per Apache Kafka.

    Per eseguire l'autenticazione in Managed Service per Apache Kafka, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura ADC per un ambiente di sviluppo locale.

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

Monitora l'operazione di creazione del cluster

Puoi eseguire il seguente comando solo se hai eseguito gcloud CLI per creare il cluster.

  • La creazione di un cluster richiede in genere 20-30 minuti. Per monitorare l'avanzamento della creazione del cluster, il comando gcloud managed-kafka clusters create utilizza un'operazione a lunga esecuzione (LRO), che puoi monitorare utilizzando il seguente comando:

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

    Sostituisci quanto segue:

    • OPERATION_ID con il valore dell'ID operazione della sezione precedente.
    • LOCATION con il valore della località della sezione precedente.

Risoluzione dei problemi

Di seguito sono riportati alcuni errori che potresti riscontrare durante la creazione dei cluster.

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.

Il service agent di Managed Service per Apache Kafka non dispone dell'autorizzazione necessaria per accedere alla chiave Cloud KMS. Consulta la documentazione sui ruoli richiesti per configurare 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}

Il service agent di Managed Service per Apache Kafka non dispone del ruolo necessario per configurare il networking nella rete VPC in cui vengono eseguiti i client Kafka. Per saperne di più, consulta Connettere un cluster a più progetti.

Passaggi successivi

Apache Kafka® è un marchio registrato di Apache Software Foundation o delle sue affiliate negli Stati Uniti e/o in altri paesi.