Como processar registros em escala usando o Cloud Dataflow

O Google Cloud Platform (GCP) fornece a infraestrutura escalonável de que você precisa para processar operações de análise de registros grandes e variadas. Neste tutorial, você aprenderá como usar o GCP para criar pipelines de análise que processam entradas de registro de várias fontes. Combine dados de registro de modo que você consiga extrair informações significativas e manter insights derivados de dados, que podem ser usados para análise, revisão e geração de relatórios.

Visão geral

À medida que seu aplicativo fica mais complexo, conseguir informações sobre os dados capturados nos registros torna-se mais complicado. Os registros provêm de um número cada vez maior de origens, então podem ser difíceis de identificar e consultar para encontrar informações úteis. Criar, operar e manter sua própria infraestrutura para analisar os dados do registro em escala pode exigir uma ampla experiência na execução de sistemas e armazenamento distribuídos. Esse tipo de infraestrutura dedicada geralmente representa uma despesa única de capital, resultando em capacidade fixa, o que dificulta a escala além do investimento inicial. Essas limitações podem afetar os negócios porque levam à lentidão na geração de insights relevantes e acionáveis a partir de dados.

Nesta solução, você verá como superar essas limitações usando o GCP. Aqui, foi usado um conjunto de exemplos de microsserviços executados no Google Kubernetes Engine (GKE) para implementar um site. O Stackdriver Logging coleta registros desses serviços e os salva em intervalos do Cloud Storage. Em seguida, o Cloud Dataflow processa os registros, extraindo metadados e calculando agregações básicas. O pipeline do Cloud Dataflow foi projetado para processar os elementos de registro diariamente, a fim de gerar métricas agregadas de tempos de resposta do servidor, com base nos registros de cada dia. Por fim, o resultado do Cloud Dataflow é carregado nas tabelas do BigQuery, onde pode ser analisado para fornecer inteligência de negócios. Você também verá nesta solução uma explicação de como mudar o pipeline para que seja executado no modo de streaming, para o processamento de registros assíncrono e de baixa latência.

A solução usa vários componentes do GCP

Este tutorial fornece um exemplo de pipeline do Cloud Dataflow, uma amostra de aplicativo da Web, informações sobre configuração e as etapas para executar a amostra.

Custos

Neste tutorial, são usados vários componentes faturáveis do GCP, incluindo os seguintes:

  • GKE para implantar microsserviços.
  • Logging para receber e exportar registros.
  • Cloud Storage para armazenar os registros exportados em modo de lote.
  • Cloud Pub/Sub para fazer o streaming dos registros exportados no modo de streaming.
  • Cloud Dataflow para processar os dados dos registros.
  • BigQuery para armazenar os dados resultantes do processamento e realizar consultas avançadas nesses dados.

O custo de executar este tutorial varia de acordo com o ambiente de execução. Use a calculadora de preços para gerar uma estimativa de custo com base no uso previsto.

Novos usuários do GCP podem estar qualificados para uma avaliação gratuita.

Antes de começar

  1. Faça login na sua Conta do Google.

    Se você ainda não tiver uma, inscreva-se.

  2. Selecione ou crie um projeto do GCP.

    Acessar a página Gerenciar recursos

  3. Verifique se o faturamento foi ativado para o projeto.

    Saiba como ativar o faturamento

  4. Ativar BigQuery, Cloud Storage, Cloud Pub/Sub, Cloud Dataflow, GKE and Logging APIs.

    Ativar as APIs

  5. Crie um espaço de trabalho do Stackdriver. Para mais informações sobre espaços de trabalho, consulte Como gerenciar espaços de trabalho.

    ACESSAR o Stackdriver

Como configurar o ambiente

Neste tutorial, use o Cloud Shell para inserir comandos. O Cloud Shell dá acesso à linha de comando no Console do GCP e inclui o SDK do Cloud e outras ferramentas necessárias para o desenvolvimento no GCP. O Cloud Shell é exibido como uma janela na parte inferior do Console do GCP. A inicialização leva alguns minutos, mas a janela aparece imediatamente.

Para usar o Cloud Shell a fim de configurar o ambiente e clonar o repositório git usado neste tutorial:

  1. No Console do GCP, abra o Cloud Shell.

    ABRIR o Cloud Shell

  2. Verifique se você está trabalhando no projeto recém-criado. Substitua [YOUR_PROJECT_ID] pelo projeto do GCP recém-criado.

    gcloud config set project [YOUR_PROJECT_ID]
    
  3. Defina a zona de computação padrão. Para os fins deste tutorial, é us-east1. Se você estiver implantando em um ambiente de produção, faça isso em uma região de sua escolha.

    export REGION=us-east1
    gcloud config set compute/region $REGION
    

Como clonar o repositório da amostra

Clone o repositório que contém os scripts e a lógica do aplicativo que você usará neste tutorial.

git clone https://github.com/GoogleCloudPlatform/processing-logs-using-dataflow.git
cd processing-logs-using-dataflow/services

Configurar variáveis de ambiente

# name your bucket
export PROJECT_ID=[YOUR_PROJECT_ID]
# name your GKE cluster
export CLUSTER_NAME=cluster-processing-logs-using-dataflow

# name the bucket for this tutorial
export BUCKET_NAME=${PROJECT_ID}-processing-logs-using-dataflow

# name the logging sink for this tutorial
export SINK_NAME=sink-processing-logs-using-dataflow

# name the logging sink for this tutorial
export DATASET_NAME=processing_logs_using_dataflow

Implantar a amostra de aplicativo em um novo cluster do Google Kubernetes Engine

# create the cluster and deploy sample services
./cluster.sh $PROJECT_ID $CLUSTER_NAME up

Sobre o exemplo de implantação de aplicativo

A amostra implantada é um exemplo de aplicativo de compras. Neste exemplo, os usuários podem visitar a página inicial de um site de varejo, procurar produtos e depois tentar localizá-los em lojas físicas tradicionais próximas. O aplicativo consiste em três microsserviços: HomeService, BrowseService e LocateService. Cada um deles está disponível a partir de um endpoint da API em um namespace compartilhado. Os usuários acessam os serviços adicionando /home, /browse e /locate ao URL de base.

O aplicativo está configurado para registrar solicitações HTTP recebidas em stdout.

Como usar o Google Kubernetes Engine com o Stackdriver Logging

Neste exemplo, os microsserviços são executados em um cluster do Kubernetes Engine, que é um grupo de instâncias, ou nós, do Compute Engine que executam o Kubernetes. Por padrão, o GKE configura cada nó para fornecer uma série de serviços, incluindo monitoramento, verificação de integridade e geração centralizada de registros. Nesta solução, foi aproveitada essa compatibilidade integrada com o Logging para enviar registros de cada microsserviço para o Cloud Storage. Como alternativa para aplicativos que registram informações em arquivos que não estão cobertos por esta solução, configure a geração de registros no nível de cluster com o Kubernetes (em inglês).

Cada microsserviço é executado em um pod individual no cluster. Cada pod é executado em um nó e exposto como um único endpoint HTTP usando os serviços do GKE.

Os microsserviços são executados em nodes individuais

Cada nó no cluster executa um agente do Stackdriver Logging que captura as mensagens de registro. Depois que os registros são disponibilizados no Logging, um script os exporta automaticamente para um intervalo do Cloud Storage, aproveitando a compatibilidade com o Logging presente no SDK do Cloud.

Observe que também é possível configurar os registros para serem exportados para o Cloud Storage usando o visualizador de registros. Nesta solução, foi usado o SDK do Cloud porque ele é necessário para exportar vários registros.

Quando você usa o Cloud Storage como destino da exportação de registros, as entradas de registro do tipo LogEntry são salvas em lotes por hora, em arquivos JSON individuais. Essas entradas estruturadas do Logging incluem metadados extras que especificam quando cada mensagem de registro foi criada, qual recurso ou instância a gerou, qual o nível de gravidade e assim por diante. No exemplo a seguir de uma entrada do Logging, é possível ver no elemento structPayload.log a mensagem de registro original que foi gerada pelo microsserviço:

 {
    "insertId": "ugjuig3j77zdi",
    "labels": {
        "compute.googleapis.com/resource_name": "fluentd-gcp-v3.2.0-9q4tr",
        "container.googleapis.com/namespace_name": "default",
        "container.googleapis.com/pod_name": "browse-service-rm7v9",
        "container.googleapis.com/stream": "stdout"
    },
    "logName": "projects/processing-logs-at-scale/logs/browse-service",
    "receiveTimestamp": "2019-03-09T00:33:30.489218596Z",
    "resource": {
        "labels": {
            "cluster_name": "cluster-processing-logs-using-dataflow",
            "container_name": "browse-service",
            "instance_id": "640697565266753757",
            "namespace_id": "default",
            "pod_id": "browse-service-rm7v9",
            "project_id": "processing-logs-at-scale",
            "zone": "us-east1-d"
        },
        "type": "container"
    },
    "severity": "INFO",
    "textPayload": "[GIN] 2019/03/09 - 00:33:23 | 200 |     190.726µs |      10.142.0.6 | GET      /browse/product/1\n",
    "timestamp": "2019-03-09T00:33:23.743466177Z"
 }

Configurar a geração de registros

Depois que o cluster estiver em execução e os serviços forem implantados, será possível configurar a geração de registros para o aplicativo.

Primeiro, consiga as credenciais do cluster porque a kubectl é usada para receber os nomes de serviços para a configuração dos coletores de exportação do Stackdriver Logging.

gcloud container clusters get-credentials  $CLUSTER_NAME --region $REGION

No repositório do código, services/logging.sh configura os componentes necessários para o modo de lote ou de streaming. O script aceita estes parâmetros:

logging.sh [YOUR_PROJECT_ID] [BUCKET_NAME] [streaming|batch] [up|down]

Para fins deste tutorial, inicie a geração de registros em lote:

./logging.sh $PROJECT_ID $BUCKET_NAME batch up

As etapas abaixo dão exemplos de comandos executados no modo de lote:

  1. Crie um intervalo do Cloud Storage.

    gsutil -q mb gs://[BUCKET_NAME]

  2. Permita o acesso do Stackdriver Logging ao intervalo.

    gsutil -q acl ch -g cloud-logs@google.com:O gs://[BUCKET_NAME]

  3. Para cada microsserviço, configure as exportações do Stackdriver usando um coletor.

    gcloud logging sinks create [SINK_NAME] \ storage.googleapis.com/[BUCKET_NAME] \ --log-filter="kubernetes.home_service..." --project=[YOUR_PROJECT_ID]

Atualizar as permissões de destino

As permissões do destino, que neste caso é o intervalo do Cloud Storage, não são modificadas ao criar um coletor. Altere as configurações de permissão do seu intervalo do Cloud Storage para conceder ao coletor a permissão de gravação.

Para atualizar as permissões no seu intervalo do Cloud Storage:

  1. Identifique a Identidade do gravador do seu coletor:

    1. Acesse a página Visualizador de registros:

      Acessar a página "Visualizador de registros"

    2. Selecione Exportações no menu à esquerda para ver um resumo dos seus coletores, incluindo a Identidade do gravador.

    3. IMPORTANTE: para cada um dos três coletores, há um e-mail de conta de serviço individual que precisa receber permissões no intervalo do Cloud Storage.

  2. No Console do GCP, clique em Storage > Navegador.

    Acessar o navegador

  3. Para abrir a visualização detalhada, clique no nome do seu intervalo.

  4. Selecione Permissões e clique em Adicionar membros.

  5. Defina o Papel como Storage Object Creator e insira a identidade do gravador do coletor.

Consulte Permissões de destino para mais informações.

É possível verificar os caminhos dos objetos de registro com o comando a seguir:

gsutil ls gs://processing-logs-at-scale-processing-logs-using-dataflow/ | grep service

Se o resultado contiver todas as três entradas, como no exemplo abaixo, será possível prosseguir com as etapas para executar o pipeline de dados:

 gs://processing-logs-at-scale-processing-logs-using-dataflow/browse-service/
 gs://processing-logs-at-scale-processing-logs-using-dataflow/home-service/
 gs://processing-logs-at-scale-processing-logs-using-dataflow/locate-service/

Criar o conjunto de dados do BigQuery

bq mk $DATASET_NAME

Gerar uma carga nos serviços de aplicativos

Instalar os utilitários do servidor HTTP Apache

Você usará a ferramenta de comparação do servidor HTTP Apache (ab) [em inglês] para gerar a carga nos serviços.

sudo apt-get update

sudo apt-get install -y apache2-utils

O script de shell load.sh gera carga nos microsserviços ao solicitar respostas de HomeService, BrowseService e LocateService.

Um único conjunto de carga é composto por uma solicitação para o serviço inicial e 20 solicitações para cada um dos serviços de localização e procura.

A opção abaixo gerará mil conjuntos de carga, com a simultaneidade configurada para três solicitações.

cd ../services
./load.sh 1000 3

Aguarde alguns minutos para que seja criada uma quantidade suficiente de registros.

Iniciar o pipeline do Cloud Dataflow

Depois de permitir que uma quantidade suficiente de tráfego atinja os serviços, inicie o pipeline do Dataflow.

Para fins deste tutorial, o pipeline do Cloud Datalflow é executado em modo de lote. O script de shell pipeline.sh inicia manualmente o pipeline.

cd ../dataflow
./pipeline.sh $PROJECT_ID $DATASET_NAME $BUCKET_NAME run

Noções básicas sobre o pipeline do Cloud Dataflow

O Cloud Dataflow é um sistema simples, mas eficiente, que pode ser usado para vários tipos de tarefas de processamento de dados. O SDK do Cloud Dataflow fornece um modelo de dados unificado que representa um conjunto de dados de qualquer tamanho, incluindo um conjunto de dados ilimitado ou infinito de uma origem de dados de atualização contínua. Ele é bem adequado para o trabalho com os dados de registro nesta solução. O serviço gerenciado do Cloud Dataflow pode executar tarefas em lote e de streaming. Isso significa que você pode usar uma única base de código para o processamento de dados assíncrono ou síncrono, em tempo real e baseado em eventos.

O SDK do Dataflow fornece representações de dados simples por meio de uma classe de coleção especializada denominada PCollection. O SDK tem um recurso integrado para realizar transformações de dados personalizadas por meio da classe PTransform. No Cloud Dataflow, as transformações representam a lógica de processamento de um pipeline. As transformações podem ser usadas para diversas operações de processamento, como unir dados, calcular valores matematicamente, filtrar a saída de dados ou converter dados de um formato para outro. Para mais informações sobre pipelines, PCollections, transformações e fontes e coletores de E/S, consulte Modelo de programação do Cloud Dataflow.

O diagrama a seguir mostra as operações do pipeline para os dados de registro armazenados no Cloud Storage:

O pipeline do Cloud Dataflow tem várias etapas

O diagrama pode parecer complexo, mas o Cloud Dataflow facilita a criação e o uso do pipeline. Nas seções a seguir, você verá uma descrição das operações específicas em cada estágio do pipeline.

Como receber os dados

O pipeline começa consumindo os dados recebidos dos intervalos do Cloud Storage que contêm os registros dos três microsserviços. Cada coleção de registros se torna uma PCollection de elementos String, em que cada elemento corresponde a um único objeto LogEntry. No snippet a seguir, homeLogs, browseLogs e locateLogs são do tipo PCollection<String>:

homeLogs = p.apply("homeLogsTextRead", TextIO.read().from(options.getHomeLogSource()));
browseLogs = p.apply("browseLogsTextRead", TextIO.read().from(options.getBrowseLogSource()));
locateLogs = p.apply("locateLogsTextRead", TextIO.read().from(options.getLocateLogSource()));

Para lidar com os desafios de um conjunto de dados de atualização contínua, o SDK do Cloud Dataflow usa uma técnica chamada janelamento (windowing). A gestão de janelas subdivide de maneira lógica os dados em uma PCollection de acordo com os carimbos de data/hora de cada elemento. Como neste caso o tipo de origem é TextIO, todos os objetos são inicialmente lidos em uma única janela global, que é o comportamento padrão.

Como coletar os dados em objetos

A próxima etapa é combinar as PCollections de microsserviços individuais em uma única PCollection usando a operação Flatten.

PCollection<String> allLogs = PCollectionList
  .of(homeLogs)
  .and(browseLogs)
  .and(locateLogs)
  .apply(Flatten.<String>pCollections());

Essa operação é útil porque cada PCollection de origem contém o mesmo tipo de dados e usa a mesma estratégia de janelamento global. As origens e a estrutura de cada registro são iguais nesta solução, mas é possível estender essa abordagem para uma na qual a origem e a estrutura sejam diferentes.

Com uma única PCollection criada, agora você pode processar cada elemento String usando uma transformação personalizada que executa várias etapas na entrada de registro. Estas são as etapas:

Uma transformação processa mensagens de string para criar mensagens de registro

  • Desserialize a string JSON em um objeto Java LogEntry do Stackdriver Logging.
  • Extraia o carimbo de data/hora dos metadados LogEntry.
  • Extraia os seguintes campos individuais da mensagem de registro usando expressões regulares: timestamp, responseTime, httpStatusCode, httpMethod, endereço IP source e endpoint destination. Use esses campos para criar um objeto personalizado LogMessage com carimbo de data/hora.
  • Produza os objetos LogMessage em uma nova PCollection.

O código a seguir executa as etapas:

PCollection<LogMessage> allLogMessages = allLogs
  .apply("allLogsToLogMessage", ParDo.of(new EmitLogMessageFn(outputWithTimestamp, options.getLogRegexPattern())));

Agregar os dados por dias

Lembre-se de que o objetivo é processar os elementos diariamente para gerar métricas agregadas com base em registros de cada dia. Para ser alcançada, essa agregação requer uma função de janelamento que subdivide os dados por dia. Isso é possível porque cada LogMessage na PCollection tem um carimbo de data/hora. Após o Cloud Dataflow particionar a PCollection em limites diários, as operações compatíveis com as PCollections com janelas respeitarão o esquema de janelamento.

PCollection<LogMessage> allLogMessagesDaily = allLogMessages
  .apply("allLogMessageToDaily", Window.<LogMessage>into(FixedWindows.of(Duration.standardDays(1))));

Com uma única PCollection com janelas, agora você pode calcular métricas diárias agregadas em todas as três origens de registros de vários dias executando um único job do Cloud Dataflow.

PCollection<KV<String,Double>> destMaxRespTime = destResponseTimeCollection
  .apply(Max.<String>doublesPerKey());
 // .apply(Combine.<String,Double,Double>perKey(new Max.doublesPerKey()));

PCollection<KV<String,Double>> destMeanRespTime = destResponseTimeCollection
  .apply(Mean.<String,Double>perKey());

Primeiro, uma transformação pega os objetos LogMessage como entrada e, em seguida, produz uma PCollection de pares de chave-valor que mapeiam os endpoints de destino como chaves para valores de tempo de resposta. Usando essa PCollection, você pode calcular duas métricas agregadas: tempo máximo de resposta por destino e tempo médio de resposta por destino. Como a PCollection ainda é particionada por dia, o resultado de cada cálculo representará os dados de registro de um único dia. Isso significa que você terá duas PCollections finais: uma contendo o tempo máximo de resposta por destino por dia e outra contendo o tempo médio de resposta por destino por dia.

Calcular métricas diárias agregadas

Como carregar os dados no BigQuery

A etapa final no pipeline produz as PCollections resultantes para o BigQuery, para análise subsequente e armazenamento de dados.

Primeiro, o pipeline transforma a PCollection que contém objetos LogMessage de todas as origens de registro em uma PCollection de objetos TableRow do BigQuery. Essa etapa é necessária para aproveitar a compatibilidade interna do Cloud Dataflow para usar o BigQuery como um coletor de um pipeline.

PCollection<TableRow> logsAsTableRows = allLogMessagesDaily
  .apply("logMessageToTableRow", ParDo.of(new LogMessageTableRowFn()));

As tabelas do BigQuery precisam de esquemas definidos. Nesta solução, os esquemas são definidos em LogAnalyticsPipelineOptions.java usando uma anotação de valor padrão. Por exemplo, o esquema da tabela de tempo máximo de resposta é definido da seguinte maneira:

@Default.String("destination:STRING,aggResponseTime:FLOAT")

Uma operação nas PCollections que contêm os valores de tempo de resposta agregados os converte em PCollections de objetos TableRow, aplicando os esquemas apropriados e criando as tabelas, se estiverem faltando.

logsAsTableRows.apply("allLogsToBigQuery", BigQueryIO.writeTableRows()
  .to(options.getAllLogsTableName())
  .withSchema(allLogsTableSchema)
  .withWriteDisposition(BigQueryIO.Write.WriteDisposition.WRITE_APPEND)
  .withCreateDisposition(BigQueryIO.Write.CreateDisposition.CREATE_IF_NEEDED));

Essa solução sempre anexa novos dados aos dados existentes. Essa é uma escolha apropriada porque este pipeline é executado periodicamente para analisar novos dados de registro. No entanto, se fizer mais sentido em um cenário diferente, também é possível truncar os dados da tabela atual ou apenas gravar na tabela se ela estiver vazia.

Como consultar os dados no BigQuery

É possível usar o console do BigQuery para executar consultas nos dados de saída e se conectar a ferramentas de inteligência de negócios de terceiros, como Tableau e QlikView, para fazer mais análises.

  1. Acesse o BigQuery no Console do GCP.

  2. No painel de navegação à esquerda, expanda o projeto processing-logs-at-scale e o conjunto de dados processing_logs_using_dataflow.

  3. Selecione all_logs_table e, no painel de dados, selecione Visualizar para ver uma amostra dos dados na tabela de todos os registros.

  4. No Editor de consultas, digite a seguinte consulta:

    SELECT *
    FROM `processing_logs_using_dataflow.max_response_time_table`
    ORDER BY aggResponseTime DESC
    LIMIT 100;
    
  5. Clique em Executar para realizar a consulta.

O console do BigQuery executa uma consulta nos dados do registro

Como usar um pipeline de streaming

O exemplo inclui suporte para executar o pipeline em modo de lote ou streaming. Bastam apenas algumas etapas para mudar o pipeline de lote para streaming. Primeiro, a configuração do Stackdriver Logging exporta informações da geração de registros para o Cloud Pub/Sub em vez de para o Google Cloud Storage. A próxima etapa é mudar as origens de entrada no pipeline do Cloud Dataflow do Google Cloud Storage para inscrições em tópicos do Cloud Pub/Sub. É necessário ter uma inscrição para cada origem de entrada.

O pipeline Cloud Pub/Sub usa assinaturas

Veja os comandos do SDK em uso no logging.sh.

As PCollections criadas a partir dos dados de entrada do Cloud Pub/Sub usam uma janela global ilimitada. No entanto, as entradas individuais já incluem carimbos de data/hora. Isso significa que não é necessário extrair os dados de carimbo de data/hora do objeto LogEntry do Stackdriver Logging. Basta extrair os carimbos de data/hora do registro para criar os objetos LogMessage personalizados.

Ao usar o pipeline do Cloud Pub/Sub, é possível extrair carimbos de data/hora dos registros

O restante do pipeline permanece como está, incluindo operações posteriores de achatamento, transformação, agregação e saída.

Como monitorar o pipeline

Quando você executa o job do Cloud Dataflow, é possível usar o Console do Google Cloud Platform para monitorar o andamento e visualizar as informações sobre cada estágio do pipeline.

A imagem a seguir mostra a interface do usuário do Console durante a execução de um exemplo de pipeline:

O Console do GCP mostra um job do Cloud Dataflow em execução

Como fazer a limpeza

Para evitar cobranças na sua conta do GCP pelos recursos usados neste tutorial, siga estas orientações:

Após concluir este tutorial, limpe os recursos criados no GCP para que não sejam faturados no futuro. As próximas seções descrevem como excluir ou desativar esses recursos.

Opção 1: excluir o projeto

O jeito mais fácil de evitar o faturamento é excluindo o projeto criado para este tutorial.

Para excluir o projeto:

  1. No Console do GCP, acesse a página "Projetos".
  2. Na lista de projetos, selecione o que você quer eliminar e clique em "Excluir projeto".
  3. Na caixa de diálogo, digite o ID do projeto e clique em "Encerrar".

Opção 2: excluir todos os componentes

Confirme se determinadas variáveis de ambiente ainda estão definidas com os valores usados durante a configuração.

  1. Exclua o conjunto de dados do BigQuery:

    bq rm $DATASET_NAME
    
  2. Desative as exportações do Cloud Logging. Esta etapa exclui as exportações e o intervalo do Cloud Storage especificado:

    cd ../services
    ./logging.sh $PROJECT_ID $BUCKET_NAME batch down
    
  3. Exclua o cluster do Kubernetes Engine usado para executar as amostras de aplicativos da Web:

    /cluster.sh $PROJECT_ID $CLUSTER_NAME down
    

Como estender a solução

O pipeline e o conjunto de operações descrito nesta solução podem ser estendidos de diversas maneiras. As extensões mais óbvias seriam a realização de agregações adicionais nos dados LogMessage. Por exemplo, se a sessão ou as informações anonimizadas do usuário fossem incluídas na saída do registro, seria possível criar agregações em torno da atividade do usuário. Também é possível usar a transformação ApproximateQuantiles (em inglês) para gerar uma distribuição de tempos de resposta.

Próximas etapas

  • Conheça outros recursos do Google Cloud Platform. Veja nossos tutoriais.
  • Aprenda a usar os produtos do Google Cloud Platform para criar soluções completas.
Esta página foi útil? Conte sua opinião sobre:

Enviar comentários sobre…