Fluent Bit con Dynatrace: enviar los logs de Kubernetes paso a paso

Fluent Bit con Dynatrace: despliega el DaemonSet con Helm, enriquece los logs de Kubernetes, envíalos a la API de ingesta y comprueba su llegada con DQL.
Fluent Bit Dynatrace : envoyer les logs Kubernetes pas à pas

Tu plataforma Kubernetes ya recoge sus logs con Fluent Bit y el equipo no quiere cambiar de agente para adoptar Dynatrace. Buena noticia: usar Fluent Bit con Dynatrace funciona sin ningún plugin específico, con la salida HTTP estándar y la API de ingesta de logs.

Eso sí, los logs tienen que llegar enriquecidos. Una línea sin namespace, sin pod ni clúster es casi inútil durante una guardia (on-call): no se puede vincular a la entidad de Kubernetes ni a la traza que la produjo, y el MTTR se alarga en la misma medida.

Objetivo de este tutorial: desplegar Fluent Bit como DaemonSet con Helm, renombrar los metadatos de Kubernetes en los campos que espera Dynatrace, enviar los logs a la API v2 y comprobar su llegada con DQL. El contenido vale para Dynatrace SaaS y Dynatrace Managed; solo cambia la URL de ingesta.

Fluent Bit con Dynatrace u OneAgent: cuál elegir

Si el Dynatrace Operator ya está en marcha con la recogida de logs, no hay motivo para añadir Fluent Bit. Fluent Bit tiene sentido cuando ya es el estándar del equipo, cuando una parte de los logs va también a otra herramienta, o en clústeres donde no se despliega OneAgent. Para el marco general, consulta el módulo sobre logs y OpenPipeline.

Requisitos previos

  • Un clúster de Kubernetes con runtime containerd o CRI-O (formato de log CRI), kubectl y Helm 3.
  • Un token de API de Dynatrace con el scope logs.ingest (Ingest logs), y nada más.
  • La URL de ingesta: https://<env-id>.live.dynatrace.com/api/v2/logs/ingest en SaaS, https://<dominio>/e/<env-id>/api/v2/logs/ingest en Managed (o a través de un ActiveGate).
  • Acceso de lectura a los logs en Dynatrace para la verificación.

Paso 1: guardar el token en un secreto

No pongas nunca el token en claro en un archivo de valores versionado. Crea un namespace y un secreto:

kubectl create namespace logging
kubectl -n logging create secret generic dynatrace-logs \
  --from-literal=DT_INGEST_TOKEN="$DT_INGEST_TOKEN" \
  --from-literal=DT_INGEST_HOST="abc12345.live.dynatrace.com"

En Managed, DT_INGEST_HOST recibe tu dominio y la ruta /e/<env-id> irá en el URI de la salida (paso 3). Para los errores 401 y 403 habituales, ten a mano la resolución de problemas de los tokens de API.

Paso 2: leer los logs de los contenedores y añadir el contexto de Kubernetes

Crea un archivo values-dynatrace.yaml para el chart oficial fluent/fluent-bit. La entrada lee los archivos de logs de los contenedores; el filtro kubernetes añade namespace, pod y contenedor; el filtro modify renombra esos campos según la convención k8s.*.

envFrom:
  - secretRef:
      name: dynatrace-logs
env:
  - name: K8S_CLUSTER_NAME
    value: "prod-eu-1"

podAnnotations:
  dynatrace.com/inject: "false"

config:
  inputs: |
    [INPUT]
        Name              tail
        Tag               kube.*
        Path              /var/log/containers/*.log
        multiline.parser  cri
        DB                /var/log/flb_kube.db
        Mem_Buf_Limit     20MB
        Skip_Long_Lines   On

  filters: |
    [FILTER]
        Name         kubernetes
        Match        kube.*
        Merge_Log    On
        Keep_Log     Off
        Labels       Off
        Annotations  Off

    [FILTER]
        Name           nest
        Match          kube.*
        Operation      lift
        Nested_under   kubernetes
        Add_prefix     k_

    [FILTER]
        Name     modify
        Match    kube.*
        Rename   log               content
        Rename   k_namespace_name  k8s.namespace.name
        Rename   k_pod_name        k8s.pod.name
        Rename   k_pod_id          k8s.pod.uid
        Rename   k_container_name  k8s.container.name
        Rename   k_host            k8s.node.name
        Add      k8s.cluster.name  ${K8S_CLUSTER_NAME}
        Remove_wildcard k_

Líneas críticas: multiline.parser cri vuelve a unir las líneas cortadas por el runtime; Rename log content coloca el mensaje en el campo que Dynatrace muestra como contenido; la anotación dynatrace.com/inject: "false" evita que el Operator instrumente al propio Fluent Bit. Si tus aplicaciones escriben JSON, Merge_Log On sube sus claves al primer nivel: comprueba que ninguna se llame ya content.

Paso 3: configurar la salida HTTP hacia Dynatrace

Añade la salida al mismo archivo:

  outputs: |
    [OUTPUT]
        Name              http
        Match             kube.*
        Host              ${DT_INGEST_HOST}
        Port              443
        URI               /api/v2/logs/ingest
        Format            json
        json_date_key     timestamp
        json_date_format  iso8601
        Header            Authorization Api-Token ${DT_INGEST_TOKEN}
        Header            Content-Type application/json; charset=utf-8
        allow_duplicated_headers false
        tls               On
        tls.verify        On
        Retry_Limit       5

Format json envía un array de registros, que es lo que espera la API; json_date_key timestamp da a cada log su marca de tiempo original. En Managed, sustituye el URI por /e/<env-id>/api/v2/logs/ingest. Retry_Limit acota los reintentos en caso de indisponibilidad: pasado ese límite, los lotes se descartan, algo que debe verse en las métricas (paso de verificación).

Paso 4: desplegar con Helm

helm repo add fluent https://fluent.github.io/helm-charts
helm repo update
helm upgrade --install fluent-bit fluent/fluent-bit \
  -n logging -f values-dynatrace.yaml
kubectl -n logging rollout status daemonset/fluent-bit

Un pod por nodo debe pasar al estado Running.

Cómo comprobar que funciona

  1. En los logs de Fluent Bit, ninguna línea [error] relacionada con la salida HTTP: kubectl -n logging logs ds/fluent-bit | grep -iE "error|http_status". Un estado 204 o 200 significa que el lote se ha aceptado; un 401 o 403 remite al token.
  2. En Dynatrace (SaaS con Grail), lanza:
    fetch logs, from: -15m
    | filter k8s.cluster.name == "prod-eu-1"
    | summarize lignes = count(), by: { k8s.namespace.name }
    | sort lignes desc

    Cada namespace activo debe aparecer. En Managed, usa el visor de logs y filtra por el mismo atributo.

  3. Expón las métricas internas de Fluent Bit (puerto 2020, ruta /api/v1/metrics/prometheus) y vigila los contadores de reintentos y de descartes de la salida: un descarte distinto de cero significa logs perdidos.

Buenas prácticas

  • Filtra lo antes posible: un filtro grep sobre los namespaces habladores cuesta menos que un procesamiento tras la ingesta.
  • Da un SLO a la propia cadena de logs (proporción de lotes aceptados) y alerta sobre el silencio, como en detectar el silencio y los excesos de volumen.
  • Añade trace_id y span_id en los logs de la aplicación para correlacionarlos con las trazas (consulta vincular logs y trazas).
  • Activa el almacenamiento en búfer en disco (storage.type filesystem) si es plausible un corte de red de varios minutos.
  • Rota el token y límitalo al único scope logs.ingest.

Preguntas frecuentes

¿Hace falta un ActiveGate entre Fluent Bit y Dynatrace?

No en SaaS: Fluent Bit puede enviar directamente al entorno. Un ActiveGate de entorno sigue siendo útil si el clúster no tiene acceso saliente a Internet o, en Managed, para concentrar los flujos; el URI sigue entonces el formato del ActiveGate.

¿Por qué mis logs llegan sin la marca de tiempo correcta?

Comprueba json_date_key y json_date_format: sin ellos, Dynatrace usa la hora de recepción. Un desfase de varios minutos falsea las correlaciones durante un incidente.

¿Puedo mantener Fluent Bit y OneAgent en el mismo clúster?

Sí, pero no actives la recogida de los mismos archivos en ambos lados: pagarías dos veces los mismos logs. Reparte por namespace o desactiva la recogida de logs en uno de los dos.

Conclusión

Con una salida HTTP, un secreto, un renombrado de los campos k8s.* y una consulta DQL de control, Fluent Bit alimenta Dynatrace sin cambiar de agente. Añade la monitorización de la propia cadena y tus logs de Kubernetes se convertirán en una fuente fiable para el diagnóstico.

span.observer es un blog independiente de la comunidad, no afiliado a Dynatrace LLC. Dynatrace es una marca de su propietario. Las opciones y los campos evolucionan: compruébalos en la documentación de Fluent Bit y en la de Dynatrace.

Total
0
Shares
Leave a Reply

Your email address will not be published. Required fields are marked *

Previous Post
Datadog vs Dynatrace ? Un comparatif Dynatrace vs Datadog concret pour une équipe SRE

¿Datadog vs Dynatrace? Una comparativa Dynatrace vs Datadog concreta para un equipo SRE

Next Post
Istio Dynatrace : superviser le service mesh avec Dynatrace (Istio, traces et métriques)

Istio Dynatrace: monitorizar el service mesh con Dynatrace (Istio, trazas y métricas)

Related Posts