Google Cloud Managed Service for Apache Kafka-Cluster aktualisieren

Sie können einen Google Cloud Managed Service for Apache Kafka-Cluster bearbeiten, um Attribute wie die Clustergröße (einschließlich vCPU-Anzahl und Arbeitsspeicher), die Liste der verbundenen Subnetze, die zulässigen Quell-IP-Bereiche für öffentliche Cluster, die Konfiguration für das automatische Rebalancing und die mTLS-Konfiguration zu aktualisieren.

Sie können einen Cluster mit der Google Cloud Console, der Google Cloud CLI, der Clientbibliothek oder der Managed Kafka API bearbeiten. Sie können die Open-Source-Apache Kafka API nicht verwenden, um einen Cluster zu aktualisieren.

Wenn Sie bestimmte Attribute wie die Anzahl der vCPUs und den Arbeitsspeicher aktualisieren, muss der Dienst den Cluster möglicherweise neu starten. Der Dienst startet den Cluster Broker für Broker neu. Während dieses Vorgangs können Anfragen an einzelne Broker fehlschlagen. Diese Fehler sind jedoch vorübergehend. Häufig verwendete Clientbibliotheken verarbeiten diese Fehler automatisch.

Erforderliche Rollen und Berechtigungen

Bitten Sie Ihren Administrator, Ihnen die IAM-Rolle Managed Kafka Cluster Editor (roles/managedkafka.clusterEditor) für Ihr Projekt zuzuweisen, um die Berechtigung zu erhalten, die Sie zum Aktualisieren eines Clusters benötigen. Weitere Informationen zum Zuweisen von Rollen finden Sie unter Zugriff auf Projekte, Ordner und Organisationen verwalten.

Diese vordefinierte Rolle enthält die Berechtigung managedkafka.clusters.update, die zum Aktualisieren eines Clusters erforderlich ist.

Sie können diese Berechtigung auch mit benutzerdefinierten Rollen oder anderen vordefinierten Rollen erhalten.

Berechtigungen für Cluster-Subnetze

Wenn Sie die Netzwerkkonfiguration eines Clusters durch Hinzufügen eines Subnetzes aktualisieren, hängt der Managed Kafka-Dienst-Agent das Subnetz während des Aktualisierungsvorgangs an.

Mit der Berechtigung managedkafka.clusters.update kann ein Hauptkonto indirekt jedes Subnetz anhängen, für das der Dienst-Agent die Berechtigung zur Verwendung hat, auch wenn das Hauptkonto keine direkte Berechtigung zur Verwendung des Subnetzes hat.

Größe eines Clusters anpassen

Wenn Sie die vCPU-Anzahl oder den Arbeitsspeicher eines Clusters aktualisieren, gelten die folgenden Regeln:

  • Das vCPU-zu-Arbeitsspeicher-Verhältnis des Clusters muss immer zwischen 1:1 und 1:8 liegen.

  • Für jeden vorhandenen Broker muss mindestens 1 vCPU und 1 GiB Arbeitsspeicher vorhanden sein. Die Anzahl der Broker wird nie verringert.

  • Wenn der Cluster eine benutzerdefinierte Laufwerkskonfiguration hat, muss das Update die Anforderungen an die Laufwerkskonfiguration für lokalen Speicher erfüllen.

  • Wenn Sie die Skalierung erhöhen, dürfen die durchschnittliche vCPU und der durchschnittliche Arbeitsspeicher pro Broker im Vergleich zu den Durchschnittswerten vor dem Update nicht um mehr als 10 % sinken. Wenn Sie beispielsweise versuchen, einen Cluster von 45 vCPUs (3 Broker) auf 48 vCPUs (4 Broker) hochzuskalieren, sinkt die durchschnittliche Anzahl der vCPUs pro Broker von 15 auf 12. Das entspricht einer Reduzierung um 20 % und überschreitet das Limit von 10 %.

    Wenn Sie die vCPU-Anzahl um mehr als 10 % verringern müssen, empfehlen wir, sie in mehreren Schritten zu reduzieren. Überwachen Sie nach jeder Aktualisierung die Ressourcenauslastung und gleichen Sie die Partitionen bei Bedarf neu aus.

    Wenn Sie jedoch sicher sind, dass Ihre Broker nach dem Update genügend Kapazität haben, können Sie diese Prüfung deaktivieren. Führen Sie dazu den Befehl gcloud managed-kafka clusters update mit dem Flag allow_broker_downscale_on_cluster_upscale=true aus. Dieses Flag signalisiert, dass Sie das potenzielle Leistungsrisiko akzeptieren.

Weitere Informationen finden Sie unter Clustergröße aktualisieren.

Konfiguration des öffentlichen Clusters

Sie können den öffentlichen Zugriff für einen vorhandenen Cluster aktivieren oder deaktivieren sowie zulässige Quell-IP-Bereiche hinzufügen oder entfernen. Weitere Informationen zu den Anforderungen und Regeln für zulässige Quell-IP-Bereiche finden Sie unter Öffentliche Cluster.

Managed Service for Apache Kafka verwendet die Cloud Next Generation Firewall, um den Zugriff auf öffentliche Cluster einzuschränken. Das Entfernen zulässiger Quell-IP-Bereiche oder das Deaktivieren des öffentlichen Zugriffs gilt nur für neue Verbindungen. Weitere Informationen finden Sie unter Auswirkungen auf vorhandenen Traffic.

Cluster bearbeiten

So bearbeiten Sie einen Cluster:

Console

  1. Rufen Sie in der Google Cloud Console die Seite Cluster auf.

Zu den Clustern

  1. Klicken Sie in der Liste der Cluster auf den Cluster, dessen Attribute Sie bearbeiten möchten.

In der Console wird die Detailseite des Clusters angezeigt.

  1. Klicken Sie auf der Cluster-Detailseite auf Bearbeiten.

  2. Bearbeiten Sie die Attribute nach Bedarf. Sie können die folgenden Attribute eines Clusters über die Console bearbeiten:

    • Arbeitsspeicher
    • vCPUs
    • Subnetz
    • Konfiguration für Neuausgleich
    • mTLS-Konfiguration
    • Labels
  3. Klicken Sie auf Speichern.

gcloud

Zum Abrufen der aktuellen Richtlinie führen Sie den Befehl gcloud managed-kafka clusters update aus:

gcloud managed-kafka clusters update CLUSTER_ID \
  --location=LOCATION \
  --cpu=CPU \
  --memory=MEMORY \
  --subnets=SUBNETS \
  --async

Ersetzen Sie Folgendes:

  • CLUSTER_ID: Die ID oder der Name des Clusters.

  • LOCATION: Der Standort des Clusters.

  • CPU: Die Anzahl der vCPUs für den Cluster.

  • MEMORY: Die Größe des Arbeitsspeichers für den Cluster. Verwenden Sie die Einheiten „MB“, „MiB“, „GB“, „GiB“, „TB“ oder „TiB“. Beispiel: „10GiB“.

  • SUBNETS: Die Liste der Subnetze, zu denen eine Verbindung hergestellt werden soll. Trennen Sie mehrere Subnetzwerte durch Kommas.

Sie müssen mindestens ein Attribut angeben, das aktualisiert werden soll.

Wenn Sie das Flag --async angeben, wird der Befehl sofort zurückgegeben, ohne auf den Abschluss des Vorgangs zu warten. Wenn Sie dieses Flag nicht festlegen, wartet der Befehl, bis der Vorgang abgeschlossen ist, bevor eine Antwort zurückgegeben wird.

Konfiguration des öffentlichen Clusters aktualisieren

Führen Sie den folgenden Befehl aus, um den öffentlichen Zugriff auf den Cluster zu aktivieren.

gcloud managed-kafka clusters update CLUSTER_ID \
  --location=LOCATION \
  --public-cluster \
  --allowed-source-ip-ranges=ALLOWED_SOURCE_IP_RANGES \
  --async

Ersetzen Sie ALLOWED_SOURCE_IP_RANGES durch die zulässigen Quell-IP-Bereiche für den öffentlichen Cluster. Weitere Informationen finden Sie unter Konfiguration öffentlicher Cluster.

Verwenden Sie das Flag --no-public-cluster, um den öffentlichen Zugriff zu deaktivieren.

REST

Ersetzen Sie diese Werte in den folgenden Anfragedaten:

  • PROJECT_ID: Ihre Projekt-ID in Google Cloud
  • LOCATION: Der Standort des Clusters.
  • CLUSTER_ID: die ID des Clusters.
  • UPDATE_MASK: die zu aktualisierenden Felder als durch Kommas getrennte Liste vollständig qualifizierter Namen. Beispiel: capacityConfig.vcpuCount,capacityConfig.memoryBytes
  • CPU_COUNT: die Anzahl der vCPUs für den Cluster.
  • MEMORY: die Größe des Arbeitsspeichers für den Cluster in Byte. Beispiel: 3221225472.
  • SUBNET_ID: Subnetz-ID des Subnetzes, zu dem eine Verbindung hergestellt werden soll. Beispiel: default.

HTTP-Methode und URL:

PATCH https://managedkafka.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/clusters/CLUSTER_ID?updateMask=UPDATE_MASK

JSON-Text anfordern:

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

Wenn Sie die Anfrage senden möchten, maximieren Sie eine der folgenden Optionen:

Sie sollten eine JSON-Antwort ähnlich wie diese erhalten:

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

Geben Sie im Anfragetext nur die Felder an, die Sie aktualisieren, wie im Suchparameter UPDATE_MASK angegeben.

  • Wenn Sie ein Subnetz hinzufügen möchten, hängen Sie einen neuen Eintrag im folgenden Format an networkConfigs an: projects/PROJECT_ID/regions/LOCATION/subnetworks/SUBNET_ID. Beispiel: projects/sample-project/regions/us-central1/subnetworks/default.
  • Wenn Sie den öffentlichen Zugriff aktivieren oder die zulässigen Quell-IP-Bereiche aktualisieren möchten, fügen Sie gcpConfig.accessConfig.publicClusterConfig in den Abfrageparameter UPDATE_MASK ein und geben Sie das Array allowedSourceIpRanges im Anfragetext an. Beispiel für einen Anfragetext:

    {
      "gcpConfig": {
        "accessConfig": {
          "publicClusterConfig": {
            "allowedSourceIpRanges": [
              "203.0.113.0/24"
            ]
          }
        }
      }
    }
    
  • Wenn Sie den öffentlichen Zugriff deaktivieren möchten, fügen Sie gcpConfig.accessConfig.publicClusterConfig in den Abfrageparameter UPDATE_MASK ein und übergeben Sie ein leeres JSON-Objekt {} im Anfragetext (oder lassen Sie publicClusterConfig weg). Beispiel für einen Anfragetext:

    {}
    

Go

Bevor Sie dieses Beispiel ausprobieren, folgen Sie der Einrichtungsanleitung für Go unter Clientbibliotheken installieren. Weitere Informationen finden Sie in der Go API-Referenzdokumentation für Managed Service for Apache Kafka.

Richten Sie zur Authentifizierung bei Managed Service for Apache Kafka Standardanmeldedaten für Anwendungen (Application Default Credentials, ADC) ein. Weitere Informationen finden Sie unter ADC für eine lokale Entwicklungsumgebung einrichten.

import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/managedkafka/apiv1/managedkafkapb"
	"google.golang.org/api/option"
	"google.golang.org/protobuf/types/known/fieldmaskpb"

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

func updateCluster(w io.Writer, projectID, region, clusterID string, memory int64, opts ...option.ClientOption) error {
	// projectID := "my-project-id"
	// region := "us-central1"
	// clusterID := "my-cluster"
	// memoryBytes := 4221225472
	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)
	capacityConfig := &managedkafkapb.CapacityConfig{
		MemoryBytes: memory,
	}
	cluster := &managedkafkapb.Cluster{
		Name:           clusterPath,
		CapacityConfig: capacityConfig,
	}
	paths := []string{"capacity_config.memory_bytes"}
	updateMask := &fieldmaskpb.FieldMask{
		Paths: paths,
	}

	req := &managedkafkapb.UpdateClusterRequest{
		UpdateMask: updateMask,
		Cluster:    cluster,
	}
	op, err := client.UpdateCluster(ctx, req)
	if err != nil {
		return fmt.Errorf("client.UpdateCluster got err: %w", err)
	}
	resp, err := op.Wait(ctx)
	if err != nil {
		return fmt.Errorf("op.Wait got err: %w", err)
	}
	fmt.Fprintf(w, "Updated cluster: %#v\n", resp)
	return nil
}

Java

Bevor Sie dieses Beispiel ausprobieren, folgen Sie der Anleitung zur Einrichtung von Java unter Clientbibliotheken installieren. Weitere Informationen finden Sie in der Referenzdokumentation zur Managed Service for Apache Kafka Java API.

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Managed Service for Apache Kafka zu authentifizieren. Weitere Informationen finden Sie unter Standardanmeldedaten für Anwendungen für eine lokale Entwicklungsumgebung einrichten.


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.cloud.managedkafka.v1.CapacityConfig;
import com.google.cloud.managedkafka.v1.Cluster;
import com.google.cloud.managedkafka.v1.ClusterName;
import com.google.cloud.managedkafka.v1.ManagedKafkaClient;
import com.google.cloud.managedkafka.v1.ManagedKafkaSettings;
import com.google.cloud.managedkafka.v1.OperationMetadata;
import com.google.cloud.managedkafka.v1.UpdateClusterRequest;
import com.google.protobuf.FieldMask;
import java.time.Duration;
import java.util.concurrent.ExecutionException;

public class UpdateCluster {

  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";
    long memoryBytes = 25769803776L; // 24 GiB
    updateCluster(projectId, region, clusterId, memoryBytes);
  }

  public static void updateCluster(
      String projectId, String region, String clusterId, long memoryBytes) throws Exception {
    CapacityConfig capacityConfig = CapacityConfig.newBuilder().setMemoryBytes(memoryBytes).build();
    Cluster cluster =
        Cluster.newBuilder()
            .setName(ClusterName.of(projectId, region, clusterId).toString())
            .setCapacityConfig(capacityConfig)
            .build();
    FieldMask updateMask = FieldMask.newBuilder().addPaths("capacity_config.memory_bytes").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.updateClusterOperationSettings()
        .setPollingAlgorithm(timedRetryAlgorithm);

    try (ManagedKafkaClient managedKafkaClient = ManagedKafkaClient.create(
        settingsBuilder.build())) {
      UpdateClusterRequest request =
          UpdateClusterRequest.newBuilder().setUpdateMask(updateMask).setCluster(cluster).build();
      OperationFuture<Cluster, OperationMetadata> future =
          managedKafkaClient.updateClusterOperationCallable().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 update started. Operation name: %s\nDone: %s\nMetadata: %s\n",
          operation.getName(),
          operation.isDone(),
          future.getMetadata().get().toString());

      Cluster response = future.get();
      System.out.printf("Updated cluster: %s\n", response.getName());
    } catch (ExecutionException e) {
      System.err.printf("managedKafkaClient.updateCluster got err: %s", e.getMessage());
    }
  }
}

Python

Bevor Sie dieses Beispiel ausprobieren, folgen Sie der Einrichtungsanleitung für Python unter Clientbibliotheken installieren. Weitere Informationen finden Sie in der Referenzdokumentation zur Managed Service for Apache Kafka Python API.

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Managed Service for Apache Kafka zu authentifizieren. Weitere Informationen finden Sie unter Standardanmeldedaten für Anwendungen für eine lokale Entwicklungsumgebung einrichten.

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

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

client = managedkafka_v1.ManagedKafkaClient()

cluster = managedkafka_v1.Cluster()
cluster.name = client.cluster_path(project_id, region, cluster_id)
cluster.capacity_config.memory_bytes = memory_bytes
update_mask = field_mask_pb2.FieldMask()
update_mask.paths.append("capacity_config.memory_bytes")

# For a list of editable fields, one can check https://cloud.google.com/managed-kafka/docs/create-cluster#properties.
request = managedkafka_v1.UpdateClusterRequest(
    update_mask=update_mask,
    cluster=cluster,
)

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

Beschränkungen

Nachdem Sie einen Managed Service for Apache Kafka-Cluster erstellt haben, können Sie die folgenden Attribute nicht mehr aktualisieren:

  • Der Clustername
  • Der Clusterstandort
  • Der Verschlüsselungstyp

Sie können den Verschlüsselungstyp zwar nicht ändern, aber die Verschlüsselungsschlüssel rotieren.

Nächste Schritte

Apache Kafka® ist eine eingetragene Marke der Apache Software Foundation oder deren Tochtergesellschaften in den USA und/oder anderen Ländern.