Lister tous les connecteurs

Lister tous les connecteurs exécutés dans un cluster Connect permet d'obtenir un aperçu des intégrations de données configurées. Vous pouvez surveiller l'état et le statut de vos connecteurs, identifier les problèmes potentiels et gérer efficacement vos flux de données.

Pour lister tous les connecteurs d'un cluster Connect, vous pouvez utiliser la console Google Cloud , la gcloud CLI, la bibliothèque cliente Managed Service pour Apache Kafka ou l'API Managed Kafka. Vous ne pouvez pas utiliser l'API Apache Kafka Open Source pour lister les connecteurs.

Rôles et autorisations requis pour lister tous les connecteurs

Pour obtenir les autorisations nécessaires pour lister tous les connecteurs, demandez à votre administrateur de vous accorder le rôle IAM Lecteur Managed Kafka (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 tous les connecteurs. Pour connaître les autorisations exactes requises, développez la section Autorisations requises :

Autorisations requises

Les autorisations suivantes sont requises pour lister tous les connecteurs :

Accordez l'autorisation "Lister les connecteurs" sur le cluster Connect parent : managedkafka.connectors.list
Accordez l'autorisation d'obtenir les détails du connecteur sur le cluster Connect parent : managedkafka.connectors.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 tous les connecteurs

Cette vue vous permet de surveiller rapidement l'état de vos connecteurs et d'identifier ceux qui requièrent votre attention. Vous pouvez ensuite examiner les connecteurs individuels pour afficher leurs détails et leurs configurations, si nécessaire.

Console

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

Accéder à Connect Clusters
Cliquez sur le cluster Connect pour lequel vous souhaitez lister les connecteurs.

La page Connecter les détails du cluster s'affiche.
L'onglet Ressources affiche la liste de tous les connecteurs exécutés dans le cluster. La liste comprend les informations suivantes pour chaque connecteur :
- Nom : nom du connecteur.
- État : état opérationnel du connecteur. Par exemple, "En cours d'exécution" ou "Échec".
- Type de connecteur : type de plug-in de connecteur.
Vous pouvez utiliser l'option Filtrer pour rechercher des connecteurs spécifiques par nom.

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 connectors list pour lister les connecteurs :

gcloud managed-kafka connectors list CONNECT_CLUSTER_ID \
    --location=LOCATION

Pour affiner davantage la liste des connecteurs, vous pouvez utiliser des options supplémentaires :
```
gcloud managed-kafka connectors list CONNECT_CLUSTER_ID \
    --location=LOCATION \
    [--filter=EXPRESSION] \
    [--limit=LIMIT] \
    [--page-size=PAGE_SIZE] \
    [--sort-by=SORT_BY]
```
Remplacez les éléments suivants :
- CONNECT_CLUSTER_ID : valeur obligatoire. ID du cluster Connect contenant les connecteurs que vous souhaitez répertorier.
- LOCATION : valeur obligatoire. Emplacement du cluster Connect contenant les connecteurs que vous souhaitez lister.
- EXPRESSION : (facultatif) expression de filtre booléen à appliquer à la liste. Si l'expression renvoie la valeur True, l'élément est inclus dans la liste. Pour en savoir plus et obtenir des exemples, exécutez gcloud topic filters.
  
  Exemples :
  - Pour n'afficher que les connecteurs à l'état "RUNNING" (EN COURS D'EXÉCUTION) :
```
--filter="state=RUNNING"
```
  - Pour n'afficher que les connecteurs "Récepteur Pub/Sub" :
```
--filter="connector_plugin='Pub/Sub Sink'"
```
  - Pour lister les connecteurs dont le nom contient "prod" :
```
--filter="name ~ 'prod'"
```
  - Pour lister les connecteurs dont l'état est "FAILED" (ÉCHEC) ou qui sont des plug-ins "Pub/Sub Source" (Source Pub/Sub) :
```
--filter="state=FAILED OR connector_plugin='Pub/Sub Source'"
```
- LIMIT : (facultatif) nombre maximal de connecteurs à afficher. Si aucune n'est spécifiée, tous les connecteurs sont listés.
- PAGE_SIZE : (facultatif) nombre de résultats à afficher par page. Si aucune taille n'est spécifiée, le service détermine une taille de page appropriée.
- SORT_BY : (facultatif) liste de champs séparés par une virgule selon lesquels effectuer le tri. L'ordre de tri par défaut est croissant. Pour trier par ordre décroissant, ajoutez le préfixe ~ au champ. Les champs acceptés sont probablement name et state.

Exemple de commande avec tri :

gcloud managed-kafka connectors list test-connect-cluster \
    --location=us-central1 \
    --sort-by=~state,name

Exemple de commande avec filtrage et limitation :

gcloud managed-kafka connectors list test-connect-cluster \
    --location=us-central1 \
    --filter="state=RUNNING AND connector_plugin='Pub/Sub Sink'" \
    --limit=5

Exemple de résultat :

NAME                                    STATE     CONNECTOR_PLUGIN
pubsub-sink-connector                   RUNNING   Pub/Sub Sink
another-pubsub-sink                     RUNNING   Pub/Sub Sink
prod-pubsub-sink                        RUNNING   Pub/Sub Sink

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/iterator"
	"google.golang.org/api/option"

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

func listConnectors(w io.Writer, projectID, region, connectClusterID string, opts ...option.ClientOption) error {
	// projectID := "my-project-id"
	// region := "us-central1"
	// connectClusterID := "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()

	parent := fmt.Sprintf("projects/%s/locations/%s/connectClusters/%s", projectID, region, connectClusterID)
	req := &managedkafkapb.ListConnectorsRequest{
		Parent: parent,
	}
	connectorIter := client.ListConnectors(ctx, req)
	for {
		connector, err := connectorIter.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return fmt.Errorf("connectorIter.Next() got err: %w", err)
		}
		fmt.Fprintf(w, "Got connector: %v", connector)
	}
	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.ConnectClusterName;
import com.google.cloud.managedkafka.v1.Connector;
import com.google.cloud.managedkafka.v1.ManagedKafkaConnectClient;
import java.io.IOException;

public class ListConnectors {

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

  public static void listConnectors(String projectId, String region, String clusterId)
      throws IOException {
    try (ManagedKafkaConnectClient managedKafkaConnectClient = ManagedKafkaConnectClient.create()) {
      ConnectClusterName parent = ConnectClusterName.of(projectId, region, clusterId);
      // This operation is handled synchronously.
      for (Connector connector : managedKafkaConnectClient.listConnectors(parent).iterateAll()) {
        System.out.println(connector.getAllFields());
      }
    } catch (IOException | ApiException e) {
      System.err.printf("managedKafkaConnectClient.listConnectors 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.cloud import managedkafka_v1
from google.cloud.managedkafka_v1.services.managed_kafka_connect import (
    ManagedKafkaConnectClient,
)
from google.api_core.exceptions import GoogleAPICallError

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

connect_client = ManagedKafkaConnectClient()

request = managedkafka_v1.ListConnectorsRequest(
    parent=connect_client.connect_cluster_path(project_id, region, connect_cluster_id),
)

try:
    response = connect_client.list_connectors(request=request)
    for connector in response:
        print("Got connector:", connector)
except GoogleAPICallError as e:
    print(f"Failed to list connectors with error: {e}")

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.

Lister tous les connecteurs Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.