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

Nesta página, mostramos como configurar um cluster para o GKE em Bare Metal 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.

Ative o 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 mais informações e instruçõ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 mais informações e instruções, consulte Ativar o Cloud Logging para aplicativos do usuário nesta página.

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:

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.

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

Salve e feche o arquivo editado.

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

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:

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

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:

No console do Google Cloud, acesse a página Monitoramento ou clique no botão a seguir:

Acessar Monitoring
No painel de navegação, selecione Metrics Explorer.
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.

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.

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

Salve e feche o arquivo editado.

Executar um aplicativo de exemplo

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

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

Criar a implantação

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

Veja os registros do aplicativo.

Console

Acesse o Explorador de registros no console do Google Cloud.

Acesse o Explorador de registros
Clique em Recurso. No menu TODOS OS TIPOS DE RECURSO, selecione Contêiner do Kubernetes.
Em CLUSTER_NAME, selecione o nome do seu cluster de usuário.
Em NAMESPACE_NAME, selecione default.
Clique em Adicionar e em Executar consulta.

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

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.

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.

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.

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

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

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

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.

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 a geração de registros e o monitoramento de aplicativos

Ativar o Managed Service para Prometheus

Executar um aplicativo de exemplo

Configurar um recurso do PodMonitoring

Consultar dados de métricas

Ativar o Cloud Logging para aplicativos do usuário

Executar um aplicativo de exemplo

Veja os registros do aplicativo.

Console

CLI da gcloud

Filtrar registros de aplicativos

Definir filtros de registro do aplicativo

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

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

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