Ativar a geração de registros e o monitoramento de aplicativos

Version 1.12 

• Versão 1.28 (mais recente)
• Versão 1.16
• Versão 1.15
• Versões anteriores (sem suporte)

Nesta página, mostramos como configurar um cluster para clusters do Anthos em bare metal para que os registros e métricas personalizados de aplicativos do usuário sejam enviados para o Cloud Logging, o Cloud Monitoring e o serviço gerenciado para o Prometheus.

Ativar o Managed Service para Prometheus

Visualização

Este produto ou recurso está sujeito aos "Termos das ofertas pré-GA" na seção "Termos de Serviço gerais" dos Termos específicos do serviço. Os produtos e recursos pré-GA estão disponíveis "no estado em que se encontram" e podem ter suporte limitado. Para mais informações, consulte as descrições da fase de lançamento.

A configuração do Managed Service para Prometheus é especificada em um objeto Stackdriver chamado stackdriver. Para mais informações, incluindo práticas recomendadas e solução de problemas, consulte a documentação do Managed Service para Prometheus.

Para configurar o objeto stackdriver para ativar o Google Cloud Managed Service para Prometheus:

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

   kubectl --kubeconfig=CLUSTER_KUBECONFIG \
       --namespace kube-system edit stackdriver stackdriver
   

   Substitua CLUSTER_KUBECONFIG pelo caminho do seu arquivo kubeconfig do cluster.

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. Salve e feche o arquivo editado.

   Os componentes do Prometheus gerenciados pelo Google são iniciados automaticamente no cluster no namespace gmp-system.

4. Verifique os componentes do Prometheus gerenciados pelo Google:

   kubectl --kubeconfig=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.

Executar um aplicativo de exemplo

O serviço gerenciado fornece um manifesto para um aplicativo de exemplo, prom-example, que emite métricas do Prometheus na porta metrics. O aplicativo usa três réplicas.

Para implantar o aplicativo:

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

   kubectl --kubeconfig=CLUSTER_KUBECONFIG create ns gmp-test
   

2. Aplique o manifesto do aplicativo com o seguinte comando:

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

Configurar um recurso do PodMonitoring

Nesta seção, você configurará um recurso personalizado PodMonitoring para capturar dados de métricas emitidos pelo aplicativo de exemplo e enviá-los para o Managed Service para Prometheus. O recurso personalizado PodMonitoring usa a cópia de destino. Nesse caso, os agentes do coletor coletam o endpoint /metrics para o qual o aplicativo de amostra emite dados.

Um recurso personalizado PodMonitoring raspa os destinos no namespace em que ele é implantado. Para extrair objetivos em vários namespaces, implante o mesmo recurso personalizado PodMonitoring em cada namespace. É possível verificar se o recurso PodMonitoring está instalado no namespace pretendido executando o seguinte comando:

kubectl --kubeconfig CLUSTER_KUBECONFIG get podmonitoring -A

Para a documentação de referência sobre todos os recursos personalizados do Managed Service para Prometheus, consulte a referência do prometheus-engine/doc/api.

O manifesto a seguir define um recurso 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 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:

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

Ativar o Cloud Logging para aplicativos do usuário

Visualização

Este produto ou recurso está sujeito aos "Termos das ofertas pré-GA" na seção "Termos de Serviço gerais" dos Termos específicos do serviço. Os produtos e recursos pré-GA estão disponíveis "no estado em que se encontram" e podem ter suporte limitado. Para mais informações, consulte as descrições da fase de lançamento.

A configuração do Cloud Logging e do Cloud Monitoring é mantida em um objeto do Stackdriver chamado stackdriver.

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

   kubectl --kubeconfig=CLUSTER_KUBECONFIG \
       --namespace kube-system edit stackdriver stackdriver
   

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

2. Na seção 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. Salve e feche o arquivo editado.

Executar um aplicativo de exemplo

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

1. Salve os seguintes manifestos 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. Criar a implantação

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

Veja os registros do aplicativo.

Console

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

   Acessar o Explorador de registros

2. Clique em Recurso. No menu TODOS OS TIPOS DE RECURSO, selecione Contêiner do Kubernetes.

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"
   }
   

CLI 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 seu projeto.

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'
   

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

Para ativar o Logging e o Monitoring nos aplicativos, use o campo spec.clusterOperations.enableApplication no arquivo de configuração do cluster.

1. Atualize o arquivo de configuração do cluster para definir enableApplication como true:

   apiVersion: v1
   kind: Namespace
   metadata:
     name: cluster-user-basic
   ---
   apiVersion: baremetal.cluster.gke.io/v1
   kind: Cluster
   metadata:
     name: user-basic
     namespace: cluster-user-basic
   spec:
     type: user
     ...
     clusterOperations:
       projectID: project-fleet
       location: us-central1
       enableApplication: true
       ...
   

2. Use bmctl update para aplicar suas alterações:

   bmctl update cluster -c CLUSTER_NAME --admin-kubeconfig=ADMIN_KUBECONFIG
   

   Substitua:

   • CLUSTER_NAME: o nome do cluster a se fazer upgrade.
   • ADMIN_KUBECONFIG: o caminho até o arquivo kubeconfig do cluster de administrador.

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.

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 CLUSTER_KUBECONFIG apply -f my-app.yaml
   

Veja os 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 TODOS OS TIPOS DE RECURSO, selecione Contêiner do Kubernetes.

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"
   }
   

CLI 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 seu projeto.

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'
   

Ver métricas do 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.