Afficher un cluster Connect

Vous pouvez afficher les détails d'un cluster Connect pour en savoir plus sur sa configuration, y compris le nom du cluster Managed Service pour Apache Kafka Google Cloud principal, l'état du cluster Connect, l'allocation de ressources, les paramètres réseau et les connecteurs hébergés par le cluster Connect.

Pour afficher vos clusters Connect, vous pouvez utiliser la console Google Cloud , la gcloud CLI, la bibliothèque cliente ou l'API Managed Kafka. Vous ne pouvez pas utiliser l'API Apache Kafka Open Source pour lister les clusters Connect.

Rôles et autorisations requis pour afficher un cluster Connect

Pour obtenir les autorisations nécessaires pour lister vos clusters Connect, demandez à votre administrateur de vous accorder le rôle IAM Lecteur Kafka géré(roles/managedkafka.viewer) sur votre projet. Pour en savoir plus sur l'attribution de rôles, consultez Gérer l'accès aux projets, aux dossiers et aux organisations.

Ce rôle prédéfini contient les autorisations requises pour lister vos clusters Connect. Pour connaître les autorisations exactes requises, développez la section Autorisations requises :

Autorisations requises

Les autorisations suivantes sont requises pour lister vos clusters Connect :

Accordez l'autorisation de lister les clusters à l'emplacement spécifié : managedkafka.connectClusters.list
Accordez l'autorisation "Obtenir les détails du cluster" à l'emplacement spécifié : managedkafka.connectClusters.get

Vous pouvez également obtenir ces autorisations avec des rôles personnalisés ou d'autres rôles prédéfinis.

Pour en savoir plus sur le rôle "Lecteur Managed Kafka", consultez Rôles prédéfinis de Managed Service pour Apache Kafka.

Afficher les détails d'un cluster Connect

Console

Dans la console Google Cloud , accédez à la page Connecter des clusters.

Accéder à Connect Clusters
Cliquez sur le cluster Connect que vous souhaitez afficher.
La page "Connecter un cluster" s'affiche avec quatre onglets :
- Ressources : fournit une vue ciblée des connecteurs exécutés sur votre cluster, y compris leur état opérationnel et leur type.
- Configurations : affiche les propriétés et les paramètres essentiels du cluster Connect, tels que le cluster Kafka principal, l'état, l'allocation des ressources et les paramètres réseau.
- Journaux : fournit un flux en temps réel des entrées de journal de votre cluster Connect pour la surveillance et le dépannage.
- Surveillance : fournit des métriques pour vous aider à surveiller les performances et l'utilisation des ressources de votre cluster Connect.

gcloud

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.
Utilisez la commande gcloud managed-kafka connect-clusters describe pour afficher les détails d'un cluster Connect :
```
gcloud managed-kafka connect-clusters describe CONNECT_CLUSTER \
    --location=LOCATION
```
Remplacez les éléments suivants :
- CONNECT_CLUSTER : ID du cluster Connect que vous souhaitez afficher.
- LOCATION : emplacement du cluster Connect.

Exemple de résultat :

capacityConfig:
memoryBytes: '3221225472'
vcpuCount: '3'
createTime: '2025-03-05T15:19:17.998009888Z'
gcpConfig:
accessConfig:
networkConfigs:
-   primarySubnet: projects/sample-project/regions/us-central1/subnetworks/default
kafkaCluster: projects/sample-project/locations/us-central1/clusters/kafka-test
name: projects/sample-project/locations/us-central1/connectClusters/my-connect-cluster
state: ACTIVE
updateTime: '2025-03-05T15:24:40.861655595Z'

Go

Avant d'essayer cet exemple, suivez les instructions de configuration pour Go dans Installer les bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Managed Service pour Apache Kafka en langage Go.

Pour vous authentifier auprès de Managed Service pour Apache Kafka, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer les ADC pour un environnement de développement 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 getConnectCluster(w io.Writer, projectID, region, clusterID string, opts ...option.ClientOption) error {
	// projectID := "my-project-id"
	// region := "us-central1"
	// clusterID := "my-connect-cluster"
	ctx := context.Background()
	client, err := managedkafka.NewManagedKafkaConnectClient(ctx, opts...)
	if err != nil {
		return fmt.Errorf("managedkafka.NewManagedKafkaConnectClient got err: %w", err)
	}
	defer client.Close()

	clusterPath := fmt.Sprintf("projects/%s/locations/%s/connectClusters/%s", projectID, region, clusterID)
	req := &managedkafkapb.GetConnectClusterRequest{
		Name: clusterPath,
	}
	cluster, err := client.GetConnectCluster(ctx, req)
	if err != nil {
		return fmt.Errorf("client.GetConnectCluster got err: %w", err)
	}
	fmt.Fprintf(w, "Got connect cluster: %#v\n", cluster)
	return nil
}

Java

Avant d'essayer cet exemple, suivez les instructions de configuration pour Java dans Installer les bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Java pour Managed Service pour Apache Kafka.

Pour vous authentifier auprès de Managed Service pour Apache Kafka, configurez les Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer les ADC pour un environnement de développement local.

import com.google.api.gax.rpc.ApiException;
import com.google.cloud.managedkafka.v1.ConnectCluster;
import com.google.cloud.managedkafka.v1.ConnectClusterName;
import com.google.cloud.managedkafka.v1.ManagedKafkaConnectClient;
import java.io.IOException;

public class GetConnectCluster {

  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-connect-cluster";
    getConnectCluster(projectId, region, clusterId);
  }

  public static void getConnectCluster(String projectId, String region, String clusterId)
      throws Exception {
    try (ManagedKafkaConnectClient managedKafkaConnectClient = ManagedKafkaConnectClient.create()) {
      // This operation is being handled synchronously.
      ConnectCluster connectCluster = managedKafkaConnectClient
          .getConnectCluster(ConnectClusterName.of(projectId, region, clusterId));
      System.out.println(connectCluster.getAllFields());
    } catch (IOException | ApiException e) {
      System.err.printf("managedKafkaConnectClient.getConnectCluster got err: %s\n", 
          e.getMessage());
    }
  }
}

Python

Avant d'essayer cet exemple, suivez les instructions de configuration pour Python dans Installer les bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Python Managed Service pour Apache Kafka.

from google.api_core.exceptions import NotFound
from google.cloud.managedkafka_v1.services.managed_kafka_connect import ManagedKafkaConnectClient
from google.cloud import managedkafka_v1

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

client = ManagedKafkaConnectClient()

cluster_path = client.connect_cluster_path(project_id, region, connect_cluster_id)
request = managedkafka_v1.GetConnectClusterRequest(
    name=cluster_path,
)

try:
    cluster = client.get_connect_cluster(request=request)
    print("Got Connect cluster:", cluster)
except NotFound as e:
    print(f"Failed to get Connect cluster {connect_cluster_id} with error: {e}")

Présentation des détails du cluster Connect

La page "Connecter un cluster" s'affiche avec quatre onglets : Ressources, Configurations, Surveillance et Journaux.

Ressources

L'onglet Ressources de la page "Connecter un cluster" récapitule les types de connecteurs déployés et leur état opérationnel. Les informations suivantes s'affichent :

Table des connecteurs : tableau listant tous les connecteurs du cluster Connect.
- Nom : nom attribué à chaque connecteur.
- État : état opérationnel actuel du connecteur.
- Type de connecteur : indique le type de connecteur, comme une source MirrorMaker 2.0, un récepteur BigQuery, un récepteur Cloud Storage ou un récepteur Pub/Sub.
Filtre : barre de recherche que vous pouvez utiliser pour filtrer les connecteurs en fonction de leurs propriétés.

Pour surveiller l'état du connecteur, utilisez l'onglet Ressources.

Configurations

L'onglet Configurations affiche des informations sur l'état du cluster, l'allocation des ressources, les paramètres réseau et la configuration DNS.

Cluster Kafka principal : affiche le nom du cluster Managed Service pour Apache Kafka associé à ce cluster Connect. Le cluster Connect stocke ses configurations et ses décalages dans le cluster Managed Service pour Apache Kafka.
État : indique l'état actuel du cluster Connect. Les états possibles sont Active, Creating, Deleting et State_unspecified.
Région : indique la région du cluster Connect.
vCPUs : indique le nombre de processeurs virtuels alloués au cluster Connect. Un nombre de vCPU plus élevé augmente la capacité de traitement du cluster.
Mémoire : indique la mémoire totale provisionnée du cluster Connect.
Libellés : affiche les libellés associés au cluster Connect.
Ressources de secret : liste les secrets associés au cluster Connect.
Sous-réseaux : liste les sous-réseaux associés au cluster Connect. Le tableau comprend des colonnes pour le nom, la région et le projet.
Noms DNS : affiche les noms DNS personnalisés configurés pour le cluster Connect. Si aucun nom DNS personnalisé n'est configuré, le tableau est vide.

Surveillance

L'onglet Surveillance fournit des métriques qui vous aident à comprendre les performances et l'utilisation des ressources de vos connecteurs. Exemples de métriques :

Utilisation du processeur par le nœud de calcul : utilisation totale du processeur, en secondes de processeur virtuel, pour chaque nœud de calcul. Cette métrique permet d'identifier les contraintes de ressources.
Utilisation de la mémoire par le nœud de calcul : utilisation actuelle de la mémoire, en octets, pour chaque nœud de calcul. Cette métrique permet d'éviter les erreurs de mémoire insuffisante.
Débit entrant du connecteur (en octets) : débit entrant moyen en octets par seconde, à partir des connexions client, pour chaque connecteur. Cette métrique permet d'évaluer les taux d'ingestion de données.
Débit sortant du connecteur (en octets) : débit sortant moyen en octets par seconde vers les serveurs, à partir des connexions client, pour chaque connecteur. Cette métrique permet de surveiller les taux de distribution des données.

Journaux

L'onglet Journaux fournit un flux en temps réel des entrées de journal de votre cluster Connect. Utilisez cet onglet pour surveiller l'état et l'activité du connecteur, et résoudre les problèmes. Ces fonctionnalités vous aident à surveiller et à déboguer efficacement votre cluster Connect :

Filtrer par gravité : filtrez les entrées de journal par niveau de gravité pour identifier rapidement les problèmes critiques.
Rechercher : recherchez des mots clés ou des expressions spécifiques dans les entrées de journaux pour trouver des événements liés à un connecteur ou à une tâche en particulier.
Horodatages : les horodatages de chaque entrée de journal permettent de suivre les séquences d'événements et d'identifier le moment où les actions se sont produites.
Résumé : Les entrées de journaux fournissent des informations sur divers événements, tels que le démarrage et l'arrêt du connecteur, l'exécution des tâches et le traitement des données.

Étape suivante

Apache Kafka® est une marque déposée d'Apache Software Foundation ou de ses filiales aux États-Unis et/ou dans d'autres pays.

Afficher un cluster Connect Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.