Os clusters do Anthos no VMware agora são o Google Distributed Cloud (somente software) para VMware. Para mais informações, consulte a visão geral do produto.

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.

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.

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

Feche o arquivo editado. Isso começará a executar componentes do Prometheus gerenciados pelo Google (GMP) no cluster.

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

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

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

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.

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

Feche o arquivo editado.

Como executar um aplicativo de exemplo

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

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

Crie a implantação:

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

Como exibir registros do aplicativo

Console

Acesse o Explorador de registros no console do Google Cloud:

Acessar o Explorador de registros
Clique em Recurso. Em ALL_RESOURCE_TYPES, selecione Kubernetes Container.
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. Por 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

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.

Na saída, é possível ver entradas de registro da implantação monitoring-example. Por 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.

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

Geração de registros e monitoramento de aplicativos

Como ativar o Managed Service para Prometheus para aplicativos de usuários

Como executar um aplicativo de exemplo

Implantar o aplicativo de exemplo

Configurar um recurso do PodMonitoring

Consultar dados de métricas

Ativar o Cloud Logging para aplicativos do usuário

Como executar um aplicativo de exemplo

Como exibir registros do aplicativo

Console

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`