Para informações sobre a versão, consulte as notas da versão do Distributed Cloud Connected.

Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

Registros e métricas

Nesta página, explicamos como o Google Distributed Cloud conectado registra vários tipos de informações sobre a operação e como visualizar essas informações. A coleta de alguns tipos de registros e métricas gera cobranças adicionais. Para mais informações, consulte Faturamento de registros e métricas.

Configurar a geração de registros e o monitoramento

Antes de começar a coletar registros e métricas, faça o seguinte:

Ative as APIs de geração de registros usando os comandos a seguir:

gcloud services enable opsconfigmonitoring.googleapis.com --project PROJECT_ID
gcloud services enable logging.googleapis.com --project PROJECT_ID
gcloud services enable monitoring.googleapis.com --project PROJECT_ID

Substitua PROJECT_ID pelo ID do projeto de destino Google Cloud .

Conceda os papéis necessários para gravar registros e métricas:

gcloud projects add-iam-policy-binding PROJECT_ID \
    --role roles/opsconfigmonitoring.resourceMetadata.writer \
    --member "serviceAccount:PROJECT_ID.svc.id.goog[kube-system/metadata-agent]"

gcloud projects add-iam-policy-binding PROJECT_ID \
    --role roles/logging.logWriter \
     --member "serviceAccount:PROJECT_ID.svc.id.goog[kube-system/stackdriver-log-forwarder]"

gcloud projects add-iam-policy-binding PROJECT_ID \
    --role roles/monitoring.metricWriter \
    --member "serviceAccount:PROJECT_ID.svc.id.goog[kube-system/gke-metrics-agent]"

Substitua PROJECT_ID pelo ID do projeto de destino Google Cloud .

Registros

Esta seção lista os tipos de recursos do Cloud Logging com suporte do Distributed Cloud. Para conferir os registros do Distributed Cloud, use o Análise de registros no Google Cloud console do. A geração de registros do Distributed Cloud está sempre ativada.

Os tipos de recursos registrados do Distributed Cloud conectado são os seguintes recursos padrão do Kubernetes:

k8s_container
k8s_node

Também é possível capturar e recuperar registros do Distributed Cloud conectado usando a API Cloud Logging. Para informações sobre como configurar esse mecanismo de geração de registros, consulte a documentação das bibliotecas de cliente do Cloud Logging.

Métricas

Esta seção lista as métricas do Cloud Monitoring com suporte do Distributed Cloud. Para conferir as métricas do Distributed Cloud, use o Metrics Explorer no Google Cloud console.

Métricas de cluster do Distributed Cloud conectado

Para clusters do Distributed Cloud conectado, o Distributed Cloud conectado fornece os seguintes tipos de métricas geradas por nós do Distributed Cloud conectado:

Métricas de recursos fornecem informações sobre o desempenho do nó e do pod do Distributed Cloud conectado, como carga da CPU e uso de memória.
Métricas de aplicativos do sistema fornecem informações sobre cargas de trabalho do sistema do Distributed Cloud conectado, como coredns.

Para uma lista dessas métricas, consulte Métricas do Google Distributed Cloud e do Google Distributed Cloud.

O Distributed Cloud conectado não fornece métricas geradas pelos planos de controle do Kubernetes associados a clusters do Distributed Cloud conectado.

Métricas de hardware do Distributed Cloud conectado

O Distributed Cloud conectado fornece métricas para hardware do Distributed Cloud conectado usando os seguintes tipos de recursos:

edgecontainer.googleapis.com/Machine
edgecontainer.googleapis.com/Rack

Métricas de recursos `Machine`

O Distributed Cloud conectado grava as seguintes métricas da API Cloud Monitoring para o recurso edgecontainer.googleapis.com/Machine:

Métrica	Descrição
`/machine/cpu/total_cores` Tipo: `GAUGE` Tipo: `INT`	Contagem total de núcleos de processador físico presentes na máquina.
`/machine/cpu/usage_time` Tipo: `CUMULATIVE` Tipo: `DOUBLE` Unidade: `Seconds`	Tempo de uso cumulativo da CPU para todos os núcleos da máquina. O tipo pode ser `workload` (cargas de trabalho do cliente) ou `system` (tudo o mais).
`/machine/cpu/utilization` Tipo: `GAUGE` Tipo: `DOUBLE`	Porcentagem de utilização da CPU na máquina. O intervalo é de 0 a 1. O tipo pode ser `workload` (cargas de trabalho do cliente) ou `system` (tudo o mais).
`/machine/memory/total_bytes` Tipo: `GAUGE` Tipo: `INT64`	Contagem de bytes da memória total na máquina.
`/machine/memory/used_bytes` Tipo: `GAUGE` Tipo: `INT64`	Contagem de bytes da memória usada na máquina. `memory_type` é either `evictable` (reivindicável pelo kernel) ou `non-evictable` (não reivindicável).
`/machine/memory/utilization` Tipo: `GAUGE` Tipo: `DOUBLE`	Porcentagem de utilização da memória na máquina. O intervalo é de 0 a 1. `memory_type` é `evictable` (reivindicável pelo kernel) ou `non-evictable` (não reivindicável).
`/machine/network/up` Tipo: `GAUGE` Tipo: `BOOL`	Indica se a interface de rede está ativa e em execução. Inclui cartões principais, secundários e portas.
`/machine/network/link_speed` Tipo: `GAUGE` Tipo: `DOUBLE` Unidade: bytes por segundo	Velocidade do link da placa de interface de rede principal.
`/machine/network/received_bytes_count` Tipo: `CUMULATIVE` Tipo: `DOUBLE`	Contagem de bytes recebidos para a placa de interface de rede principal.
`/machine/network/sent_bytes_count` Tipo: `CUMULATIVE` Tipo: `DOUBLE`	Contagem de bytes enviados para a placa de interface de rede principal.
`/machine/network/connectivity` Tipo: `GAUGE` Tipo: `BOOL`	Indica se a placa de interface de rede principal tem conectividade com a Internet.
`/machine/disk/total_bytes` Tipo: `GAUGE` Tipo: `INT64`	Contagem de bytes do espaço total em disco na máquina.
`/machine/disk/used_bytes` Tipo: `GAUGE` Tipo: `INT64`	Contagem de bytes do espaço em disco usado na máquina.
`/machine/disk/utilization` Tipo: `GAUGE` Tipo: `DOUBLE`	Porcentagem de utilização do espaço em disco na máquina. O intervalo é de 0 a 1.
`/machine/restart_count` Tipo: `CUMULATIVE` Tipo: `INT`	Número de reinicializações que a máquina passou.
`/machine/uptime` Tipo: `GAUGE` Tipo: `INT` Unidade: `Seconds`	Tempo de atividade da máquina desde a última reinicialização.
`/machine/connected` Tipo: `GAUGE` Tipo: `INT64`	Indica se a máquina está conectada a Google Cloud.

Métricas de recursos `Rack`

O Distributed Cloud conectado grava as seguintes métricas da API Cloud Monitoring para o recurso edgecontainer.googleapis.com/Rack:

Métrica	Descrição
`/router/bgp_up` Tipo: `GAUGE` Tipo: `BOOL`	Indica se a sessão de peering BGP no roteador está ativa e íntegra. `router_id` identifica o roteador específico (até 2 por rack).
`/router/connected` Tipo: `GAUGE` Tipo: `BOOL`	Indica se o roteador BGP está conectado a Google Cloud. `router_id` identifica o roteador específico (até 2 por rack).

Exportar registros e métricas de aplicativos personalizados

O Distributed Cloud conectado exporta automaticamente registros de aplicativos em execução em cargas de trabalho do Distributed Cloud conectado. Para exportar métricas de um aplicativo em execução em cargas de trabalho do Distributed Cloud conectado, é necessário anotá-lo conforme descrito na próxima seção.

Anotar a carga de trabalho para ativar a exportação de métricas

Para ativar a coleta de métricas personalizadas de um aplicativo, adicione as seguintes anotações ao manifesto de serviço ou de implantação do aplicativo:

prometheus.io/scrape: "true"
prometheus.io/path: "ENDPOINT_PATH". Substitua ENDPOINT_PATH pelo caminho completo para o endpoint de métrica do aplicativo de destino.
prometheus.io/port: "PORT_NUMBER": a porta em que o endpoint de métrica do aplicativo escuta conexões.

Executar um aplicativo de exemplo

Nesta seção, você criará um aplicativo que grava registros personalizados e expõe um endpoint de métrica personalizada.

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

Crie a implantação e o serviço:

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

Veja os registros do aplicativo.

Console

No console do Google Cloud , acesse a página Análise de registros.
Acessar a Análise de registros
Clique em Recurso.
Na lista Todos os tipos de recursos, selecione Kubernetes Container.
Em Nome do cluster, selecione o nome do cluster de usuário.
Em Nome do namespace, selecione default.
Clique em Adicionar e em Executar consulta.

Na seção Resultados da consulta, é possível conferir 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

Use o comando gcloud logging read:

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'

Ver métricas do aplicativo

O aplicativo de exemplo expõe uma métrica personalizada chamada example_monitoring_up. É possível conferir os valores dessa métrica no Google Cloud console do.

No Google Cloud console do, acesse a página Metrics Explorer.
Acesse o Metrics explorer
Em Tipo de recurso, selecione Kubernetes Pod.
Em Métrica, selecione external/prometheus/example_monitoring_up.
No gráfico, você pode ver que example_monitoring_up tem um valor repetido de 1.

Coletar métricas com o Prometheus

O Distributed Cloud conectado oferece suporte à Prometheus para coletar métricas nas cargas de trabalho do Distributed Cloud conectado.

Para isso, o Distributed Cloud conectado cria um namespace não gerenciado com o nome prom-monitoring ao criar um cluster do Distributed Cloud conectado. Recomendamos que você use esse namespace para implantar o Prometheus. Também é possível copiar os recursos necessários do namespace prom-monitoring para um namespace de sua escolha e implantar o Prometheus nele.

Configurar a extração de métricas do Prometheus

Para coletar métricas do Distributed Cloud conectado com o Prometheus, é necessário configurar a extração de métricas do Prometheus. Para fazer isso, monte o ConfigMap prometheus-scrape-config no pod do Prometheus e adicione a configuração de extração do ConfigMap à configuração do Prometheus. Exemplo:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: prometheus-deployment
  namespace: prom-monitoring
  labels:
    app: prom-monitoring
spec:
  replicas: 1
  selector:
    matchLabels:
      app: prom-monitoring
  template:
    metadata:
      labels:
        app: prom-monitoring
    spec:
      containers:
        - name: prometheus
          image: prom/prometheus:main
          args:
            - "--config.file=/etc/prometheus/prometheus.yml"
            - "--storage.tsdb.path=/prometheus/"
          ports:
            - containerPort: 9090
          volumeMounts:
            - name: prometheus-config-volume
              mountPath: /etc/prometheus/
            - name: prometheus-scrape-config-volume
              mountPath: /etc/prometheus/scrape/
            - name: prometheus-storage-volume
              mountPath: /prometheus/
            - name: prometheus-scrape-token
              mountPath: /var/run/secrets/kubernetes.io/stackdriver-prometheus-scrape
            - name: stackdriver-prometheus-scrape-cert
              mountPath: /certs/stackdriver-prometheus-scrape
            - name: metrics-providers-ca
              mountPath: /certs/metrics-providers
            - name: stackdriver-prometheus-etcd-scrape
              mountPath: /stackdriver-prometheus-etcd-scrape
      volumes:
        - name: prometheus-storage-volume
          emptyDir: {}
        - name: prometheus-config-volume
          configMap:
            defaultMode: 420
            name: prometheus-config
        - name: prometheus-scrape-config-volume
          configMap:
            defaultMode: 420
            name: prometheus-scrape-config
        - name: prometheus-scrape-token
          secret:
            defaultMode: 420
            secretName: prometheus-scrape
        - name: stackdriver-prometheus-scrape-cert
          secret:
            defaultMode: 420
            secretName: stackdriver-prometheus-scrape-cert
        - name: metrics-providers-ca
          secret:
            defaultMode: 420
            items:
            - key: ca.crt
              path: ca.crt
            secretName: metrics-providers-ca
        - name: stackdriver-prometheus-etcd-scrape
          secret:
            defaultMode: 420
            optional: true
            secretName: stackdriver-prometheus-etcd-scrape

Para coletar métricas de carga de trabalho com o Prometheus, adicione anotações aos serviços e pods que executam as cargas de trabalho de destino da seguinte maneira:

Para enviar métricas ao Cloud Monitoring e ao Prometheus, use as anotações descritas em Exportar registros e métricas personalizados.
Para enviar métricas apenas ao Prometheus, use as seguintes anotações:

prometheus.io/unmanaged_scrape: "true"
prometheus.io/unmanaged_path: "ENDPOINT_PATH"
prometheus.io/unmanaged_port: "PORT_NUMBER"

Coletar registros com o Kafka

O Distributed Cloud conectado oferece suporte à solução do Apache Kafka para coletar registros em cargas de trabalho em execução na implantação do Distributed Cloud conectado.

É necessário ter uma implantação funcional do Kafka antes de concluir as etapas desta seção. Os agentes do Kafka precisam anunciar os listeners no modo PLAINTEXT. As variáveis relacionadas a SSL/SASL não são compatíveis.

Para configurar um cluster para geração de registros do Kafka, é necessário criar um arquivo JSON que configure os complementos que você quer executar no cluster. Especifique esse arquivo ao criar um cluster usando a flag --system-addons-config. Se você precisar modificar a configuração do Kafka, exclua e recrie o cluster com as novas configurações do Kafka.

Adicione a seguinte seção ao arquivo de configuração de complementos do sistema:

{
        "systemAddonsConfig": {
          "unmanagedKafkaConfig": {
            "brokers": "BROKERS",
            "topics": "TOPICS"
     "topic_key": "TOPIC_KEY, 
          }
      }
}

Substitua:

BROKERS: uma lista separada por vírgulas de pares de endereço IP e porta do agente no formato ip_address:port.
TOPICS: uma lista separada por vírgulas de tópicos do Kafka.
TOPIC_KEY: uma chave de tópico do Kafka. Isso permite que o Kafka selecione um tópico se houver vários.

Se o Kafka não estiver coletando registros depois que você criar o cluster do Distributed Cloud conectado, verifique o seguinte:

Lado do servidor:verifique os registros de erros na implantação do Kafka para indicações de um problema.
Lado do cliente: entre em contato com o Suporte do Google para recuperar e examinar os registros de pods do sistema.

A seguir

Registro de auditoria

Registros e métricas Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.