Habilitar el registro y la supervisión de la aplicación

En esta página, se muestra cómo configurar un clúster para GDCV para Bare Metal a fin de que los registros y las métricas personalizados de las aplicaciones de usuario se envíen a Cloud Logging, Cloud Monitoring y Servicio administrado para Prometheus.

Para obtener la mejor experiencia de registro y supervisión de aplicaciones de usuario, te recomendamos que uses la siguiente configuración:

  • Habilita Google Cloud Managed Service para Prometheus mediante la configuración de enableGMPForApplications como true en el objeto Stackdriver. Esta configuración te permite supervisar tus cargas de trabajo de forma global y generar alertas sobre ellas mediante Prometheus. Si deseas obtener instrucciones y más información, consulta Habilita el servicio administrado para Prometheus en esta página.

  • Habilita Cloud Logging para las aplicaciones de usuarios mediante la configuración de enableCloudLoggingForApplications en true en el objeto Stackdriver. Esta configuración proporciona registros para tus cargas de trabajo. Si quieres obtener instrucciones y más información, consulta Habilita Cloud Logging para aplicaciones de usuarios en esta página.

Habilita Managed Service para Prometheus

La configuración del servicio administrado para Prometheus se especifica en un objeto Stackdriver llamado stackdriver. Para obtener información adicional, incluidas las prácticas recomendadas y la solución de problemas, consulta la documentación del servicio administrado para Prometheus.

Si deseas configurar el objeto stackdriver para habilitar Google Cloud Managed Service para Prometheus, sigue estos pasos:

  1. Abre el objeto de Stackdriver para editarlo:

    kubectl --kubeconfig=CLUSTER_KUBECONFIG \
        --namespace kube-system edit stackdriver stackdriver
    

    Reemplaza CLUSTER_KUBECONFIG por la ruta del archivo kubeconfig del clúster de administrador.

  2. En spec, configura 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. Guarda y cierra el archivo editado.

    Los componentes de Prometheus administrados por Google se inician automáticamente en el clúster del espacio de nombres gmp-system.

  4. Verifica los componentes de Prometheus administrados por Google:

    kubectl --kubeconfig=CLUSTER_KUBECONFIG --namespace gmp-system get pods
    

    El resultado de este comando es similar al siguiente:

    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
    

El servicio administrado para Prometheus admite la evaluación de reglas y las alertas. Para configurar la evaluación de reglas, consulta Evaluación de reglas.

Ejecuta una aplicación de ejemplo

El servicio administrado proporciona un manifiesto para una aplicación de ejemplo, prom-example, que emite métricas de Prometheus en su puerto metrics. La aplicación usa tres réplicas.

Para implementar la aplicación, haz lo siguiente:

  1. Crea el espacio de nombres gmp-test para los recursos que crees como parte de la aplicación de ejemplo:

    kubectl --kubeconfig=CLUSTER_KUBECONFIG create ns gmp-test
    
  2. Aplica el manifiesto de la aplicación con el siguiente comando:

    kubectl -n gmp-test apply \
        -f https://raw.githubusercontent.com/GoogleCloudPlatform/prometheus-engine/v0.4.1/examples/example-app.yaml
    

Configura un recurso PodMonitoring

En esta sección, configurarás un recurso personalizado PodMonitoring para capturar datos de métricas emitidos por la aplicación de ejemplo y enviarlos al servicio administrado para Prometheus. El recurso personalizado PodMonitoring usa la recopilación de objetivos. En este caso, los agentes recopiladores extraen el extremo /metrics en el que la aplicación de ejemplo emite datos.

Un recurso personalizado PodMonitoring solo recopila objetivos en el espacio de nombres en el que se implementa. Para recopilar destinos en varios espacios de nombres, implementa el mismo recurso personalizado PodMonitoring en cada espacio de nombres. Puedes verificar que el recurso PodMonitoring está instalado en el espacio de nombres deseado mediante la ejecución del siguiente comando:

kubectl --kubeconfig CLUSTER_KUBECONFIG get podmonitoring -A

Para ver la documentación de referencia sobre todos los servicios personalizados de los servicios administrados de Prometheus, consulta la referencia de prometheus-engine/doc/api.

El siguiente manifiesto define un recurso PodMonitoring, prom-example, en el espacio de nombres gmp-test. El recurso encuentra todos los Pods en el espacio de nombres que tienen la etiqueta app con el valor prom-example. Los Pods coincidentes se copian en un puerto llamado metrics, cada 30 segundos, en la ruta 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 este recurso, ejecuta el siguiente comando:

kubectl --kubeconfig CLUSTER_KUBECONFIG -n gmp-test apply \
    -f https://raw.githubusercontent.com/GoogleCloudPlatform/prometheus-engine/v0.4.1/examples/pod-monitoring.yaml

El servicio administrado para Prometheus ahora recopila los Pods coincidentes.

Consulta datos de métricas

La forma más sencilla de verificar que se exporten los datos de Prometheus es usar consultas de PromQL en el Explorador de métricas en la consola de Google Cloud.

Para ejecutar una consulta de PromQL, haz lo siguiente:

  1. En la consola de Google Cloud, ve a la página Monitoring o haz clic en el siguiente botón:

    Ir a Monitoring

  2. En el panel de navegación, selecciona Explorador de métricas.

  3. Usa Prometheus Query Language (PromQL) para especificar los datos que se mostrarán en el gráfico:

    1. En la barra de herramientas del panel Seleccionar una métrica, selecciona Editor de código.

    2. Selecciona PromQL en el botón de activación de Language. El botón de activación del idioma se encuentra en la parte inferior del panel Editor de código.

    3. Ingresa tu consulta en el editor de consultas. Por ejemplo, para graficar la cantidad promedio de segundos que las CPU pasaron en cada modo durante la última hora, usa la siguiente consulta:

      avg(rate(kubernetes_io:anthos_container_cpu_usage_seconds_total
      {monitored_resource="k8s_node"}[1h]))
      

    Para obtener más información sobre el uso de PromQL, consulta PromQL en Cloud Monitoring.

En la siguiente captura de pantalla, se muestra un gráfico en el que se muestra la métrica anthos_container_cpu_usage_seconds_total:

Gráfico de Managed Service para Prometheus para la métrica `anthos_container_cpu_usage_seconds_total` de Prometheus.

Si recopilas grandes cantidades de datos, te recomendamos filtrar las métricas exportadas para reducir los costos.

Habilita Cloud Logging para aplicaciones de usuario

La configuración de Cloud Logging y Cloud Monitoring se guarda en un objeto de Stackdriver llamado stackdriver.

  1. Abre el objeto de Stackdriver para editarlo:

    kubectl --kubeconfig=CLUSTER_KUBECONFIG \
        --namespace kube-system edit stackdriver stackdriver
    

    Reemplaza CLUSTER_KUBECONFIG con la ruta de tu archivo kubeconfig del clúster de usuario.

  2. En la sección spec, configura 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. Guarda y cierra el archivo editado.

Ejecuta una aplicación de ejemplo

En esta sección, crearás una aplicación que escriba registros personalizados.

  1. Guarda los siguientes manifiestos de Gateway en un archivo llamados 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. Crea el objeto Deployment

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

Ver los registros de la aplicación

Console

  1. Ve al Explorador de registros en la consola de Google Cloud.

    Ir al Explorador de registros.

  2. Haz clic en Recurso. En el menú TODOS LOS TIPOS DE RECURSOS, selecciona Contenedor de Kubernetes.

  3. En CLUSTER_NAME, selecciona el nombre de tu clúster de usuario.

  4. En NAMESPACE_NAME, selecciona predeterminado.

  5. Haz clic en Agregar y, luego, en Ejecutar consulta.

  6. En 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 CLI

  1. Ejecuta este comando:

    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.

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

Filtrar registros de aplicaciones

Filtrar registros de aplicaciones puede reducir la facturación de registros de aplicaciones y el tráfico de red del clúster a Cloud Logging. A partir de la versión 1.15.0 de GKE en Bare Metal, cuando enableCloudLoggingForApplications se configura como true, puedes filtrar los registros de la aplicación según los siguientes criterios:

  • Etiquetas de Pod (podLabelSelectors)
  • Espacios de nombres (namespaces)
  • Expresiones regulares para el contenido de registro (contentRegexes)

GKE en Bare Metal envía solo los resultados del filtro a Cloud Logging.

Define filtros de registro de la aplicación

La configuración para Logging se especifica en un objeto de Stackdriver llamado stackdriver.

  1. Abre el objeto stackdriver para editarlo:

    kubectl --kubeconfig USER_CLUSTER_KUBECONFIG --namespace kube-system \
        edit stackdriver stackdriver
    

    Reemplaza USER_CLUSTER_KUBECONFIG por la ruta de acceso al archivo kubeconfig de tu clúster de usuario.

  2. Agrega una sección appLogFilter a 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. Guarda y cierra el archivo editado.

  4. Si usas podLabelSelectors, reinicia el DaemonSet de stackdriver-log-forwarder para aplicar los cambios lo antes posible (opcional):

    kubectl --kubeconfig USER_CLUSTER_KUBECONFIG --namespace kube-system \
        rollout restart daemonset stackdriver-log-forwarder
    

    Por lo general, los podLabelSelectors son efectivos después de 10 minutos. Si reinicias el DaemonSet stackdriver-log-forwarder, los cambios se aplicarán con más rapidez.

Ejemplo: Incluye los registros ERROR o WARN solo en el espacio de nombres prod

En el siguiente ejemplo, se muestra cómo funciona un filtro de registro de la aplicación. Debes definir un filtro que use un espacio de nombres (prod), una expresión regular (.*(ERROR|WARN).*) y una etiqueta de Pod (disableGCPLogging=yes). Luego, para verificar que el filtro funcione, ejecuta un Pod en el espacio de nombres prod a fin de probar estas condiciones del filtro.

Para definir y probar un filtro de registro de la aplicación, haz lo siguiente:

  1. Especifica un filtro de registro de la aplicación en el objeto Stackdriver:

    En el siguiente ejemplo de appLogFilter, solo se conservan los registros ERROR o WARN en el espacio de nombres prod. Se descartan todos los registros de los Pods con la etiqueta disableGCPLogging=yes:

    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. Implementa un Pod en el espacio de nombres prod y ejecuta una secuencia de comandos que genere entradas de registro ERROR y 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"
    

    Los registros filtrados deben contener solo las entradas ERROR, no las INFO.

  3. Agrega la etiqueta disableGCPLogging=yes al Pod:

    kubectl --kubeconfig USER_CLUSTER_KUBECONFIG label pods pod1 \
        --namespace prod disableGCPLogging=yes
    

    El registro filtrado ya no debe contener ninguna entrada para el Pod pod1.

Definición de la API de filtro de registro de aplicaciones

La definición para el filtro de registro de la aplicación se declara dentro de la definición del recurso personalizado de Stackdriver.

Para obtener la definición del recurso personalizado de Stackdriver, ejecuta el siguiente comando:

kubectl --kubeconfig USER_CLUSTER_KUBECONFIG get crd stackdrivers.addons.gke.io \
    --namespace kube-system -o yaml