Personaliza registros de Cloud Logging para Google Kubernetes Engine con Fluentd

En este instructivo, se describe cómo personalizar los registros de Fluentd para un clúster de Google Kubernetes Engine. Aprenderás a alojar tu propio daemonset de Fluentd configurable para enviar registros a Cloud Logging, en lugar de seleccionar la opción de registro en la nube cuando creas el clúster de Google Kubernetes Engine (GKE), que no permite la configuración del daemon de Fluentd.

Objetivos

  • Implementar tu propio daemonset de Fluentd en un clúster de Google Kubernetes Engine, configurado para registrar datos en Cloud Logging. Suponemos que ya conoces Kubernetes
  • Personalizar el registro de GKE para quitar datos sensibles de los registros de Cloud Logging
  • Personaliza el registro de GKE para agregar eventos a nivel de nodo a los registros de Cloud Logging

Costos

En este instructivo, se usan los siguientes componentes facturables de Cloud Platform:

La Calculadora de precios estima que el costo de este entorno es de alrededor de $1.14 por 8 horas.

Antes de comenzar

  1. Accede a tu Cuenta de Google.

    Si todavía no tienes una cuenta, regístrate para obtener una nueva.

  2. En la página de selección de proyectos de Cloud Console, selecciona o crea un proyecto de Cloud.

    Ir a la página Selector de proyectos

  3. Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud. Obtén información sobre cómo confirmar que tienes habilitada la facturación para tu proyecto.

  4. Habilita las API de Google Kubernetes Engine, Compute Engine.

    Habilita las API

Inicializa variables comunes

Debes definir muchas variables que controlen dónde se implementan los elementos de la infraestructura.

  1. Con un editor de texto, edita la siguiente secuencia de comandos y sustituye el ID de tu proyecto por [YOUR_PROJECT_ID]. La secuencia de comandos establece la región como us-east-1. Si realizas cambios a la secuencia de comandos, asegúrate de que los valores de zona hagan referencia a la región que especificas.

    region=us-east1
    zone=${region}-b
    project_id=[YOUR_PROJECT_ID]
    
  2. Ve a Cloud Shell.

    Abrir Cloud Shell

  3. Copia la secuencia de comandos en tu ventana de Cloud Shell y ejecútala.

  4. Ejecuta los siguientes comandos para establecer la zona predeterminada y el ID del proyecto a fin de que no tengas que especificar estos valores en cada comando posterior:

    gcloud config set compute/zone ${zone}
    gcloud config set project ${project_id}
    

Crea el clúster de GKE

Excepto que se especifique lo contrario, debes ingresar todos los comandos para este instructivo en la línea de comandos de tu computadora o en Cloud Shell.

  1. Clona el repositorio de muestra. El repositorio de muestra incluye los manifiestos de Kubernetes para el daemonset de Fluentd y un programa de prueba de registro que implementarás:

    git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-customize-fluentd
    
  2. Cambia tu directorio de trabajo al repositorio clonado:

    cd kubernetes-engine-customize-fluentd
    
  3. Crea el clúster de GKE con el registro en la nube apagado:

    gcloud beta container clusters create gke-with-custom-fluentd \
       --zone us-east1-b \
       --no-enable-cloud-logging \
       --tags=gke-cluster-with-customized-fluentd \
       --scopes=logging-write
    

Implementa la aplicación de registro de prueba

De forma predeterminada, la aplicación de muestra que implementas emite instrucciones de registro aleatorias de forma continua. El contenedor de Docker que usa está disponible en gcr.io/cloud-solutions-images/test-logger y el código fuente se incluye en el subdirectorio test-logger.

  1. Implementa la aplicación test-logger en el clúster de GKE:

    kubectl apply -f kubernetes/test-logger.yaml
    
  2. Ver el estado de los pods test-logger:

    kubectl get pods
    
  3. Repite este comando hasta que el resultado sea similar al siguiente, con los tres pods test-logger en ejecución:

    Resultado del comando que muestra tres pods en ejecución

Implementa el daemonset de Fluentd en tu clúster

A continuación, configurarás el daemonset de Fluentd y lo implementarás.

  1. Implementa la configuración de Fluentd:

    kubectl apply -f kubernetes/fluentd-configmap.yaml
    
  2. Implementa el daemonset de Fluentd:

    kubectl apply -f kubernetes/fluentd-daemonset.yaml
    
  3. Comprueba que los pods de Fluentd se iniciaron:

    kubectl get pods --namespace=kube-system
    

    Si están en ejecución, verás un resultado como este:

    Resultado del comando que muestra tres pods en ejecución

  4. Verifica que veas registros en Logging. En Console, en el menú de la izquierda, haz clic en Logging > Registros (Logs) y selecciona Contenedor de Kubernetes (Kubernetes Container) en la lista.

    Lista de Logging en la que se muestran datos sin filtrar

Filtra información en el archivo de registro

El paso siguiente es especificar a Fluentd que filtre ciertos datos para que no se registren. En este instructivo, debes filtrar los números de identificación personal, de tarjeta de crédito y las direcciones de correo electrónico. A fin de realizar esta actualización, debes cambiar el daemonset para usar un ConfigMap diferente que contenga estos filtros. Usa la función de actualizaciones progresivas de Kubernetes y conserva la versión anterior del ConfigMap.

  1. Abre el archivo kubernetes/fluentd-configmap.yaml en un editor.

  2. Quita el comentario de las líneas intermedias y excluye las líneas ### sample log scrubbing filters y ### end sample log scrubbing filters:

    ############################################################################################################
    #  ### sample log scrubbing filters
    #  #replace social security numbers
    # <filter reform.**>
    #   @type record_transformer
    #   enable_ruby true
    #   <record>
    #     log ${record["log"].gsub(/[0-9]{3}-*[0-9]{2}-*[0-9]{4}/,"xxx-xx-xxxx")}
    #   </record>
    # </filter>
    # # replace credit card numbers that appear in the logs
    # <filter reform.**>
    #   @type record_transformer
    #   enable_ruby true
    #   <record>
    #      log ${record["log"].gsub(/[0-9]{4} *[0-9]{4} *[0-9]{4} *[0-9]{4}/,"xxxx xxxx xxxx xxxx")}
    #   </record>
    # </filter>
    # # replace email addresses that appear in the logs
    # <filter reform.**>
    #   @type record_transformer
    #   enable_ruby true
    #   <record>
    #     log ${record["log"].gsub(/[\w+\-]+@[a-z\d\-]+(\.[a-z\d\-]+)*\.[a-z]+/i,"user@email.tld")}
    #   </record>
    # </filter>
    # ### end sample log scrubbing filters
    #############################################################################################################
  3. Para cambiar el nombre del ConfigMap de fluentd-gcp-config a fluentd-gcp-config-filtered, edita el campo metadata.name:

    name: fluentd-gcp-config
    namespace: kube-system
    labels:
      k8s-app: fluentd-gcp-custom
  4. Guarda el archivo y ciérralo.

Actualiza el daemonset de Fluentd para usar la configuración nueva

Ahora cambia kubernetes/fluentd-daemonset.yaml para activar el ConfigMap fluentd-gcp-config-filtered en lugar de fluentd-gcp-config.

  1. Abre el archivo kubernetes/fluentd-daemonset.yaml en un editor.

  2. Para cambiar el nombre del ConfigMap de fluentd-gcp-config a fluentd-gcp-config-filtered, edita el campo configMap.name:

    - configMap:
        defaultMode: 420
        name: fluentd-gcp-config
      name: config-volume
  3. Implementa la versión nueva del ConfigMap en tu clúster:

    kubectl apply -f kubernetes/fluentd-configmap.yaml
    
  4. Implementa la versión nueva del daemonset:

    kubectl apply -f kubernetes/fluentd-daemonset.yaml
  5. Implementa la actualización y espera a que se complete:

    kubectl rollout status ds/fluentd-gcp-v3.2.0 --namespace=kube-system
    

    Resultado del comando que muestra mensajes de espera para 3 pods, luego indica la finalización correcta

  6. Cuando finalices el lanzamiento, actualiza los registros de Logging y verifica que se hayan filtrado los datos del número de identificación personal, el número de tarjeta de crédito y la dirección de correo electrónico.

    Lista de Logging en la que se muestran los mismos datos, pero filtrados

Registra eventos a nivel de nodo

Si quieres que los eventos que ocurren en los nodos de GKE también aparezcan en Logging, agrega las siguientes líneas al ConfigMap y sigue las instrucciones que se detallan en la última sección:

<source>
  type systemd
  filters [{ "SYSLOG_IDENTIFIER": "sshd" }]
  pos_file /var/log/journal/gcp-journald-ssh.pos
  read_from_head true
  tag sshd
</source>

<source>
  type systemd
  filters [{ "SYSLOG_IDENTIFIER": "sudo" }]
  pos_file /var/log/journal/gcp-journald-sudo.pos
  read_from_head true
  tag sudo
</source>

Realiza una limpieza

Una vez completado el instructivo, puedes limpiar los recursos creados en GCP para que no se te facture por ellos en el futuro.

Cómo borrar el proyecto

La manera más fácil de eliminar la facturación es borrar el proyecto que creaste para el instructivo.

Para borrar el proyecto, haz lo siguiente:

  1. En Cloud Console, ve a la página Administrar recursos.

    Ir a la página Administrar recursos

  2. En la lista de proyectos, selecciona el proyecto que deseas borrar y haz clic en Borrar .
  3. En el cuadro de diálogo, escribe el ID del proyecto y haz clic en Cerrar para borrar el proyecto.

Borra el clúster de GKE

Si no quieres borrar todo el proyecto, ejecuta el comando siguiente para borrar el clúster de GKE:

gcloud container clusters delete gke-with-custom-fluentd --zone us-east1-b

Próximos pasos