Para obtener información sobre la versión, consulta las notas de la versión de Distributed Cloud conectado.

Registros y métricas

En esta página, se explica cómo Google Distributed Cloud conectado registra varios tipos de información sobre su operación y cómo ver esa información. La recopilación de algunos tipos de registros y métricas genera cargos adicionales. Para obtener más información, consulta Facturación de registros y métricas.

Configurar el registro y la supervisión

Antes de comenzar a recopilar registros y métricas, debes hacer lo siguiente:

Habilita las APIs de Logging con los siguientes comandos:

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

Reemplaza PROJECT_ID por el ID del proyecto Google Cloud de destino.

Otorga los roles necesarios para escribir registros y 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]"

Reemplaza PROJECT_ID por el ID del proyecto Google Cloud de destino.

Registros

En esta sección, se enumeran los tipos de recursos de Cloud Logging que admite Distributed Cloud. Para ver los registros de Distributed Cloud, usa el Explorador de registros en la consola de Google Cloud . El registro de Distributed Cloud siempre está habilitado.

Los tipos de recursos registrados conectados de Distributed Cloud son los siguientes recursos estándar de Kubernetes:

k8s_container
k8s_node

También puedes capturar y recuperar registros conectados de Distributed Cloud con la API de Cloud Logging. Para obtener información sobre cómo configurar este mecanismo de registro, consulta la documentación de las bibliotecas cliente de Cloud Logging.

Métricas

En esta sección, se enumeran las métricas de Cloud Monitoring que admite Distributed Cloud. Para ver las métricas de Distributed Cloud, usa el Explorador de métricas en la consola deGoogle Cloud .

Métricas de clústeres de Distributed Cloud conectado

En el caso de los clústeres de Distributed Cloud connected, Distributed Cloud connected proporciona los siguientes tipos de métricas generadas por los nodos de Distributed Cloud connected:

Las métricas de recursos proporcionan información sobre el rendimiento de los nodos conectados y los Pods de Distributed Cloud, como la carga de CPU y el uso de memoria.
Las métricas de aplicaciones del sistema proporcionan información sobre las cargas de trabajo del sistema conectado de Distributed Cloud, como coredns.

Para obtener una lista de estas métricas, consulta Google Distributed Cloud y sus métricas.

Distributed Cloud connected no proporciona métricas generadas por los planos de control de Kubernetes asociados con los clústeres de Distributed Cloud connected.

Métricas de hardware conectado a Distributed Cloud

Distributed Cloud connected proporciona métricas para el hardware conectado a Distributed Cloud con los siguientes tipos de recursos:

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

Métricas de recursos de `Machine`

Distributed Cloud conectado escribe las siguientes métricas de la API de Cloud Monitoring para el recurso edgecontainer.googleapis.com/Machine:

Métrica	Descripción
`/machine/cpu/total_cores` Tipo: `GAUGE` Tipo: `INT`	Es el recuento total de núcleos de procesador físicos presentes en la máquina.
`/machine/cpu/usage_time` Tipo: `CUMULATIVE` Tipo: `DOUBLE` Unidad: `Seconds`	Tiempo de uso acumulado de la CPU para todos los núcleos de la máquina. El tipo puede ser `workload` (cargas de trabajo del cliente) o `system` (todo lo demás).
`/machine/cpu/utilization` Tipo: `GAUGE` Tipo: `DOUBLE`	Porcentaje de uso de CPU en la máquina. El rango es de 0 a 1. El tipo puede ser `workload` (cargas de trabajo del cliente) o `system` (todo lo demás).
`/machine/memory/total_bytes` Tipo: `GAUGE` Tipo: `INT64`	Es el recuento de bytes de la memoria total de la máquina.
`/machine/memory/used_bytes` Tipo: `GAUGE` Tipo: `INT64`	Es el recuento de bytes de la memoria utilizada en la máquina. `memory_type` es `evictable` (recuperable por el kernel) o `non-evictable` (no recuperable).
`/machine/memory/utilization` Tipo: `GAUGE` Tipo: `DOUBLE`	Es el porcentaje de uso de memoria en la máquina. El rango es de 0 a 1. `memory_type` es `evictable` (recuperable por el kernel) o `non-evictable` (no recuperable).
`/machine/network/up` Tipo: `GAUGE` Tipo: `BOOL`	Indica si la interfaz de red está en funcionamiento. Incluye tarjetas principales, tarjetas secundarias y puertos.
`/machine/network/link_speed` Tipo: `GAUGE` Tipo: `DOUBLE` Unidad: bytes por segundo	Velocidad de vínculo de la tarjeta de interfaz de red principal.
`/machine/network/received_bytes_count` Tipo: `CUMULATIVE` Tipo: `DOUBLE`	Es el recuento de bytes recibidos para la tarjeta de interfaz de red principal.
`/machine/network/sent_bytes_count` Tipo: `CUMULATIVE` Tipo: `DOUBLE`	Es el recuento de bytes enviados para la tarjeta de interfaz de red principal.
`/machine/network/connectivity` Tipo: `GAUGE` Tipo: `BOOL`	Indica si la tarjeta de interfaz de red principal tiene conectividad a Internet.
`/machine/disk/total_bytes` Tipo: `GAUGE` Tipo: `INT64`	Es el recuento de bytes del espacio total en disco de la máquina.
`/machine/disk/used_bytes` Tipo: `GAUGE` Tipo: `INT64`	Es el recuento de bytes del espacio en disco usado en la máquina.
`/machine/disk/utilization` Tipo: `GAUGE` Tipo: `DOUBLE`	Es el porcentaje de uso del espacio en disco de la máquina. El rango es de 0 a 1.
`/machine/restart_count` Tipo: `CUMULATIVE` Tipo: `INT`	Cantidad de reinicios que sufrió la máquina.
`/machine/uptime` Tipo: `GAUGE` Tipo: `INT` Unidad: `Seconds`	Tiempo de actividad de la máquina desde el último reinicio.
`/machine/connected` Tipo: `GAUGE` Tipo: `INT64`	Indica si la máquina está conectada a Google Cloud.

Métricas de recursos de `Rack`

Distributed Cloud conectado escribe las siguientes métricas de la API de Cloud Monitoring para el recurso edgecontainer.googleapis.com/Rack:

Métrica	Descripción
`/router/bgp_up` Tipo: `GAUGE` Tipo: `BOOL`	Indica si la sesión de peering de BGP en el router está activa y en buen estado. `router_id` identifica el router específico (hasta 2 por rack).
`/router/connected` Tipo: `GAUGE` Tipo: `BOOL`	Indica si el router BGP está conectado a Google Cloud. `router_id` identifica el router específico (hasta 2 por rack).

Exporta métricas y registros de aplicaciones personalizados

Distributed Cloud conectado exporta automáticamente los registros de las aplicaciones que se ejecutan en cargas de trabajo de Distributed Cloud conectado. Para exportar métricas de una aplicación que se ejecuta en cargas de trabajo conectadas de Distributed Cloud, debes agregarle anotaciones como se describe en la siguiente sección.

Anota la carga de trabajo para habilitar la exportación de métricas

Para habilitar la recopilación de métricas personalizadas de una aplicación, agrega las siguientes anotaciones al manifiesto de servicio o Deployment de la aplicación:

prometheus.io/scrape: "true"
prometheus.io/path: "ENDPOINT_PATH". Reemplaza ENDPOINT_PATH por la ruta de acceso completa al extremo de métricas de la aplicación de destino.
prometheus.io/port: "PORT_NUMBER": Es el puerto en el que el extremo de métricas de la aplicación escucha las conexiones.

Ejecuta una aplicación de ejemplo

En esta sección, crearás una aplicación que escriba registros personalizados y exponga un extremo de métrica personalizada.

Guarda los siguientes manifiestos de Service y Deployment en un archivo llamado my-app.yaml. Ten en cuenta que el Service tiene la anotación 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

Crea el Deployment y el Service:

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

Ver los registros de la aplicación

Console

En la consola de Google Cloud , accede a la página Explorador de registros.
Ve al Explorador de registros
Haz clic en Recurso.
En la lista Todos los tipos de recursos, selecciona Kubernetes Container.
En Nombre del clúster, selecciona el nombre de tu clúster de usuario.
En Nombre del espacio de nombres, selecciona default.
Haz clic en Agregar y, luego, en Ejecutar consulta.

En la sección Resultados de la consulta, puedes ver las entradas de registro del Deployment monitoring-example. Por ejemplo:

{
  "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

Usa el comando gcloud logging read:

gcloud logging read 'resource.labels.project_id="PROJECT_ID" AND \
    resource.type="k8s_container" AND resource.labels.namespace_name="default"'

Reemplaza PROJECT_ID por el ID de tu proyecto.

En el resultado, puedes ver las entradas de registro del Deployment monitoring-example. Por ejemplo:

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'

Consulta las métricas de las aplicaciones

Tu aplicación de ejemplo expone una métrica personalizada llamada example_monitoring_up. Puedes ver los valores de esa métrica en la consola de Google Cloud .

En la consola de Google Cloud , ve a la página Explorador de métricas.
Dirígete al Explorador de métricas
En Tipo de recurso, selecciona Kubernetes Pod.
En Métrica, selecciona external/prometheus/example_monitoring_up.
En el gráfico, puedes ver que example_monitoring_up tiene un valor repetido de 1.

Recopila métricas con Prometheus

Distributed Cloud connected admite la solución de métricas de Prometheus para recopilar métricas en tus cargas de trabajo conectadas a Distributed Cloud.

Para este propósito, Distributed Cloud connected crea un espacio de nombres no administrado con el nombre prom-monitoring cuando creas un clúster de Distributed Cloud connected. Te recomendamos que uses este espacio de nombres para implementar Prometheus. También puedes copiar los recursos necesarios del espacio de nombres prom-monitoring a un espacio de nombres de tu elección y, luego, implementar Prometheus allí.

Configura la recopilación de métricas de Prometheus

Para recopilar métricas conectadas de Distributed Cloud con Prometheus, debes configurar la recopilación de métricas de Prometheus. Para ello, instala el ConfigMap prometheus-scrape-config en tu Pod de Prometheus y agrega la configuración de extracción del ConfigMap a tu configuración de Prometheus. Por ejemplo:

apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: prometheus-local-rolebinding
  namespace: prom-monitoring
subjects:
- kind: ServiceAccount
  name: prometheus-scrape
  namespace: prom-monitoring
roleRef:
  kind: ClusterRole
  name: gke-metrics-agent
  apiGroup: rbac.authorization.k8s.io
---
apiVersion: v1
kind: ConfigMap
metadata:
  name: prometheus-config
  namespace: prom-monitoring
data:
  prometheus.yml: |
    global:
      scrape_interval: 5s
      evaluation_interval: 5s
    rule_files:
    scrape_config_files:
    - /etc/prometheus/scrape/*.yml
---
apiVersion: v1
kind: Service
metadata:
  name: prometheus
  namespace: prom-monitoring
spec:
  selector:
    app: prom-monitoring
  ports:
  - port: 9090
    targetPort: 9090
  type: LoadBalancer
---
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:
      serviceAccountName: prometheus-scrape
      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: 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
            optional: true
            secretName: stackdriver-prometheus-scrape-cert
        - name: stackdriver-prometheus-etcd-scrape
          secret:
            defaultMode: 420
            optional: true
            secretName: stackdriver-prometheus-etcd-scrape

Para recopilar métricas de cargas de trabajo con Prometheus, debes agregar anotaciones a los servicios y los Pods que ejecutan las cargas de trabajo objetivo de la siguiente manera:

Para enviar métricas a Cloud Monitoring y Prometheus, usa las anotaciones que se describen en Exporta registros y métricas personalizados.
Para enviar métricas solo a Prometheus, usa las siguientes anotaciones:

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

Recopila registros con Kafka

Distributed Cloud Connected admite la solución Apache Kafka para recopilar registros en las cargas de trabajo que se ejecutan en tu implementación de Distributed Cloud Connected.

Debes tener una implementación de Kafka funcional antes de completar los pasos de esta sección. Tus agentes de Kafka deben anunciar sus listeners en modo PLAINTEXT. No se admiten variables relacionadas con SSL/SASL.

Para configurar un clúster para el registro de Kafka, debes crear un archivo JSON que configure los complementos que deseas ejecutar en el clúster. Especifica este archivo cuando crees un clúster con la marca --system-addons-config. Si necesitas modificar la configuración de Kafka, debes borrar y volver a crear el clúster con la nueva configuración de Kafka.

Agrega la siguiente sección al archivo de configuración de complementos del sistema:

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

Reemplaza lo siguiente:

BROKERS: Es una lista separada por comas de pares de direcciones IP y puertos de agentes en formato ip_address:port.
TOPICS: Es una lista separada por comas de temas de Kafka.
TOPIC_KEY: Es una clave de tema de Kafka que permite que Kafka seleccione un tema si existen varios.

Si Kafka no recopila registros después de que creaste tu clúster conectado de Distributed Cloud, verifica lo siguiente:

Lado del servidor: Revisa los registros de errores en tu implementación de Kafka para ver si hay indicios de un problema.
Del cliente: Comunícate con el equipo de Atención al cliente de Google para recuperar y examinar los registros de los Pods del sistema.

Recopila registros de carga de trabajo sin procesar para el procesamiento externo

Puedes configurar Distributed Cloud Connected para exportar registros de Pods de cargas de trabajo sin procesar (sin procesar ni etiquetar) a /var/logs/export, lo que te permite usar tu propio recopilador de registros para el procesamiento de registros.

Para configurar la exportación de registros de cargas de trabajo sin procesar, crea un recurso personalizado LogExport con el siguiente contenido y, luego, aplícalo a tu clúster:

apiVersion: gdc.addons.gke.io/v1
kind: LogExport
metadata:
  name: my-log-export
spec:
  namespaces:
  - namespace1
  - namespace2
  - namespace3

En el campo namespaces, enumera los espacios de nombres de las cargas de trabajo para los que deseas exportar los registros de Pod sin procesar. El campo no acepta espacios de nombres del sistema, como los que se indican en Restricciones del espacio de nombres de administración.

¿Qué sigue?

Registros de auditoría

Registros y métricas Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.