Geração de registros e monitoramento de aplicativos

Nesta página, mostramos como configurar um cluster de usuário para clusters do Anthos no VMware (GKE On-Prem) para que os registros e as métricas personalizadas dos aplicativos do usuário sejam enviados para o Cloud Logging e o Cloud Monitoring.

Também é possível usar o Google Cloud Managed Service para Prometheus para monitorar suas cargas de trabalho. Esse é o serviço de consulta e armazenamento totalmente gerenciado do Google Cloud para métricas do Prometheus. Para usar esse recurso, ative o serviço gerenciado para o Prometheus e o Cloud Logging seguindo as etapas abaixo.

Como ativar o Managed Service para Prometheus para aplicativos de usuários

A configuração do serviço gerenciado para o Prometheus é mantida em um objeto do Stackdriver chamado stackdriver.

  1. Abra o objeto stackdriver para edição:

    kubectl --kubeconfig=USER_CLUSTER_KUBECONFIG --namespace kube-system edit stackdriver stackdriver
    

    Substitua USER_CLUSTER_KUBECONFIG pelo caminho do arquivo kubeconfig do cluster de usuário.

  2. Em spec, defina enableGMPForApplications como true:

      apiVersion: addons.gke.io/v1alpha1
      kind: Stackdriver
      metadata:
        name: stackdriver
        namespace: kube-system
      spec:
        projectID: ...
        clusterName: ...
        clusterLocation: ...
        proxyConfigSecretName: ...
        enableGMPForApplications: true
        enableVPC: ...
        optimizedMetrics: true
    
  3. Feche o arquivo editado. Isso começará a executar componentes do Prometheus gerenciados pelo Google (GMP) no cluster.

  4. Para verificar os componentes, execute este comando:

    kubectl --kubeconfig=USER_CLUSTER_KUBECONFIG --namespace gmp-system get pods
    

    A saída deste comando é semelhante a:

     NAME                                 READY   STATUS    RESTARTS        AGE
     collector-abcde                      2/2     Running   1 (5d18h ago)   5d18h
     collector-fghij                      2/2     Running   1 (5d18h ago)   5d18h
     collector-klmno                      2/2     Running   1 (5d18h ago)   5d18h
     gmp-operator-68d49656fc-abcde        1/1     Running   0               5d18h
     rule-evaluator-7c686485fc-fghij      2/2     Running   1 (5d18h ago)   5d18h
    

O serviço gerenciado para Prometheus é compatível com a avaliação e os alertas de regras. Para configurar a avaliação de regras, consulte Avaliação de regras.

Como executar um aplicativo de exemplo

Nesta seção, você criará um aplicativo que emite métricas do Prometheus e usa o Prometheus gerenciado pelo Google para coletar as métricas. Para mais informações, consulte Serviço gerenciado do Google Cloud para Prometheus.

Implantar o aplicativo de exemplo

  1. Crie o namespace gmp-test para os recursos que você criar como parte do aplicativo de exemplo:

    kubectl --kubeconfig=USER_CLUSTER_KUBECONFIG create ns gmp-test
    
  2. O serviço gerenciado fornece um manifesto para um aplicativo de exemplo que emite métricas do Prometheus na porta metrics. O aplicativo usa três réplicas.

    Para implantar o aplicativo de exemplo, execute o seguinte comando:

    kubectl --kubeconfig USER_CLUSTER_KUBECONFIG -n gmp-test apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/prometheus-engine/v0.4.1/examples/example-app.yaml
    

Configurar um recurso do PodMonitoring

Para ingerir os dados de métrica emitidos pelo aplicativo de exemplo, use a coleta de destino. O serviço gerenciado usa recursos personalizados (CRs, na sigla em inglês) do PodMonitoring para configurar a extração de destino e a ingestão de métricas. É possível converter os recursos de operadores de prometheus atuais em respostas automáticas do PodMonitoring.

Uma coleta de resposta automática do PodMonitoring só segmenta no namespace em que a resposta automática está implantada. Para coletar objetivos em vários namespaces, implante a mesma resposta automática do PodMonitoring em cada namespace. Verifique se o recurso PodMonitoring está instalado no namespace pretendido executando o seguinte comando:

 kubectl --kubeconfig USER_CLUSTER_KUBECONFIG get podmonitoring -A

Para a documentação de referência sobre todas as respostas automáticas gerenciadas pelo serviço do Prometheus, consulte a referência do prometheus-engine/doc/api.

O manifesto a seguir define um recurso do PodMonitoring, prom-example, no namespace gmp-test. O recurso encontra todos os pods no namespace que têm o rótulo app com o valor prom-example. Os pods correspondentes são copiados em uma porta chamada metrics, a cada 30 segundos, no caminho HTTP /metrics.

apiVersion: monitoring.googleapis.com/v1
kind: PodMonitoring
metadata:
  name: prom-example
spec:
  selector:
    matchLabels:
      app: prom-example
  endpoints:
  - port: metrics
    interval: 30s

Para aplicar esse recurso, execute o seguinte comando:

kubectl --kubeconfig USER_CLUSTER_KUBECONFIG -n gmp-test apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/prometheus-engine/v0.4.1/examples/pod-monitoring.yaml

O Managed Service para Prometheus agora está copiando os pods correspondentes.

Consultar dados de métricas

A maneira mais simples de verificar se os dados do Prometheus estão sendo exportados é usar consultas em PromQL no Metrics Explorer do console do Google Cloud.

Para executar uma consulta em PromQL, realize estas ações:

  1. No console do Google Cloud, acesse a página Monitoramento ou clique no botão a seguir:

    Acessar Monitoring

  2. No painel de navegação, selecione Metrics Explorer.

  3. Use a linguagem de consulta do Prometheus (PromQL) para especificar os dados que serão exibidos no gráfico:

    1. Na barra de ferramentas do painel Selecionar uma métrica, clique em Editor de código.

    2. Selecione PromQL no botão de alternância Linguagem. O botão de alternar linguagem fica na parte inferior do painel Editor de código.

    3. Insira sua consulta no editor de consultas. Por exemplo, para gerar um gráfico sobre o número médio de segundos que as CPUs gastaram em cada modo na última hora, use a seguinte consulta:

      avg(rate(kubernetes_io:anthos_container_cpu_usage_seconds_total
      {monitored_resource="k8s_node"}[1h]))
      

    Para mais informações sobre como usar PromQL, consulte PromQL no Cloud Monitoring.

A captura de tela a seguir mostra um gráfico que exibe a métrica anthos_container_cpu_usage_seconds_total:

Gráfico do serviço gerenciado para Prometheus com a métrica "anthos_container_cpu_usage_seconds_total" do Prometheus.

Se você coleta muitos dados, filtre as métricas exportadas para manter os custos baixos.

Ativar o Cloud Logging para aplicativos do usuário

A configuração do Logging é mantida em um objeto do Stackdriver chamado Stackdriver.

  1. Abra o objeto stackdriver para edição:

    kubectl --kubeconfig=USER_CLUSTER_KUBECONFIG --namespace kube-system edit stackdriver stackdriver
    

    Substitua USER_CLUSTER_KUBECONFIG pelo caminho do arquivo kubeconfig do cluster de usuário.

  2. Em spec, defina enableCloudLoggingForApplications como true:

      apiVersion: addons.gke.io/v1alpha1
      kind: Stackdriver
      metadata:
        name: stackdriver
        namespace: kube-system
      spec:
        projectID: ...
        clusterName: ...
        clusterLocation: ...
        proxyConfigSecretName: ...
        enableCloudLoggingForApplications: true
        enableVPC: ...
        optimizedMetrics: true
    
  3. Feche o arquivo editado.

Como executar um aplicativo de exemplo

Nesta seção, você criará um aplicativo que grava registros personalizados.

  1. Salve o seguinte manifesto de implantação em um arquivo chamado my-app.yaml:

    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: "monitoring-example"
      namespace: "default"
      labels:
        app: "monitoring-example"
    spec:
      replicas: 1
      selector:
        matchLabels:
          app: "monitoring-example"
      template:
        metadata:
          labels:
            app: "monitoring-example"
        spec:
          containers:
          - image: gcr.io/google-samples/prometheus-dummy-exporter:latest
            name: prometheus-example-exporter
            imagePullPolicy: Always
            command:
            - /bin/sh
            - -c
            - ./prometheus-dummy-exporter --metric-name=example_monitoring_up --metric-value=1 --port=9090
            resources:
              requests:
                cpu: 100m
    
  2. Crie a implantação:

    kubectl --kubeconfig USER_CLUSTER_KUBECONFIG apply -f my-app.yaml
    

Como exibir registros do aplicativo

Console

  1. Acesse o Explorador de registros no console do Google Cloud:

    Acessar o Explorador de registros

  2. Clique em Recurso. Em ALL_RESOURCE_TYPES, selecione Kubernetes Container.

  3. Em CLUSTER_NAME, selecione o nome do seu cluster de usuário.

  4. Em NAMESPACE_NAME, selecione default.

  5. Clique em Adicionar e em Executar consulta.

  6. Em Resultados da consulta, é possível ver as entradas de registro da implantação monitoring-example. Exemplo:

    {
      "textPayload": "2020/11/14 01:24:24 Starting to listen on :9090\n",
      "insertId": "1oa4vhg3qfxidt",
      "resource": {
        "type": "k8s_container",
        "labels": {
          "pod_name": "monitoring-example-7685d96496-xqfsf",
          "cluster_name": ...,
          "namespace_name": "default",
          "project_id": ...,
          "location": "us-west1",
          "container_name": "prometheus-example-exporter"
        }
      },
      "timestamp": "2020-11-14T01:24:24.358600252Z",
      "labels": {
        "k8s-pod/pod-template-hash": "7685d96496",
        "k8s-pod/app": "monitoring-example"
      },
      "logName": "projects/.../logs/stdout",
      "receiveTimestamp": "2020-11-14T01:24:39.562864735Z"
    }
    

gcloud

  1. Execute este comando:

    gcloud logging read 'resource.labels.project_id="PROJECT_ID" AND \
        resource.type="k8s_container" AND resource.labels.namespace_name="default"'
    

    Substitua PROJECT_ID pelo ID do projeto de geração de registros.

  2. Na saída, é possível ver entradas de registro da implantação monitoring-example. Exemplo:

    insertId: 1oa4vhg3qfxidt
    labels:
      k8s-pod/app: monitoring-example
      k8s- pod/pod-template-hash: 7685d96496
    logName: projects/.../logs/stdout
    receiveTimestamp: '2020-11-14T01:24:39.562864735Z'
    resource:
      labels:
        cluster_name: ...
        container_name: prometheus-example-exporter
        location: us-west1
        namespace_name: default
        pod_name: monitoring-example-7685d96496-xqfsf
        project_id: ...
      type: k8s_container
    textPayload: |
      2020/11/14 01:24:24 Starting to listen on :9090
    timestamp: '2020-11-14T01:24:24.358600252Z'
    

Como ativar o Logging e o Monitoring para aplicativos do usuário (legado)

É altamente recomendável usar os campos enableGMPForApplications e enableCloudLoggingForApplications acima da resposta automática do Stackdriver para ativar o monitoramento e a geração de registros de aplicativos do usuário.

As etapas a seguir ainda funcionam, mas não são recomendadas. Leia o problema conhecido antes de usar as etapas a seguir.

Nesta seção, descrevemos como ativar o Logging e o Monitoring se você não estiver usando o Managed Service para Prometheus. A configuração do Logging e do Monitoring é mantida em um objeto do Stackdriver chamado stackdriver.

  1. Abra o objeto stackdriver para edição:

    kubectl --kubeconfig=USER_CLUSTER_KUBECONFIG --namespace kube-system edit stackdriver stackdriver
    

    Substitua USER_CLUSTER_KUBECONFIG pelo caminho do arquivo kubeconfig do cluster de usuário.

  2. Em spec, defina enableStackdriverForApplications como true:

      apiVersion: addons.gke.io/v1alpha1
      kind: Stackdriver
      metadata:
        name: stackdriver
        namespace: kube-system
      spec:
        projectID: ...
        clusterName: ...
        clusterLocation: ...
        proxyConfigSecretName: ...
        enableStackdriverForApplications: true
        enableVPC: ...
        optimizedMetrics: true
    
  3. Feche o arquivo editado.

Como anotar cargas de trabalho

Para ativar a coleta de métricas personalizadas de um aplicativo, adicione a anotação prometheus.io/scrape: "true" ao manifesto de serviço ou pod do aplicativo ou inclua a mesma anotação na seção spec.template em "Implantação" ou "Manifesto do DaemonSet" para ser transmitida aos pods deles.

Para evitar a coleta de lixo de métricas, recomendamos definir o intervalo de extração de métricas para um minuto.

Como executar um aplicativo de exemplo

Nesta seção, você criará um aplicativo que grava registros personalizados e expõe uma métrica personalizada.

  1. Salve os seguintes manifestos de Serviço e Implantação em um arquivo chamado my-app.yaml. Observe que o Serviço tem a anotação prometheus.io/scrape: "true":

    kind: Service
    apiVersion: v1
    metadata:
      name: "monitoring-example"
      namespace: "default"
      annotations:
        prometheus.io/scrape: "true"
    spec:
      selector:
        app: "monitoring-example"
      ports:
        - name: http
          port: 9090
    ---
    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: "monitoring-example"
      namespace: "default"
      labels:
        app: "monitoring-example"
    spec:
      replicas: 1
      selector:
        matchLabels:
          app: "monitoring-example"
      template:
        metadata:
          labels:
            app: "monitoring-example"
        spec:
          containers:
          - image: gcr.io/google-samples/prometheus-dummy-exporter:latest
            name: prometheus-example-exporter
            imagePullPolicy: Always
            command:
            - /bin/sh
            - -c
            - ./prometheus-dummy-exporter --metric-name=example_monitoring_up --metric-value=1 --port=9090
            resources:
              requests:
                cpu: 100m
    
  2. Crie a implantação e o serviço:

    kubectl --kubeconfig USER_CLUSTER_KUBECONFIG apply -f my-app.yaml
    

Como exibir registros do aplicativo

Console

  1. Acesse o Explorador de registros no console do Google Cloud:

    Acessar o Explorador de registros

  2. Clique em Recurso. Em ALL_RESOURCE_TYPES, selecione Kubernetes Container.

  3. Em CLUSTER_NAME, selecione o nome do seu cluster de usuário.

  4. Em NAMESPACE_NAME, selecione default.

  5. Clique em Adicionar e em Executar consulta.

  6. Em Resultados da consulta, é possível ver as entradas de registro da implantação monitoring-example. Exemplo:

    {
      "textPayload": "2020/11/14 01:24:24 Starting to listen on :9090\n",
      "insertId": "1oa4vhg3qfxidt",
      "resource": {
        "type": "k8s_container",
        "labels": {
          "pod_name": "monitoring-example-7685d96496-xqfsf",
          "cluster_name": ...,
          "namespace_name": "default",
          "project_id": ...,
          "location": "us-west1",
          "container_name": "prometheus-example-exporter"
        }
      },
      "timestamp": "2020-11-14T01:24:24.358600252Z",
      "labels": {
        "k8s-pod/pod-template-hash": "7685d96496",
        "k8s-pod/app": "monitoring-example"
      },
      "logName": "projects/.../logs/stdout",
      "receiveTimestamp": "2020-11-14T01:24:39.562864735Z"
    }
    

gcloud

  1. Execute este comando:

    gcloud logging read 'resource.labels.project_id="PROJECT_ID" AND \
        resource.type="k8s_container" AND resource.labels.namespace_name="default"'
    

    Substitua PROJECT_ID pelo ID do projeto de geração de registros.

  2. Na saída, é possível ver entradas de registro da implantação monitoring-example. Exemplo:

    insertId: 1oa4vhg3qfxidt
    labels:
      k8s-pod/app: monitoring-example
      k8s- pod/pod-template-hash: 7685d96496
    logName: projects/.../logs/stdout
    receiveTimestamp: '2020-11-14T01:24:39.562864735Z'
    resource:
      labels:
        cluster_name: ...
        container_name: prometheus-example-exporter
        location: us-west1
        namespace_name: default
        pod_name: monitoring-example-7685d96496-xqfsf
        project_id: ...
      type: k8s_container
    textPayload: |
      2020/11/14 01:24:24 Starting to listen on :9090
    timestamp: '2020-11-14T01:24:24.358600252Z'
    

Como visualizar métricas de aplicativo no console do Google Cloud

O aplicativo de exemplo expõe uma métrica personalizada chamada example_monitoring_up. É possível ver os valores dessa métrica no console do Cloud.

  1. Acesse o Metrics Explorer no Console do Google Cloud:

    Acessar o Metrics Explorer

  2. Em Tipo de recurso, selecione Kubernetes Pod ou Kubernetes Container.

  3. Em Métrica, selecione external.googleapis.com/prometheus/example_monitoring_up.

  4. No gráfico, você pode ver que example_monitoring_up tem um valor repetido de 1.