Afficher un sujet Google Cloud Managed Service pour Apache Kafka

Pour afficher les informations détaillées sur un sujet, vous pouvez utiliser la Google Cloud console, la Google Cloud CLI, la bibliothèque cliente, l'API Managed Kafka ou les API Apache Kafka Open Source.

Rôles et autorisations requis pour afficher un sujet

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

Autorisations requises

Les autorisations suivantes sont requises pour afficher un sujet :

  • Lister les sujets : managedkafka.topics.list
  • Obtenir le sujet : managedkafka.topics.get

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

Propriétés du sujet dans la console

Dans la console, vous pouvez afficher les propriétés de sujet suivantes :

  • Configurations : cet onglet fournit des informations de configuration générales sur le sujet, y compris les suivantes :

    • Nom : identifiant unique du sujet dans le cluster.

    • Partitions : nombre de partitions dans le sujet. Les partitions divisent les données du sujet en segments pour assurer l'évolutivité et le parallélisme.

    • Réplicas : nombre de copies (réplicas) conservées pour chaque partition afin de garantir la redondance et la disponibilité des données.

    • Cluster : nom du cluster Managed Service pour Apache Kafka auquel appartient le sujet.

    • Région : Google Cloud région dans laquelle se trouvent le cluster et le sujet.

    • Paramètres de sujet non par défaut : tous les remplacements de configuration au niveau du sujet qui ont été définis pour le sujet, différents des valeurs par défaut à l’échelle du cluster.

  • Surveillance : cet onglet fournit des graphiques visuels qui affichent les métriques clés liées à l'activité et aux performances du sujet. Ces graphiques incluent les éléments suivants :

    • Nombre d'octets : graphique de série temporelle indiquant le taux de production ou d'envoi d'octets au sujet. Il indique le volume de données publiées dans le sujet au fil du temps. La métrique correspondante est managedkafka.googleapis.com/byte_in_count.

    • Nombre de requêtes : graphique de série temporelle représentant le taux de requêtes adressées au sujet. Il reflète l'activité et l'utilisation globales du sujet. La métrique associée est managedkafka.googleapis.com/topic_request_count.

    • Segments de journal par partition : ce graphique affiche le nombre de segments de journal actifs pour chaque partition du sujet. Les segments de journal sont les fichiers physiques sur disque dans lesquels Kafka stocke les données du sujet. La métrique pertinente est managedkafka.googleapis.com/log_segments.

  • Groupes de consommateurs : cette section liste les groupes de consommateurs qui sont abonnés au sujet. Un groupe de consommateurs est un ensemble de consommateurs qui travaillent ensemble pour lire les messages du sujet.

Afficher un sujet

Console

  1. Dans la console Google Cloud , accédez à la page Clusters.

    Accéder aux clusters

    Les clusters que vous avez créés dans un projet sont listés.

  2. Cliquez sur le cluster dont vous souhaitez afficher les sujets.

    La page d'informations du cluster s'affiche. Dans la page d'informations du cluster, les sujets sont listés dans l'onglet Ressources.

  3. Pour afficher un sujet spécifique, cliquez sur son nom.

    La page d'informations du sujet s'affiche.

gcloud

  1. Dans la Google Cloud console, activez Cloud Shell.

    Activer Cloud Shell

    En bas de la Google Cloud console, une session Cloud Shell démarre et affiche une invite de ligne de commande. Cloud Shell est un environnement shell dans lequel Google Cloud CLI est déjà installé, et dans lequel des valeurs sont déjà définies pour votre projet actuel. L'initialisation de la session peut prendre quelques secondes.

  2. Exécutez la gcloud managed-kafka topics describe commande :

    gcloud managed-kafka topics describe TOPIC_ID \
  --cluster=CLUSTER_ID --location=LOCATION_ID

    Cette commande récupère et affiche des informations complètes sur le sujet spécifié. Ces informations incluent ses paramètres de configuration, tels que le nombre de partitions, le facteur de réplication et tous les remplacements de configuration au niveau du sujet.

    Remplacez les éléments suivants :

    • TOPIC_ID : ID du sujet.
    • CLUSTER_ID : ID du cluster contenant le sujet.
    • LOCATION_ID : emplacement du cluster.

La commande gcloud managed-kafka topics describe affiche des informations minimales sur un sujet, telles que le nombre de partitions et le facteur de réplication. Pour obtenir des informations plus détaillées, y compris les affectations de partitions et l'ensemble complet des paramètres de configuration, utilisez l'outil de ligne de commande kafka-topics.sh.

CLI Kafka

Avant d'exécuter cette commande, installez les outils de ligne de commande Kafka sur une VM Compute Engine. La VM doit pouvoir atteindre un sous-réseau connecté à votre cluster Managed Service pour Apache Kafka. Suivez les instructions de la section Produire et consommer des messages avec les outils de ligne de commande Kafka.

Pour afficher les détails d'un sujet, exécutez la commande kafka-topics.sh --describe :

kafka-topics.sh --describe \
  --bootstrap-server=BOOTSTRAP_ADDRESS \
  --command-config client.properties \
  --topic TOPIC_ID

Remplacez les éléments suivants :

  • BOOTSTRAP_ADDRESS : adresse d'amorçage du cluster Managed Service pour Apache Kafka.
  • TOPIC_ID : ID du sujet.

Cette commande renvoie un sous-ensemble des propriétés du sujet, y compris les suivantes :

  • Nombre de partitions
  • Facteur de réplication
  • Affectations de partitions
  • Configuration dynamique (paramètres que vous avez définis explicitement)
  • Configuration statique (paramètres appliqués au démarrage du cluster)

Pour afficher l'ensemble complet des paramètres de configuration d'un sujet, y compris les paramètres avec des valeurs par défaut, exécutez la commande kafka-configs.sh --describe :

kafka-configs.sh --describe \
--bootstrap-server=BOOTSTRAP_ADDRESS \
--command-config client.properties \
--entity-type topics \
--entity-name TOPIC_ID \
--all

La sortie est une liste de paramètres sous forme de paires clé/valeur. L'option --all renvoie tous les paramètres de configuration. Pour obtenir la liste des paramètres de configuration dynamiques uniquement, omettez l'option --all.

REST

Avant d'utiliser les données de requête, effectuez les remplacements suivants :

  • PROJECT_ID: ID de votre Google Cloud projet
  • LOCATION : emplacement du cluster
  • CLUSTER_ID : ID du cluster
  • TOPIC_ID : ID du sujet

Méthode HTTP et URL : 

GET https://managedkafka.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/clusters/CLUSTER_ID/topics/TOPIC_ID

Pour envoyer votre requête, développez l'une des options suivantes :

Vous devriez recevoir une réponse JSON de ce type :

{
  "name": "projects/PROJECT_ID/locations/LOCATION/clusters/CLUSTER_ID/topics/TOPIC_ID",
  "partitionCount": PARTITION_COUNT,
  "replicationFactor": REPLICATION_FACTOR
}

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(ADC). 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 getTopic(w io.Writer, projectID, region, clusterID, topicID string, opts ...option.ClientOption) error {
	// projectID := "my-project-id"
	// region := "us-central1"
	// clusterID := "my-cluster"
	// topicID := "my-topic"
	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)
	topicPath := fmt.Sprintf("%s/topics/%s", clusterPath, topicID)
	req := &managedkafkapb.GetTopicRequest{
		Name: topicPath,
	}
	topic, err := client.GetTopic(ctx, req)
	if err != nil {
		return fmt.Errorf("client.GetTopic got err: %w", err)
	}
	fmt.Fprintf(w, "Got topic: %#v\n", topic)
	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 Managed Service pour Apache Kafka en langage Java.

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.ManagedKafkaClient;
import com.google.cloud.managedkafka.v1.Topic;
import com.google.cloud.managedkafka.v1.TopicName;
import java.io.IOException;

public class GetTopic {

  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 topicId = "my-topic";
    getTopic(projectId, region, clusterId, topicId);
  }

  public static void getTopic(String projectId, String region, String clusterId, String topicId)
      throws Exception {
    try (ManagedKafkaClient managedKafkaClient = ManagedKafkaClient.create()) {
      // This operation is being handled synchronously.
      Topic topic =
          managedKafkaClient.getTopic(TopicName.of(projectId, region, clusterId, topicId));
      System.out.println(topic.getAllFields());
    } catch (IOException | ApiException e) {
      System.err.printf("managedKafkaClient.getTopic got err: %s", 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 de 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.

from google.api_core.exceptions import NotFound
from google.cloud import managedkafka_v1

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

client = managedkafka_v1.ManagedKafkaClient()

topic_path = client.topic_path(project_id, region, cluster_id, topic_id)
request = managedkafka_v1.GetTopicRequest(
    name=topic_path,
)

try:
    topic = client.get_topic(request=request)
    print("Got topic:", topic)
except NotFound as e:
    print(f"Failed to get topic {topic_id} with error: {e.message}")

Étape suivante