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.