Personaliza registros de Cloud Logging para Google Kubernetes Engine con Fluentd

Last reviewed 2022-10-03 UTC

---

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.

Nota: Este instructivo es para el agente de Logging heredado basado en Fluentd. Para personalizar el agente de operaciones basado en Fluent Bit en máquinas virtuales, consulta Configura el agente de operaciones. Para personalizar Fluent Bit en GKE, consulta Personaliza fluentbit.

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 componentes facturables de Google Cloud, que incluyen lo siguiente:

• Un clúster de tres nodos de Google Kubernetes Engine

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 Cloud. Si eres nuevo en Google Cloud, crea una cuenta para evaluar el rendimiento de nuestros productos en situaciones reales. Los clientes nuevos también obtienen $300 en créditos gratuitos para ejecutar, probar y, además, implementar cargas de trabajo.

2. En la página del selector de proyectos de la consola de Google Cloud, selecciona o crea un proyecto de Google Cloud.

   Nota: Si no planeas conservar los recursos que creaste durante este procedimiento, crea un proyecto en lugar de seleccionar uno existente. Cuando termines, puedes borrar el proyecto y quitar todos los recursos asociados con él.

   Ir al selector de proyectos

3. Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud.

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

   Habilita las API

5. En la página del selector de proyectos de la consola de Google Cloud, selecciona o crea un proyecto de Google Cloud.

   Nota: Si no planeas conservar los recursos que creaste durante este procedimiento, crea un proyecto en lugar de seleccionar uno existente. Cuando termines, puedes borrar el proyecto y quitar todos los recursos asociados con él.

   Ir al selector de proyectos

6. Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud.

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

   export region=us-east1
   export zone=${region}-b
   export project_id=[YOUR_PROJECT_ID]
   

2. Dirígete a Cloud Shell.

   Abra 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

1. En Cloud Shell, clona el repositorio de muestra:

   git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-customize-fluentd
   

   El repositorio de muestra incluye los manifiestos de Kubernetes para el daemonset de Fluentd y un programa de prueba de registro que implementarás más adelante en este instructivo.

2. Cambia tu directorio de trabajo al repositorio clonado:

   cd kubernetes-engine-customize-fluentd
   

3. Crea el clúster de GKE solo con el registro y la supervisión del sistema:

   gcloud container clusters create gke-with-custom-fluentd \
      --zone us-east1-b \
      --logging=SYSTEM \
      --tags=gke-cluster-with-customized-fluentd \
      --scopes=logging-write,storage-rw
   

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 se compila a partir del código fuente en el subdirectorio test-logger.

1. En Cloud Shell, compila la imagen de contenedor test-logger:

   docker build -t test-logger test-logger
   

2. Etiqueta el contenedor antes de enviarlo al registro:

   docker tag test-logger gcr.io/${project_id}/test-logger
   

3. Envía la imagen del contenedor:

   docker push gcr.io/${project_id}/test-logger
   

4. Actualiza el archivo de implementación:

   envsubst < kubernetes/test-logger.yaml > kubernetes/test-logger-deploy.yaml
   

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

   kubectl apply -f kubernetes/test-logger-deploy.yaml
   

6. Ver el estado de los pods test-logger:

   kubectl get pods
   

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

   

Implementa el daemonset de Fluentd en tu clúster

A continuación, configura y, luego, implementa tu daemonset de Fluentd.

Nota: Debido a que activaste el registro solo del sistema, se implementó un daemonset de Fluentd administrado por GKE que es responsable de los registros del sistema. Los manifiestos de Kubernetes para Fluentd que debes implementar en este procedimiento son versiones modificadas de aquellos disponibles en el daemonset de Fluentd para el repositorio de Kubernetes en GitHub.

1. En Cloud Shell, 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:

   

4. Verifica que veas registros en Logging. En la consola, en el lado izquierdo, selecciona Logging > Explorador de registros y, luego, Contenedor de Kubernetes como un tipo de recurso en la lista de Recursos.

5. Haga clic en Ejecutar consulta.

6. En el Explorador de campos de registros, selecciona test-logger para CONTAINER_NAME:

   

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,"[e-mail]")}
   #   </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. Guarde y cierre el archivo.

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 --namespace=kube-system
   

   

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.

   

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>

Nota: Durante una actualización del clúster, es normal que el uso de CPU en Fluentd se aumente cuando haya una mayor cantidad de registros en un nodo. Fluentd intenta procesar todos los registros lo más rápido posible y enviarlos a su destino (API de Cloud Logging). Cualquier aumento significativo en los registros generados puede hacer que el uso de CPU aumente hasta el límite del Pod. Establecemos este límite para asegurarnos de que no consuma todos los recursos disponibles del nodo.

Limpia

Una vez que hayas terminado el instructivo, puedes limpiar los recursos que creaste en Google Cloud para que no se te cobre por ellos en el futuro.

Borra 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, sigue estos pasos:

Precaución: Borrar un proyecto tiene estas consecuencias:

• Se borra todo en el proyecto. Si usaste un proyecto existente para las tareas de este documento, cuando lo borres, también se borrará cualquier otro trabajo que hayas realizado en el proyecto.
• Se pierden los ID personalizados de proyectos. Cuando creaste este proyecto, es posible que hayas creado un ID del proyecto personalizado que desees utilizar en el futuro. Para conservar las URL que utilizan el ID del proyecto, como una URL appspot.com, borra los recursos seleccionados dentro del proyecto en lugar de borrar todo el proyecto.

Si planeas explorar varias infraestructuras, instructivos y guías de inicio rápido la reutilización de proyectos puede ayudarte a evitar exceder los límites de las cuotas del proyecto.

1. En la consola de Google Cloud, ve a la página Administrar recursos.

   Ir a Administrar recursos

2. En la lista de proyectos, elige el proyecto que quieres borrar y haz clic en Borrar.
3. En el diálogo, escribe el ID del proyecto y, luego, 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

¿Qué sigue?

• Revisa con más detenimiento la documentación de Fluentd.
• Revisa con más detenimiento la documentación de Google Kubernetes Engine.
• Explora arquitecturas de referencia, diagramas y prácticas recomendadas sobre Google Cloud. Consulta nuestro Cloud Architecture Center.