Capturer le traçage et les métriques Cloud Bigtable à l'aide de Cloud Trace, de Cloud Monitoring et d'OpenCensus

Ce tutoriel explique comment mettre en œuvre le traçage côté client et l'enregistrement des métriques dans vos charges de travail Cloud Bigtable en utilisant OpenCensus, Trace et Cloud Monitoring.

Bien que Cloud Bigtable propose un ensemble de métriques côté serveur utiles via Trace, les applications peuvent retirer des avantages supplémentaires de la mise en œuvre côté client des fonctionnalités de traçage et d'instrumentation ainsi que des métriques définies par l'application. À titre d'exemple, les métriques côté serveur ne vous permettent pas de connaître la latence aller-retour des appels passés vers le point de terminaison Cloud Bigtable, car celle-ci ne peut être mise en évidence que par un traçage côté client.

OpenCensus est une bibliothèque Open Source qui vous permet d'offrir de la visibilité au sein de vos applications. Cette bibliothèque est indépendante des fournisseurs et s'intègre à plusieurs backends, tels que Prometheus et Zipkin. Dans ce tutoriel, vous utiliserez Trace et Monitoring comme backend pour le traçage et les métriques.

Pour suivre ce tutoriel, vous devez maîtriser la ligne de commande Linux. Sans être obligatoire, la connaissance du langage de programmation Java vous aidera à comprendre l'exemple de code.

Objectifs

  • Déployer une instance Cloud Bigtable
  • Déployer une machine virtuelle Compute Engine pour exécuter un exemple de client Java instrumenté par OpenCensus
  • Télécharger, déployer et exécuter l'application cliente Java instrumentée
  • Afficher les traces OpenCensus dans Cloud Trace
  • Afficher les métriques OpenCensus dans l'explorateur de métriques de Monitoring

Coûts

Ce tutoriel utilise les composants facturables suivants de Google Cloud :

Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût. Les nouveaux utilisateurs de Google Cloud peuvent bénéficier d'un essai gratuit.

Avant de commencer

  1. Connectez-vous à votre compte Google Cloud. Si vous débutez sur Google Cloud, créez un compte pour évaluer les performances de nos produits en conditions réelles. Les nouveaux clients bénéficient également de 300 $ de crédits gratuits pour exécuter, tester et déployer des charges de travail.
  2. Dans Google Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud.

    Accéder au sélecteur de projet

  3. Assurez-vous que la facturation est activée pour votre projet Cloud. Découvrez comment vérifier que la facturation est activée pour votre projet.

  4. Activer les API Compute Engine, Cloud Bigtable, and Cloud Logging.

    Activer les API

  5. Installez et initialisez le SDK Cloud.

Architecture de référence

Pour plus de simplicité, dans ce tutoriel, vous allez mettre en œuvre l'ensemble de votre logique côté client dans une application de console Java. Pour le niveau datastore, vous utilisez Cloud Bigtable, qui vous permet de vous concentrer sur les aspects clés du traçage et des métriques côté client sans avoir à vous soucier des déploiements de bases de données et de la configuration associée.

Le schéma d'architecture suivant présente une application de console Java et un niveau datastore.

Architecture de référence montrant une application de console Java et un niveau datastore.

Créer une instance Cloud Bigtable

Dans cette section, vous allez créer une instance Cloud Bigtable que votre application Java utilisera ultérieurement dans le tutoriel.

  • Dans Cloud Shell, créez une instance de développement Cloud Bigtable :

    gcloud bigtable instances create cbt-oc \
      --cluster=cbt-oc \
      --cluster-zone=us-central1-c \
      --display-name=cbt-oc \
      --instance-type=DEVELOPMENT
    

L'exécution de cette commande peut prendre quelques minutes.

Créer et configurer une VM Compute Engine

  • Dans Cloud Shell, créez une VM Compute Engine en spécifiant les champs d'application de sécurité requis pour 0Auth 2.0 :

    gcloud compute instances create trace-client \
        --zone=us-central1-c \
        --scopes="https://www.googleapis.com/auth/bigtable.admin.table,\
    https://www.googleapis.com/auth/bigtable.data,\
    https://www.googleapis.com/auth/logging.write,\
    https://www.googleapis.com/auth/monitoring.write,\
    https://www.googleapis.com/auth/trace.append"
    

Exemple d'application Java

Cette section utilise un exemple d'application Java qui génère des transactions afin de montrer les capacités de traçage d'OpenCensus et de Logging.

Déroulement des opérations de l'application

L'exemple d'application Java exécuté sur la VM Compute Engine effectue les opérations suivantes :

  1. Crée une table dans l'instance Cloud Bigtable.
  2. Pour une série de 10 000 ensembles de transactions, exécute la procédure suivante :
    1. Écrit un petit ensemble de lignes.
    2. Lit une seule ligne.
    3. Effectue une analyse de table pour localiser ces lignes.
  3. Supprime la table.

Déployer l'exemple d'application

Dans cette section, vous allez télécharger l'application Java contenant le code instrumenté, modifier celle-ci en fonction de votre environnement, puis l'exécuter.

  1. Dans Cloud Console, accédez à la page Instances de VM :

    ACCÉDER À LA PAGE INSTANCES DE VM

  2. Utilisez SSH pour vous connecter à la VM en cliquant sur le bouton SSH (mis en évidence dans la capture d'écran suivante) :

    Se connecter à la VM via SSH.

  3. Sur l'instance de VM, installez Git, le JDK Java 8 et Maven :

    sudo apt-get install git openjdk-8-jdk maven -y
    
  4. Sur cette même instance, clonez le dépôt source destiné au présent tutoriel :

    git clone https://github.com/GoogleCloudPlatform/community.git
    

    Vous pouvez désormais mettre à jour l'application Java pour y intégrer certains paramètres de configuration spécifiques de votre projet.

  5. Accédez au dossier contenant la source Java :

    cd community/tutorials/bigtable-oc/java/
    
  6. Configurez le code d'application pour utiliser l'instance Cloud Bigtable cbt-oc :

    export INSTANCE_ID=cbt-oc
    
  7. Exécutez à présent les commandes Maven permettant de créer et d'exécuter le programme :

    mvn package -DskipTests --quiet
    mvn exec:java -Dexec.mainClass=com.example.bigtable.App --quiet
    

    La sortie ressemble à ceci :

    ...
    2019-05-13 23:31:54 INFO  BigtableSession:89 - Opening connection for projectId your-project, instanceId cbt-oc, on data host bigtable.googleapis.com, admin host bigtableadmin.googleapis.com.
    2019-05-13 23:31:54 INFO  BigtableSession:89 - Bigtable options: {......}
    2019-05-13 23:31:54 INFO  OAuthCredentialsCache:89 - Refreshing the OAuth token
    2019-05-13 23:31:55 INFO  App:170 - Create table Hello-Bigtable
    2019-05-13 23:35:36 INFO  App:209 - Delete the table
    2019-05-13 23:35:36 WARN  BigtableAdmin:116 - Table Hello-Bigtable was disabled in memory only.
    

Remarques importantes sur le code de l'application

Dans le segment de code suivant, l'instance Cloud Bigtable est fournie au moteur d'exécution Java via la variable d'environnement INSTANCE_ID que vous avez définie précédemment.

private static final String PROJECT_ID = ServiceOptions.getDefaultProjectId();
private static final String INSTANCE_ID = System.getenv( "INSTANCE_ID");

Le segment de code ci-dessous montre comment définir un champ d'application de traçage à libellé manuel :

try (Scope ss = tracer.spanBuilder("opencensus.Bigtable.Tutorial").startScopedSpan()) {

    // generate unique UUID
    UUID uuid = UUID.randomUUID();
    String randomUUIDString = uuid.toString();

    startWrite = System.currentTimeMillis();
    // write to Bigtable
    writeRows(table, randomUUIDString);
    endWrite = System.currentTimeMillis();

    startRead = System.currentTimeMillis();
    // read from Bigtable
    readRows(table, randomUUIDString);
    endRead = System.currentTimeMillis();

Remarquez le bloc try contenant l'appel de spanBuilder. Celui-ci montre comment le programme fait appel à OpenCensus pour effectuer le traçage. C'est ainsi qu'est instrumentée la chaîne d'appel qui effectue les écritures et les lectures dans la table au sein de la fonction doBigTableOperations.

Le programme configure également Cloud Trace en tant que backend de traçage :

private static void configureOpenCensusExporters(Sampler sampler) throws IOException {
    TraceConfig traceConfig = Tracing.getTraceConfig();

    // For demo purposes, lets always sample.

    traceConfig.updateActiveTraceParams(
      traceConfig.getActiveTraceParams().toBuilder().setSampler(sampler).build());

    // Create the Stackdriver trace exporter
    StackdriverTraceExporter.createAndRegister(
      StackdriverTraceConfiguration.builder()
        .setProjectId(PROJECT_ID)
        .build());

    // [Start Stackdriver Monitoring]
    StackdriverStatsExporter.createAndRegister();

Afficher les traces dans Cloud Trace

L'exemple de programme exécute 10 000 ensembles de transactions comprenant chacun trois écritures et une lecture de plage. L'exportateur est configuré pour enregistrer un échantillon de trace pour 1 000 ensembles de transactions. Le programme capture par conséquent 10 ou 11 traces au cours de son exécution.

Après avoir exécuté le programme pendant une courte période, procédez comme suit :

  1. Dans Cloud Console, accédez à Trace :

    Accédez à Trace.

  2. Cliquez sur Trace list (Liste de traces).

    Sur la droite, un tableau semblable à celui-ci s'affiche :

    Tableau contenant la liste des traces.

    La fréquence d'échantillonnage des traces est définie de façon à enregistrer une trace pour chaque tranche de 1 000 transactions.

    Le libellé de traçage opencensus.Bigtable.Tutorial dans la section Timeline (Historique) est le nom du champ d'application de traçage le plus externe défini dans l'extrait de code suivant.

    // sample every 1000 transactions
    configureOpenCensusExporters(Samplers.probabilitySampler(1/1000.0));
  3. Sélectionnez opencensus.Bigtable.Tutorial. Une vue détaillée affiche alors des informations supplémentaires sur la chaîne d'appel, ainsi que d'autres informations utiles telles que les champs d'application de traçage des appels d'API discrets instrumentés dans la bibliothèque cliente et les latences d'appel au niveau des opérations.

    Par exemple, chaque série de lignes d'écriture et de lecture est encapsulée par les délais de traçage de niveau inférieur définis par l'utilisateur WriteRows et ReadRows.

    Au-dessous de ReadRows, vous distinguez l'opération get, suivie des opérations d'analyse de table.

    Opération get et opérations d'analyse de table.

    Les autres éléments inclus dans la liste de traces, tels que Operation.google.bigtable.admin.v2.BigtableTableAdmin.CreateTable, se trouvaient en dehors du champ d'application de traçage défini manuellement. Par conséquent, ces éléments sont inclus en tant qu'opérations séparées dans la liste.

Afficher les métriques dans Monitoring

Le code de l'application indique comment mesurer et enregistrer la latence et le nombre de transactions.

Les métriques ne font l'objet d'aucun échantillonnage. Chaque valeur enregistrée est incluse dans leurs représentations. Chacune des métriques est définie par le type de mesure à effectuer. Dans cet exemple, la latence d'écriture est enregistrée avec la microseconde comme unité :

// The write latency in milliseconds
private static final MeasureDouble M_WRITE_LATENCY_MS = MeasureDouble.create("btapp/write_latency", "The latency in milliseconds for write", "ms");

La distribution est agrégée et stockée selon les segments suivants : 0 à 5 ms, 5 à 10 ms, 10 à 25 ms, etc.

Aggregation latencyDistribution = Distribution.create(BucketBoundaries.create(
        Arrays.asList(
            0.0, 5.0, 10.0, 25.0, 100.0, 200.0, 400.0, 800.0, 10000.0)));
View.create(Name.create("btappmetrics/write_latency"),
            "The distribution of the write latencies",
            M_WRITE_LATENCY_MS,
            latencyDistribution,
            Collections.singletonList(KEY_LATENCY)),

Les trois métriques (latence d'écriture, latence de lecture et nombre de transactions) sont enregistrées via un appel unique de l'enregistreur :

// record read, write latency metrics and count
STATS_RECORDER.newMeasureMap()
              .put(M_READ_LATENCY_MS, endRead - startRead)
              .put(M_WRITE_LATENCY_MS, endWrite - startWrite)
              .put(M_TRANSACTION_SETS, 1)
              .record();

Vous pouvez maintenant examiner les métriques capturées :

  1. Dans Google Cloud Console, accédez à Surveillance ou utilisez le bouton suivant :
    Accéder à Surveillance
  2. Cliquez sur Tableaux de bord.
  3. Cliquez sur Créer un tableau de bord.
  4. Dans le champ Nom du tableau de bord, saisissez Cloud Bigtable Metrics.
  5. Cliquez sur Add Chart (Ajouter un graphique).
  6. Assurez-vous que l'onglet Métrique est sélectionné.
  7. Cliquez dans la zone intitulée Find resource type and metric (Rechercher le type de ressource et la métrique), puis saisissez opencensus/btappmetrics/write_latency.
  8. Dans le menu déroulant, sélectionnez Carte de densité. Le graphique de carte de densité de distribution s'affiche.
  9. Cliquez sur Enregistrer le graphique.
  10. Ajoutez des graphiques à votre tableau de bord pour les ressources surveillées suivantes : opencensus/btappmetrics/read_latency et opencensus/btappmetrics/transaction_set_count.
  11. Cliquez sur Tableaux de bord/Métriques Cloud Bigtable. Les graphiques correspondant aux trois métriques sont affichés.
  12. Pour effectuer un zoom avant, sélectionnez une période, cliquez sur l'un des graphiques et faites glisser le pointeur vers le bord du graphique. Pour les cartes de densité, vous pouvez afficher plus de détails sur la distribution en plaçant le curseur sur les différents blocs colorés.

    Détails de la distribution pour les cartes de densité.

    L'explorateur de métriques affiche la carte de densité de la latence d'écriture. Comme le montre l'image, 2108 échantillons de cette métrique sont compris dans le segment de 5 à 10 ms.

Nettoyer

  1. Dans Cloud Console, accédez à la page Gérer les ressources.

    Accéder à la page Gérer les ressources

  2. Dans la liste des projets, sélectionnez le projet que vous souhaitez supprimer, puis cliquez sur Supprimer.
  3. Dans la boîte de dialogue, saisissez l'ID du projet, puis cliquez sur Arrêter pour supprimer le projet.

Étape suivante