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

Nesta página, mostramos como configurar um cluster bare metal do GKE para que registros e 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:

  • Para ativar o Google Cloud Managed Service para Prometheus, defina enableGMPForApplications como true no objeto Stackdriver. Com essa configuração, você monitora e envia alertas sobre suas cargas de trabalho globalmente, usando o Prometheus. Para instruções e mais informações, consulte Ativar o 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 instruções e outras informações, consulte Ativar o Cloud Logging para aplicativos de usuários nesta página.

  • Desative o Logging e o Monitoring legados para aplicativos do usuário definindo enableApplication como false no recurso do cluster. Desativar esse recurso impede que as métricas do aplicativo sejam coletadas duas vezes. Use as etapas em Ativar o Logging e o Monitoring para aplicativos de usuários (legado), mas defina enableApplication como false, em vez de true.

Ativar o Managed Service para Prometheus

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:

Gráfico do serviço gerenciado para Prometheus com 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 GKE em Bare Metal, quando enableCloudLoggingForApplications é definido como true, é possível filtrar os registros do aplicativo pelos seguintes critérios:

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

O GKE em Bare Metal 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

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

Recomendamos seriamente que você siga as orientações de configuração no início deste documento.

As etapas a seguir ainda funcionam, mas não são recomendadas. Leia este problema conhecido relacionado antes de seguir as próximas etapas.

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

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.