Captura las métricas y el seguimiento de Bigtable mediante Cloud Trace, Cloud Monitoring y OpenCensus

En este instructivo, se muestra cómo implementar el registro del seguimiento y las métricas del cliente en las cargas de trabajo de Cloud Bigtable mediante OpenCensus, Trace y Cloud Monitoring.

Si bien Bigtable muestra varias métricas útiles del servidor con Trace, las apps pueden obtener beneficios adicionales si implementan métricas definidas por las apps, la instrumentación y el seguimiento del cliente. Por ejemplo, las métricas del servidor no proporcionan una ventana a la latencia de ida y vuelta de las llamadas realizadas al extremo de Bigtable y solo pueden obtenerse mediante el seguimiento del cliente.

OpenCensus es una biblioteca de código abierto que puedes usar para proporcionar observabilidad en tus apps. La biblioteca es independiente de los proveedores y se integra a varios backends, como Prometheus y Zipkin. En este instructivo, usarás Trace y Monitoring como backend para el seguimiento y las métricas.

Para completar los pasos de este instructivo, debes estar familiarizado con la línea de comandos de Linux. Aunque no es obligatorio, el conocimiento del lenguaje de programación Java te ayuda a comprender el código de ejemplo.

Objetivos

  • Implementar una instancia de Bigtable
  • Implementar una máquina virtual (VM) de Compute Engine a fin de ejecutar un ejemplo de cliente de Java con instrumentación de OpenCensus
  • Descargar, implementar y ejecutar la app cliente con instrumentación de Java
  • Ver seguimientos de OpenCensus en Cloud Trace
  • Ver las métricas de OpenCensus en el Explorador de métricas en Monitoring

Costos

En este instructivo, se usan los siguientes componentes facturables de Google Cloud:

Para generar una estimación de costos en función del uso previsto, usa la calculadora de precios. Es posible que los usuarios nuevos de Google Cloud sean aptos para obtener una prueba gratuita.

Antes de comenzar

  1. Accede a tu Cuenta de Google.

    Si todavía no tienes una cuenta, regístrate para obtener una nueva.

  2. En la página de selección de proyectos de Cloud Console, selecciona o crea un proyecto de Cloud.

    Ir a la página Selector de proyectos

  3. Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud. Obtén información sobre cómo confirmar que tienes habilitada la facturación para tu proyecto.

  4. Habilita las API de Compute Engine, Bigtable, and Cloud Logging.

    Habilita las API

  5. Instala e inicializa el SDK de Cloud.

Arquitectura de referencia

Para simplificarlo, en este instructivo implementarás toda la lógica del cliente en una app de la consola de Java. Para el nivel del almacén de datos, debes usar Bigtable, que te permite enfocarte en los aspectos clave del seguimiento y las métricas del cliente sin tener que preocuparte por cuestiones como las implementaciones de bases de datos y la configuración relacionada.

En el siguiente diagrama de arquitectura, se muestra una app de la consola de Java y un nivel del almacén de datos.

Arquitectura de referencia que muestra una app de la consola de Java y un nivel del almacén de datos.

Crea una instancia de Bigtable

En esta sección, crearás una instancia de Bigtable que tu app de Java usará más adelante en el instructivo.

  • En Cloud Shell, crea una instancia de desarrollo de Bigtable:

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

Este comando puede tardar unos minutos en completarse.

Crea y configura una VM de Compute Engine

  • En Cloud Shell, crea una VM de Compute Engine con los permisos de seguridad necesarios para 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"
    

App de Java de muestra

En esta sección, se usa una app de Java de muestra que genera transacciones para demostrar las capacidades de seguimiento de OpenCensus y Logging.

Flujo de la app

La app de Java de muestra que se ejecuta en la VM de Compute Engine hace lo siguiente:

  1. Crea una tabla en la instancia de Bigtable.
  2. Para una serie de 10,000 conjuntos de transacciones, realiza lo siguiente:
    1. Escribe un pequeño conjunto de filas.
    2. Lee una sola fila.
    3. Realiza un análisis de tabla para esas filas.
  3. Borra la tabla.

Implementa la app de muestra

En esta sección, debes descargar la app de Java que contiene el código instrumentado, modificarlo para reflejar el entorno y, luego, ejecutarlo.

  1. En Cloud Console, ve a la página Instancias de VM:

    IR A LA PÁGINA INSTANCIAS DE VM

  2. Puedes usar SSH para conectarte a la VM si haces clic en el botón SSH (destacado en la siguiente captura de pantalla):

    Usa SSH para conectarte a la VM

  3. En la instancia de VM, instala Git, el JDK de Java 8 y Maven:

    sudo apt-get install git openjdk-8-jdk maven -y
    
  4. En la instancia, clona el repositorio de origen de este instructivo:

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

    Ahora, puedes actualizar la app de Java con algunas opciones de configuración específicas del proyecto.

  5. Navega a la carpeta que contiene la fuente de Java:

    cd community/tutorials/bigtable-oc/java/
    
  6. Configura el código de la app para usar la instancia de Bigtable cbt-oc:

    export INSTANCE_ID=cbt-oc
    
  7. Ejecuta los comandos de Maven para compilar y ejecutar el programa:

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

    El resultado es similar al siguiente:

    ...
    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.
    

Aspectos destacados del código de la app de muestra

En el siguiente segmento de código, la instancia de Bigtable se proporciona al entorno de ejecución de Java mediante la variable de entorno INSTANCE_ID que configuraste con anterioridad.

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

En el siguiente segmento de código, se muestra cómo definir un permiso de seguimiento etiquetado de forma manual:

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();

Observa el bloque try con la llamada a spanBuilder. Esto ilustra cómo el programa usa OpenCensus para realizar el seguimiento. La cadena de llamadas que realiza las operaciones de escritura y lectura de tablas en la función doBigTableOperations se instrumenta de esta manera.

El programa también configura Cloud Trace como el backend de seguimiento:

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();

Ve los seguimientos en Cloud Trace

El programa de muestra realiza 10,000 conjuntos de transacciones: tres escrituras y un rango de lectura. El exportador está configurado para registrar una muestra de seguimiento por cada 1,000 conjuntos de transacciones. Como resultado, se capturan entre 10 y 11 seguimientos durante la ejecución del programa.

Una vez que el programa se ejecutó por un breve período, haz lo siguiente:

  1. En Cloud Console, ve a Trace:

    Ir a Seguimiento

  2. Haz clic en Trace List (Lista de seguimiento).

    A la derecha, deberías ver una tabla similar a la siguiente:

    Tabla de lista de seguimiento.

    La tasa de muestreo de los seguimientos está configurada para registrar un seguimiento por cada 1,000 transacciones.

    La etiqueta de seguimiento opencensus.Bigtable.Tutorial en el Cronograma es el nombre del permiso de seguimiento más externo que se define en el siguiente fragmento de código.

    // sample every 1000 transactions
    configureOpenCensusExporters(Samplers.probabilitySampler(1/1000.0));
  3. Selecciona opencensus.Bigtable.Tutorial. Esto abre una vista de desglose que muestra más información sobre la cadena de llamadas, junto con otra información útil como permisos de seguimiento para las llamadas discretas a la API instrumentadas en la biblioteca cliente y las latencias de llamada a nivel de las operaciones.

    Por ejemplo, cada una de las series de filas de escritura y lectura se encapsulan mediante los intervalos de seguimiento WriteRows y ReadRows definidos por el usuario y de menor nivel.

    Debajo de ReadRows, puedes ver la operación get, seguida de las operaciones de análisis de tablas.

    Operación get y operaciones de análisis de tablas.

    Los otros elementos incluidos en la lista de seguimiento, como Operation.google.bigtable.admin.v2.BigtableTableAdmin.CreateTable, se produjeron fuera del permiso de seguimiento definido de forma manual. Como resultado, estos elementos se incluyen como operaciones distintas en la lista.

Ve las métricas en Monitoring

En el código de la app, se muestra cómo medir y registrar la latencia y el recuento de transacciones.

Para las métricas, no hay muestreo. Cada valor registrado se incluye en las representaciones de las métricas. Cada métrica se define según el tipo de medida que se realizará. En este ejemplo, la latencia de escritura se registra en unidades de microsegundos:

// 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 distribución se agrega y almacena mediante estos depósitos: 0 a 5 ms, 5 a 10 ms, 10 a 25 ms, etcétera.

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)),

Las tres métricas (latencia de escritura, latencia de lectura y recuento de transacciones) se registran mediante una sola llamada al registrador:

// 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();

Puedes revisar las métricas capturadas:

  1. En Google Cloud Console, ve a Monitoring o usa el siguiente botón:
    Ir a Monitoring
  2. Haz clic en Paneles de control
  3. Haz clic en Crear panel de control.
  4. En el campo Nombre del panel de control, ingresa Cloud Bigtable Metrics.
  5. Haz clic en Agregar gráfico.
  6. Asegúrate de que esté seleccionada la pestaña Métrica.
  7. Haz clic en el cuadro Find resource type and metric (Buscar tipo de recurso y métrica) y, luego, ingresa opencensus/btappmetrics/write_latency.
  8. En el menú desplegable, selecciona Heatmap (Mapa de calor). Se muestra el gráfico del mapa de calor de distribución.
  9. Haz clic en Guardar gráfico.
  10. Agrega gráficos al panel para los siguientes recursos supervisados: opencensus/btappmetrics/read_latency y opencensus/btappmetrics/transaction_set_count.
  11. Haz clic en Paneles de control/Métricas de Cloud Bigtable. Se muestran los tres gráficos de métricas.
  12. Para acercar la imagen, selecciona un intervalo de tiempo, haz clic en uno de los gráficos y arrastra el puntero hasta el borde del gráfico. Para los mapas de calor, puedes ver más detalles sobre la distribución si mantienes el cursor sobre los diferentes bloques de colores.

    Detalles de distribución para los mapas de calor.

    El Explorador de métricas muestra un mapa de calor de la latencia de escritura. Como se muestra en la imagen, 2,108 muestras de métricas se encuentran en el depósito de 5 a 10 ms.

Limpieza

  1. En Cloud Console, ve a la página Administrar recursos.

    Ir a la página Administrar recursos

  2. En la lista de proyectos, selecciona el proyecto que deseas borrar y haz clic en Borrar .
  3. En el cuadro de diálogo, escribe el ID del proyecto y haz clic en Cerrar para borrar el proyecto.

Próximos pasos