Geração de registros e monitoramento de aplicativos

Nesta página, mostramos como configurar um cluster de usuário para o Google Distributed Cloud para que os registros e as métricas personalizados dos aplicativos do usuário sejam enviados ao Cloud Logging e ao Cloud Monitoring. As métricas dos aplicativos do usuário são coletadas com o Google Cloud Managed Service para Prometheus.

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 PromQL. 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'
    

Filtrar registros de aplicativos

A filtragem de registros de aplicativos pode reduzir o faturamento de geração de registros do aplicativo e o tráfego de rede do cluster para o Cloud Logging. Começando com Google Distributed Cloud versão 1.15.0, quando enableCloudLoggingForApplications estiver definido como true, será possível filtrar os registros de aplicativos de acordo com os seguintes critérios:

  • Identificadores de pods (podLabelSelectors)
  • Namespaces (namespaces)
  • Expressões regulares para o conteúdo de registros (contentRegexes)

O Google Distributed Cloud envia apenas os resultados do filtro para o Cloud Logging.

Definir filtros de registro do aplicativo

A configuração do Logging é especificada 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 para o arquivo kubeconfig do cluster de usuário.

  2. Adicione uma seção appLogFilter ao spec:

      apiVersion: addons.gke.io/v1alpha1
      kind: Stackdriver
      metadata:
        name: stackdriver
        namespace: kube-system
      spec:
        enableCloudLoggingForApplications: true
        projectID: ...
        clusterName: ...
        clusterLocation: ...
        appLogFilter:
          keepLogRules:
          - namespaces:
            - prod
            ruleName: include-prod-logs
          dropLogRules:
          - podLabelSelectors:
            - disableGCPLogging=yes
            ruleName: drop-logs
    
  3. Salve e feche o arquivo editado.

  4. (Opcional) Se você estiver usando podLabelSelectors, reinicie o DaemonSet stackdriver-log-forwarder para aplicar suas alterações o mais rápido possível:

    kubectl --kubeconfig USER_CLUSTER_KUBECONFIG --namespace kube-system \
        rollout restart daemonset stackdriver-log-forwarder
    

    Normalmente, podLabelSelectors são efetivas após 10 minutos. Reiniciar o DaemonSet stackdriver-log-forwarder faz as alterações entrarem em vigor mais rapidamente.

Exemplo: inclua os registros ERROR ou WARN apenas no namespace prod

O exemplo a seguir ilustra um funcionamento do filtro de registro do aplicativo. Defina um filtro que use um namespace (prod), uma expressão regular (.*(ERROR|WARN).*) e um identificador de pod (disableGCPLogging=yes). Em seguida, para verificar se o filtro funciona, execute um pod no namespace prod para testar essas condições de filtro.

Para definir e testar um filtro de registro do aplicativo:

  1. Especifique um filtro de registro do aplicativo no objeto do Stackdriver:

    No exemplo appLogFilter a seguir, apenas os registros ERROR ou WARN no namespace prod são mantidos. Todos os registros de pods com o identificador disableGCPLogging=yes são descartados:

    apiVersion: addons.gke.io/v1alpha1
    kind: Stackdriver
    metadata:
      name: stackdriver
      namespace: kube-system
    spec:
      ...
      appLogFilter:
        keepLogRules:
        - namespaces:
          - prod
          contentRegexes:
          - ".*(ERROR|WARN).*"
          ruleName: include-prod-logs
        dropLogRules:
        - podLabelSelectors:
          - disableGCPLogging=yes # kubectl label pods pod disableGCPLogging=yes
          ruleName: drop-logs
    ...
    
  2. Implante um pod no namespace prod e execute um script que gera entradas de registro ERROR e INFO:

    kubectl --kubeconfig USER_CLUSTER_KUBECONFIG run pod1 \
        --image gcr.io/cloud-marketplace-containers/google/debian10:latest \
        --namespace prod --restart Never --command -- \
        /bin/sh -c "while true; do echo 'ERROR is 404\\nINFO is not 404' && sleep 1; done"
    

    Os registros filtrados precisam conter apenas as entradas ERROR, não as INFO.

  3. Adicione o identificador disableGCPLogging=yes ao pod:

    kubectl --kubeconfig USER_CLUSTER_KUBECONFIG label pods pod1 \
        --namespace prod disableGCPLogging=yes
    

    O registro filtrado não deve mais conter nenhuma entrada para o pod pod1.

Definição da API de filtro de registro do aplicativo

A definição do filtro de registro do aplicativo é declarada na definição de recursos personalizados do Stackdriver.

Para conferir a definição do recurso personalizado do Stackdriver, execute o seguinte comando:

kubectl --kubeconfig USER_CLUSTER_KUBECONFIG get crd stackdrivers.addons.gke.io \
    --namespace kube-system -o yaml