BLOG

Métricas de alta resolução definidas pelo usuário no Cloud Monitoring

Métricas de resolução mais alta são críticas para monitorar ambientes que mudam dinamicamente e métricas de aplicativos que mudam rapidamente. Exemplos em que as métricas de alta resolução são críticas incluem e-commerce de alto volume, streaming ao vivo, cargas de trabalho em rajadas de escalonamento automático em clusters Kubernetes e muito mais. Métricas personalizadas de resolução mais alta , Prometheus e métricas de agente agora estão geralmente disponíveis e podem ser gravadas em uma granularidade de 10 segundos . Anteriormente, esses tipos de métricas só podiam ser gravados uma vez a cada 60 segundos.

Como escrever métricas de agente de monitoramento em resolução de 10 segundos

agente Cloud Monitoring é um daemon baseado em collectd que coleta métricas de sistema e aplicativo de instâncias de máquina virtual e as envia ao Cloud Monitoring. O agente do Monitoring coleta métricas de disco, CPU, rede e processo. Por padrão, as métricas do agente são gravadas com granularidade de 60 segundos. Você pode modificar a configuração do agente collectd.conf para enviar métricas em granularidade de 10 segundos, alterando o valor do intervalo para ’10’ no arquivo collectd.conf do agente de monitoramento.

Depois de fazer essa alteração, você precisará reiniciar seu agente (isso pode variar de acordo com seu sistema operacional e distribuição):

sudo service stackdriver-agent restart

Métricas de agente de resolução mais alta requerem o agente de monitoramento versão 6.0.1 ou superior. Você pode encontrar a documentação para determinar sua versão do agente aqui .

Agora que o agente do Monitoring está emitindo métricas com granularidade de 10 segundos, você pode visualizá-las no Metrics Explorer procurando métricas com o prefixo “agent.googleapis.com/agent/”.

1 Metrics Explorer.jpg

Como escrever métricas personalizadas com resolução de 10 segundos

As métricas personalizadas permitem definir e coletar dados de métricas que as métricas integradas do Google Cloud não podem fornecer. Eles podem ser específicos para seu aplicativo, infraestrutura ou negócios. Por exemplo: “Latência do serviço de carrinho de compras” ou “Taxa de retorno do cliente” em um aplicativo de e-commerce.

As métricas personalizadas podem ser gravadas de várias maneiras: por meio da API de monitoramento , bibliotecas de cliente do Cloud Monitoring , bibliotecas OpenCensus / OpenTelemetry ou o agente do Cloud Monitoring .

Recomendamos usar as bibliotecas do OpenCensus para escrever métricas personalizadas por vários motivos:

  1. É de código aberto e oferece suporte a uma ampla variedade de linguagens e estruturas.
  2. O OpenCensus fornece suporte independente de fornecedor para a coleta de dados de métrica e rastreamento.
  3. O OpenCensus fornece coleta otimizada de pontos e lote de chamadas de API de monitoramento. Ele também lida com chamadas de API de tempo para resolução de 10 segundos e outros intervalos de tempo, para que a API de monitoramento não rejeite pontos por serem gravados com muita frequência. Ele também lida com novas tentativas, retirada exponencial e muito mais, ajudando a garantir que seus pontos métricos cheguem ao sistema de monitoramento.
  4. O OpenCensus permite que você exporte os dados coletados para uma variedade de aplicativos de back-end e serviços de monitoramento, incluindo o Cloud Monitoring.

Instrumentar seu código para usar o OpenCensus para métricas envolve três etapas gerais:

  1. Importe as estatísticas do OpenCensus e os pacotes de exportação do OpenCensus Stackdriver.
  2. Inicialize o exportador do Cloud Monitoring.
  3. Use a API OpenCensus para instrumentar seu código.

A seguir, um programa Go mínimo que ilustra as etapas de instrumentação listadas acima, gravando uma métrica de contador no Cloud Monitoring.

Se você não tiver um ambiente de desenvolvimento Go funcionando, siga estas etapas no Google Cloud Console e no Cloud Shell para compilar e executar o programa de demonstração:

  1. Acesse Cloud Monitoring. Se estiver usando o Cloud Monitoring pela primeira vez, você será solicitado a criar um espaço de trabalho (o padrão será o mesmo nome do projeto do GCP em que você está).
  2. Abra o Cloud Shell no Cloud Console.
  3. Certifique-se de habilitar a API de monitoramento executando gcloud services enable monitoring
  4. Se você ainda não tem um ambiente de trabalho em movimento, siga estas etapas:
    1. mkdir ~ / go
    2. exportar GOPATH = ~ / go
    3. mkdir -p ~ / go / src / testCustomMetrics
    4. cd ~ / go / src / testCustomMetrics
    5. Execute “go mod init”
    6. toque em testCustomMetrics.go
    7. Abra testCustomMetrics.go no editor de texto de sua escolha e copie o código abaixo
    8. Execute “go mod tidy”. Nota: “go mod tidy” encontra todos os pacotes importados transitivamente por pacotes em seu módulo
    9. Execute “go build testCustomMetrics.go”
    10. Execute “./testCustomMetrics”

O programa de exemplo é o seguinte:

// Example of exporting a custom metric from OpenCensus to Cloud Monitoring.
package main
 
import (
        "context"
        "fmt"
        "log"
        "time"
 
        "contrib.go.opencensus.io/exporter/stackdriver"
        "go.opencensus.io/stats"
        "go.opencensus.io/stats/view"
        "golang.org/x/exp/rand"
)
 
var (
        // The restaurant rating in number of stars.
        starCount = stats.Int64("star_count", "The star rating for the restaurant (0-5)", "stars")
)
 
func main() {
        ctx := context.Background()
 
        // Register the view. It is imperative that this step exists,
        // otherwise recorded metrics will be dropped and never exported.
        v := &view.View{
                Name:        "star_count",
                Measure:     starCount,
                Description: "Restaurant star rating 0-5",
                Aggregation: view.Count(),
        }
        if err := view.Register(v); err != nil {
                log.Fatalf("Failed to register the view: %v", err)
        }
 
        // Enable OpenCensus exporters to export metrics
        // to Google Cloud Monitoring.
        // Exporters use Application Default Credentials to authenticate.
        // See https://developers.google.com/identity/protocols/application-default-credentials
        // for more details.
        // The Stackdriver Exporter sets a default MonitoredResource of type “global”
        exporter, err := stackdriver.NewExporter(stackdriver.Options{
            // ProjectID <change this value>
            ProjectID: "demo-project-id",
            // MetricPrefix helps uniquely identify your metrics. <change this value>
            MetricPrefix: "demo-prefix", 
            // ReportingInterval sets the frequency of reporting metrics
            // to the Cloud Monitoring backend.
            ReportingInterval: 10 * time.Second,
        })
 
        if err != nil {
                log.Fatal(err)
        }
        // Flush must be called before main() exits to ensure metrics are recorded.
        defer exporter.Flush()
 
        if err := exporter.StartMetricsExporter(); err != nil {
                log.Fatalf("Error starting metric exporter: %v", err)
        }
        defer exporter.StopMetricsExporter()
 
        // Record 100 fake count values between 0-5.
      //  rand.Intn(n) returns a random number between 0 and n - 1
        for i := 0; i < 180; i++ {
                random_star_count := int64(rand.Intn(6))
                fmt.Println("Star count: ", random_star_count)
                stats.Record(ctx, starCount.M(random_star_count))
                
                // Wait 1 second until we write the next count
                time.Sleep(1 * time.Second)
        }
 
        fmt.Println("Done recording metrics")
}

Este programa grava uma contagem de estrelas aleatória a cada segundo, por três minutos. Como você pode notar acima, as métricas personalizadas só podem ser gravadas com granularidade de 10 segundos. Estamos escrevendo pontos de métrica brutos com mais frequência, mas definimos o exportador OpenCensus ‘ReportingInterval’ para ser a cada 10 segundos, para que o Exportador lide com a chamada do ‘ponto de extremidade CreateTimeSeries’ da API de monitoramento corretamente a cada 10 segundos. Ao consultar seus pontos, selecione uma opção de ‘alinhador’ e ‘agregação’ no Metrics Explorer. Dessa forma, mesmo se você tiver vários pontos em um intervalo de 10 segundos, você retornará um único ponto com base em suas opções de alinhamento e agregação.

Depois de executar o programa, você pode acessar o Metrics Explorer no Cloud Monitoring para ver a métrica “OpenCensus / star_count”, escrita em relação ao recurso “global”.

2 Metrics Explorer no Cloud Monitoring.jpg

Como escrever métricas do Prometheus com resolução de 10 segundos

A ferramenta de monitoramento Prometheus costuma ser usada com o Kubernetes. Se você configurar o Cloud Operations for GKE para incluir o suporte do Prometheus, as métricas que são geradas por serviços usando o formato de exposição do Prometheus podem ser exportadas do cluster e tornadas visíveis como métricas externas no Cloud Monitoring.

A instalação e configuração do Prometheus, incluindo a configuração da exportação para o Cloud Monitoring, envolve algumas etapas, portanto, recomendamos que você siga estas instruções . O OpenCensus também oferece um codelab guiado para configurar a instrumentação do Prometheus.

Para ativar a resolução de 10 segundos para métricas do Prometheus que são exportadas para o Cloud Monitoring, defina o parâmetro “scrape_interval” em “prometheus.yml” para:

scrape_interval:     10s

Depois que o Prometheus estiver configurado corretamente para exportar métricas para o Cloud Monitoring, você pode ir para Metrics Explorer no Cloud Monitoring e pesquisar métricas com o prefixo external.googleapis.com/prometheus/.

3 Metrics Explorer em Cloud Monitoring.jpg

Preços para métricas do Cloud Monitoring

As métricas cobráveis ​​do Cloud Monitoring são cobradas por megabyte de ingestão, com os primeiros 150 MB gratuitos, e níveis de preços reduzidos para clientes que enviam grandes volumes de métricas. Não há custo adicional para o envio de métricas de resolução mais alta, além do custo adicional incorrido com o envio de dados métricos com mais frequência. A frequência com que você escreve métricas personalizadas (com 10 segundos como o limite inferior) é sua. As métricas da plataforma (sistema) do GCP permanecem livres e a granularidade em que são gravadas é determinada por cada serviço individual do GCP. 

Em direção a uma melhor observabilidade

Esperamos que você considere útil a capacidade de escrever métricas personalizadas de alta resolução, do Prometheus e do Agente e que ajude a criar aplicativos e serviços mais observáveis. 

Métricas com base em registros de resolução mais alta com granularidade de 10 segundos também estão em nosso roteiro, portanto, fique atento para mais informações em uma próxima postagem do blog.

Fonte: Blog Google.

Compartilhe nas Redes Sociais

Outros Artigos

Googleselos_pequeno

Siga-nos

Onde Estamos

Ceará | Rio Grande do Norte | Pernambuco | Sergipe | Bahia | Minas Gerais | São Paulo

Endereço Matriz: Rua Zildenia, 1166, Sala 13, Coite, Eusébio, Ceará, CEP: 61760-000

Telefone: (85) 3119.5969

GOLDEN TECHNOLOGIA © 2020 - TODOS OS DIREITOS RESERVADOS.