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

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

Para a melhor experiência de geração de registros e monitoramento de aplicativos do usuário, recomendamos que você use a seguinte configuração:

  • Ative o Google Cloud Managed Service para Prometheus definindo enableGMPForApplications como true no objeto Stackdriver. Essa configuração permite usar o Prometheus para monitoramento e alertas globais das cargas de trabalho. Para instruções e informações adicionais, consulte Ativar o Google Cloud Managed Service para Prometheus nesta página.

  • Ative o Cloud Logging para aplicativos do usuário definindo enableCloudLoggingForApplications como true no objeto Stackdriver. Essa configuração fornece geração de registros das suas cargas de trabalho. Para mais informações e instruções, consulte Ativar o Cloud Logging para aplicativos do usuário nesta página.

Ativar o Google Cloud Managed Service para Prometheus

A configuração do Google Cloud 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 Google Cloud 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 Google Cloud Managed Service para Prometheus oferece suporte à avaliação e ao alerta 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ê configura um recurso personalizado PodMonitoring para capturar dados de métricas emitidos pelo aplicativo de exemplo e enviá-los ao Google Cloud 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 ver a documentação de referência sobre todos os recursos personalizados do Google Cloud 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 Google Cloud Managed Service para Prometheus agora está coletando 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 Google Cloud Managed Service para Prometheus para a métrica "anthos_container_cpu_usage_seconds_total" do Prometheus.

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

Ativar o Cloud Logging para aplicativos do usuário

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.

    Acesse 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 da 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'

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. A partir da versão 1.15.0 do Google Distributed Cloud, quando enableCloudLoggingForApplications é definido como true, é possível filtrar os registros de aplicativos pelos 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