Habilitar el almacenamiento de registros y la monitorización de aplicaciones

En esta página se muestra cómo configurar un clúster para Google Distributed Cloud de forma que los registros y las métricas personalizados de las aplicaciones de usuario se envíen a Cloud Logging, Cloud Monitoring y Google Cloud Managed Service para Prometheus.

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

  • Para habilitar Google Cloud Managed Service para Prometheus, asigna el valor true a enableGMPForApplications en el objeto Stackdriver. Esta configuración te permite monitorizar tus cargas de trabajo y recibir alertas sobre ellas a nivel mundial con Prometheus. Para obtener instrucciones e información adicional, consulta la sección Habilitar Google Cloud Managed Service para Prometheus de esta página.

  • Para habilitar Cloud Logging en las aplicaciones de usuario, asigna el valor true a enableCloudLoggingForApplications en el objeto Stackdriver. Esta configuración proporciona registros de tus cargas de trabajo. Para obtener instrucciones e información adicional, consulta la sección Habilitar Cloud Logging para aplicaciones de usuario de esta página.

Habilitar Google Cloud Managed Service para Prometheus

La configuración de Google Cloud Managed Service para Prometheus se especifica en un objeto Stackdriver llamado stackdriver. Para obtener más información, incluidas las prácticas recomendadas y la solución de problemas, consulta la documentación de Google Cloud Managed Service para Prometheus.

Para configurar el objeto stackdriver y habilitar Managed Service para Prometheus, haz lo siguiente: Google Cloud

  1. Abre el objeto de Stackdriver para editarlo:

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

    Sustituye CLUSTER_KUBECONFIG por la ruta del archivo kubeconfig de tu clúster.

  2. En spec, asigna el valor true a enableGMPForApplications:

    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 gestionados por Google se inician automáticamente en el clúster en el espacio de nombres gmp-system.

  4. Comprueba los componentes de Prometheus gestionados por Google:

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

    El resultado debe ser 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

Google Cloud Managed Service para Prometheus admite la evaluación de reglas y las alertas. Para configurar la evaluación de reglas, consulta el artículo Evaluación de reglas.

Ejecutar una aplicación de ejemplo

El servicio gestionado 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 desplegar la aplicación, sigue estos pasos:

  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 archivo de 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 de PodMonitoring

En esta sección, configurarás un recurso personalizado PodMonitoring para capturar los datos de métricas emitidos por la aplicación de ejemplo y enviarlos a Google Cloud Managed Service para Prometheus. El recurso personalizado PodMonitoring usa el raspado de datos. En este caso, los agentes del recolector rastrean el /metricsendpoint al que emite datos la aplicación de ejemplo.

Un recurso personalizado PodMonitoring solo rastrea los destinos del espacio de nombres en el que se ha implementado. Para raspar destinos en varios espacios de nombres, implementa el mismo recurso personalizado PodMonitoring en cada espacio de nombres. Para comprobar que el recurso PodMonitoring se ha instalado en el espacio de nombres previsto, ejecuta el siguiente comando:

kubectl --kubeconfig CLUSTER_KUBECONFIG get podmonitoring -A

Para consultar la documentación de referencia sobre todos los recursos personalizados de Google Cloud Managed Service para Prometheus, consulta prometheus-engine/doc/api reference.

El siguiente archivo de manifiesto define un recurso PodMonitoring, prom-example, en el espacio de nombres gmp-test. El recurso busca todos los pods del espacio de nombres que tengan la etiqueta app con el valor prom-example. Los pods coincidentes se rastrean 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

Google Cloud Managed Service para Prometheus ahora está obteniendo datos de los pods coincidentes.

Consultar datos de métricas

La forma más sencilla de verificar que tus datos de Prometheus se están exportando es usar consultas de PromQL en el explorador de métricas de la consola de Google Cloud .

Para ejecutar una consulta de PromQL, haz lo siguiente:

  1. En la Google Cloud consola, 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 el lenguaje de consulta de Prometheus (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, elija Editor de código.

    2. Selecciona PromQL en el interruptor Idioma. El interruptor de idioma se encuentra en la parte inferior del panel Editor de código.

    3. Escribe tu consulta en el editor de consultas. Por ejemplo, para representar en un gráfico el número medio de segundos que las CPUs han dedicado a cada modo durante la última hora, utiliza 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 cómo usar PromQL, consulta el artículo PromQL en Cloud Monitoring.

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

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

Si recoges grandes cantidades de datos, puede que te interese filtrar las métricas exportadas para reducir los costes.

Habilitar Cloud Logging para aplicaciones de usuario

La configuración de Cloud Logging y Cloud Monitoring se encuentra 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

    Sustituye CLUSTER_KUBECONFIG por la ruta del archivo kubeconfig de tu clúster de usuario.

  2. En la sección spec, define 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.

Ejecutar una aplicación de ejemplo

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

  1. Guarda los siguientes manifiestos de Deployment en un archivo llamado 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. Crear el despliegue

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

Ver registros de aplicaciones

Consola

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

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

  5. Haz clic en Añadir y, a continuación, en Ejecutar consulta.

  6. En Resultados de la consulta, puedes ver las entradas de registro de la monitoring-example implementación. 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"
}

CLI de gcloud

  1. Ejecuta este comando:

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

    Sustituye PROJECT_ID por el ID de tu proyecto.

  2. En la salida, puedes ver las entradas de registro de la monitoring-example implementación. 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

El filtrado de registros de aplicaciones puede reducir la facturación de los 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 Google Distributed Cloud, cuando enableCloudLoggingForApplications se establece en true, puedes filtrar los registros de aplicaciones por los siguientes criterios:

  • Etiquetas de pod (podLabelSelectors)
  • Espacios de nombres (namespaces)
  • Expresiones regulares para el contenido de los registros (contentRegexes)

Google Distributed Cloud solo envía los resultados del filtro a Cloud Logging.

Definir filtros de registro de aplicaciones

La configuración de 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

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

  2. Añade 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. (Opcional) Si usas podLabelSelectors, reinicia el DaemonSet de stackdriver-log-forwarder para que los cambios se apliquen lo antes posible:

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

    Normalmente, las podLabelSelectors se aplican al cabo de 10 minutos. Si reinicias el DaemonSet stackdriver-log-forwarder, los cambios se aplicarán más rápido.

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

En el siguiente ejemplo se muestra cómo funciona un filtro de registro de aplicaciones. Defines un filtro que usa un espacio de nombres (prod), una expresión regular (.*(ERROR|WARN).*) y una etiqueta de pod (disableGCPLogging=yes). A continuación, para verificar que el filtro funciona, ejecutas un pod en el espacio de nombres prod para probar estas condiciones del filtro.

Para definir y probar un filtro de registro de aplicaciones, sigue estos pasos:

  1. Especifica un filtro de registro de aplicaciones en el objeto Stackdriver:

    En el siguiente ejemplo de appLogFilter, solo se conservan los registros ERROR o WARN del espacio de nombres prod. Se descartan 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 solo deben contener las entradas ERROR, no las INFO.

  3. Añade la etiqueta disableGCPLogging=yes al Pod:

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

    El registro filtrado ya no debería contener ninguna entrada del pod pod1.

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

La definición del filtro de registro de la aplicación se declara en la definición de recurso personalizado de stackdriver.

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

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