Afficher un connecteur

L'affichage des détails d'un connecteur vous permet d'inspecter sa configuration, son état opérationnel et sa règle de redémarrage des tâches, et de surveiller ses métriques de performances.

Pour afficher les détails d'un connecteur dans 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 afficher les connecteurs.

Rôles et autorisations requis pour afficher un connecteur

Pour obtenir les autorisations nécessaires pour afficher un connecteur, 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 afficher un connecteur. Pour connaître les autorisations exactes requises, développez la section Autorisations requises :

Autorisations requises

Les autorisations suivantes sont requises pour afficher un connecteur :

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 les détails du connecteur

Console

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

Accéder à Connect Clusters
Cliquez sur le cluster Connect qui héberge le connecteur que vous souhaitez afficher.

La page Connecter les détails du cluster s'affiche.
Dans l'onglet Ressources, recherchez le connecteur dans la liste, puis cliquez sur son nom. Vous êtes redirigé vers la page Informations sur le connecteur.
La page Détails du connecteur comporte les onglets suivants :
- Configuration : affiche la configuration du connecteur, y compris :
  - Nom : nom du connecteur.
  - État : état opérationnel du connecteur. Par exemple, "Course à pied".
  - Règle de redémarrage des tâches : règle de redémarrage des tâches ayant échoué. Par exemple, s'il faut redémarrer les tâches ayant échoué ou non, et avec quels paramètres de délai avant nouvelle tentative.
  - Propriétés de configuration : liste de paires clé/valeur définissant la configuration du connecteur.
- Surveillance : fournit des graphiques pour surveiller le connecteur, par exemple :
  - Nombre d'erreurs de tâches : nombre de tâches ayant rencontré des erreurs.
  - Nombre de tâches actives : nombre de tâches actuellement actives.
Cette page inclut également des boutons permettant de modifier, supprimer, mettre en veille, arrêter et redémarrer le connecteur.

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 describe pour décrire un connecteur :
```
gcloud managed-kafka connectors describe CONNECTOR_ID \
    --location=LOCATION \
    --connect-cluster=CONNECT_CLUSTER_ID
```
Remplacez les éléments suivants :
- CONNECTOR_ID : valeur obligatoire. ID du connecteur que vous souhaitez décrire.
- LOCATION : valeur obligatoire. Emplacement du cluster Connect contenant le connecteur.
- CONNECT_CLUSTER_ID : valeur obligatoire. ID du cluster Connect contenant le connecteur.

Exemple de commande :

gcloud managed-kafka connectors describe test-connector \
  --location=us-central1 \
  --connect-cluster=test-connect-cluster

Exemple de résultat :

config:
  connector.class: com.google.cloud.kafka.connect.pubsub.PubsubSinkConnector
  kafka.topic.regex: .*
  key.converter: org.apache.kafka.connect.storage.StringConverter
  project: test-project
  tasks.max: '1'
  topic: test-pubsub-topic
  value.converter: org.apache.kafka.connect.json.JsonConverter
  value.converter.schemas.enable: 'false'
createTime: '2024-03-13T05:17:34.123456Z'
labels:
  test-label-key: test-label-value
name: projects/test-project/locations/us-central1/connectClusters/test-connect-cluster/connectors/test-connector
state: RUNNING
taskRestartPolicy: RESTART_WITH_EXPONENTIAL_BACKOFF
updateTime: '2024-03-13T05:18:15.987654Z'

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 getConnector(w io.Writer, projectID, region, connectClusterID, connectorID string, opts ...option.ClientOption) error {
	// projectID := "my-project-id"
	// region := "us-central1"
	// connectClusterID := "my-connect-cluster"
	// connectorID := "my-connector"
	ctx := context.Background()
	client, err := managedkafka.NewManagedKafkaConnectClient(ctx, opts...)
	if err != nil {
		return fmt.Errorf("managedkafka.NewManagedKafkaConnectClient got err: %w", err)
	}
	defer client.Close()

	connectorPath := fmt.Sprintf("projects/%s/locations/%s/connectClusters/%s/connectors/%s", projectID, region, connectClusterID, connectorID)
	req := &managedkafkapb.GetConnectorRequest{
		Name: connectorPath,
	}
	connector, err := client.GetConnector(ctx, req)
	if err != nil {
		return fmt.Errorf("client.GetConnector got err: %w", err)
	}
	fmt.Fprintf(w, "Got connector: %#v\n", 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.Connector;
import com.google.cloud.managedkafka.v1.ConnectorName;
import com.google.cloud.managedkafka.v1.ManagedKafkaConnectClient;
import java.io.IOException;

public class GetConnector {

  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";
    String connectorId = "my-connector";
    getConnector(projectId, region, clusterId, connectorId);
  }

  public static void getConnector(
      String projectId, String region, String clusterId, String connectorId) throws IOException {
    try (ManagedKafkaConnectClient managedKafkaConnectClient = ManagedKafkaConnectClient.create()) {
      ConnectorName name = ConnectorName.of(projectId, region, clusterId, connectorId);
      // This operation is handled synchronously.
      Connector connector = managedKafkaConnectClient.getConnector(name);
      System.out.println(connector.getAllFields());
    } catch (IOException | ApiException e) {
      System.err.printf("managedKafkaConnectClient.getConnector 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"
# connector_id = "my-connector"

connect_client = ManagedKafkaConnectClient()

connector_path = connect_client.connector_path(
    project_id, region, connect_cluster_id, connector_id
)
request = managedkafka_v1.GetConnectorRequest(
    name=connector_path,
)

try:
    connector = connect_client.get_connector(request=request)
    print("Got connector:", connector)
except NotFound as e:
    print(f"Failed to get connector {connector_id} 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.

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