Fluent Bit Kubernetes Filter allows to enrich your log files with Kubernetes metadata.
When Fluent Bit is deployed in Kubernetes as a DaemonSet and configured to read the log files from the containers (using tail or systemd input plugins), this filter aims to perform the following operations:
Analyze the Tag and extract the following metadata:
Query Kubernetes API Server to obtain extra metadata for the POD in question:
The data is cached locally in memory and appended to each record.
The plugin supports the following configuration parameters:
Set the buffer size for HTTP client when reading responses from Kubernetes API server. The value must be according to the Unit Size specification. A value of
API Server end-point
CA certificate file
Absolute path to scan for certificate files
When the source records comes from Tail input plugin, this option allows to specify what's the prefix used in Tail configuration.
When enabled, it checks if the
Optional parser name to specify how to parse the data contained in the log key. Recommended use is for developers or testing only.
Debug level between 0 (nothing) and 4 (every detail).
When enabled, turns on certificate validation when connecting to the Kubernetes API server.
When enabled, the filter reads logs coming in Journald format.
When enabled, metadata will be fetched from K8s when docker_id is changed.
Set an alternative Parser to process record Tag and extract pod_name, namespace_name, container_name and docker_id. The parser must be registered in a parsers file (refer to parser filter-kube-test as an example).
Allow Kubernetes Pods to suggest a pre-defined Parser (read more about it in Kubernetes Annotations section)
Allow Kubernetes Pods to exclude their logs from the log processor (read more about it in Kubernetes Annotations section).
Include Kubernetes resource labels in the extra metadata.
Include Kubernetes resource annotations in the extra metadata.
If set, Kubernetes meta-data can be cached/pre-loaded from files in JSON format in this directory, named as namespace-pod.meta
If set, use dummy-meta data (for test/dev purposes)
DNS lookup retries N times until the network start working
DNS lookup interval between network status checks
this is an optional feature flag to get metadata information from kubelet instead of calling Kube Server API to enhance the log. This could mitigate the Kube API heavy traffic issue for large cluster.
kubelet port using for HTTP request, this only works when
Kubernetes Filter aims to provide several ways to process the data contained in the log key. The following explanation of the workflow assumes that your original Docker parser defined in parsers.conf is as follows:
[PARSER]Name dockerFormat jsonTime_Key timeTime_Format %Y-%m-%dT%H:%M:%S.%LTime_Keep On
Since Fluent Bit v1.2 we are not suggesting the use of decoders (Decode_Field_As) if you are using Elasticsearch database in the output to avoid data type conflicts.
To perform processing of the log key, it's mandatory to enable the Merge_Log configuration property in this filter, then the following processing order will be done:
If a Pod suggest a parser, the filter will use that parser to process the content of log.
If the option Merge_Parser was set and the Pod did not suggest a parser, process the log content using the suggested parser in the configuration.
If no Pod was suggested and no Merge_Parser is set, try to handle the content as JSON.
If log value processing fails, the value is untouched. The order above is not chained, meaning it's exclusive and the filter will try only one of the options above, not all of them.
A flexible feature of Fluent Bit Kubernetes filter is that allow Kubernetes Pods to suggest certain behaviors for the log processor pipeline when processing the records. At the moment it support:
Suggest a pre-defined parser
Request to exclude logs
The following annotations are available:
Suggest a pre-defined parser. The parser must be registered already by Fluent Bit. This option will only be processed if Fluent Bit configuration (Kubernetes Filter) have enabled the option K8S-Logging.Parser. If present, the stream (stdout or stderr) will restrict that specific stream. If present, the container can override a specific container in a Pod.
Request to Fluent Bit to exclude or not the logs generated by the Pod. This option will only be processed if Fluent Bit configuration (Kubernetes Filter) have enabled the option K8S-Logging.Exclude.
The following Pod definition runs a Pod that emits Apache logs to the standard output, in the Annotations it suggest that the data should be processed using the pre-defined parser called apache:
apiVersion: v1kind: Podmetadata:name: apache-logslabels:app: apache-logsannotations:fluentbit.io/parser: apachespec:containers:- name: apacheimage: edsiper/apache_logs
There are certain situations where the user would like to request that the log processor simply skip the logs from the Pod in question:
apiVersion: v1kind: Podmetadata:name: apache-logslabels:app: apache-logsannotations:fluentbit.io/exclude: "true"spec:containers:- name: apacheimage: edsiper/apache_logs
Note that the annotation value is boolean which can take a true or false and must be quoted.
Kubernetes Filter depends on either Tail or Systemd input plugins to process and enrich records with Kubernetes metadata. Here we will explain the workflow of Tail and how it configuration is correlated with Kubernetes filter. Consider the following configuration example (just for demo purposes, not production):
[INPUT]Name tailTag kube.*Path /var/log/containers/*.logParser docker[FILTER]Name kubernetesMatch kube.*Kube_URL https://kubernetes.default.svc:443Kube_CA_File /var/run/secrets/kubernetes.io/serviceaccount/ca.crtKube_Token_File /var/run/secrets/kubernetes.io/serviceaccount/tokenKube_Tag_Prefix kube.var.log.containers.Merge_Log OnMerge_Log_Key log_processed
In the input section, the Tail plugin will monitor all files ending in .log in path /var/log/containers/. For every file it will read every line and apply the docker parser. Then the records are emitted to the next step with an expanded tag.
Tail support Tags expansion, which means that if a tag have a star character (*), it will replace the value with the absolute path of the monitored file, so if you file name and path is:
then the Tag for every record of that file becomes:
note that slashes are replaced with dots.
When Kubernetes Filter runs, it will try to match all records that starts with kube. (note the ending dot), so records from the file mentioned above will hit the matching rule and the filter will try to enrich the records
Kubernetes Filter do not care from where the logs comes from, but it cares about the absolute name of the monitored file, because that information contains the pod name and namespace name that are used to retrieve associated metadata to the running Pod from the Kubernetes Master/API Server.
If you have large pod specifications (can be caused by large numbers of environment variables, etc.), be sure to increase the
Buffer_Sizeparameter of the kubernetes filter. If object sizes exceed this buffer, some metadata will fail to be injected to the logs.
If the configuration property Kube_Tag_Prefix was configured (available on Fluent Bit >= 1.1.x), it will use that value to remove the prefix that was appended to the Tag in the previous Input section. Note that the configuration property defaults to _kube._var.logs.containers. , so the previous Tag content will be transformed from:
the transformation above do not modify the original Tag, just creates a new representation for the filter to perform metadata lookup.
that new value is used by the filter to lookup the pod name and namespace, for that purpose it uses an internal Regular expression:
If you want to know more details, check the source code of that definition here.
You can see on Rublar.com web site how this operation is performed, check the following demo link:
Under certain and not common conditions, a user would want to alter that hard-coded regular expression, for that purpose the option Regex_Parser can be used (documented on top).
So at this point the filter is able to gather the values of pod_name and namespace, with that information it will check in the local cache (internal hash table) if some metadata for that key pair exists, if so, it will enrich the record with the metadata value, otherwise it will connect to the Kubernetes Master/API Server and retrieve that information.
There is an issue reported about kube-apiserver fall over and become unresponsive when cluster is too large and too many requests are sent to it. For this feature, fluent bit Kubernetes filter will send the request to kubelet /pods endpoint instead of kube-apiserver to retrieve the pods information and use it to enrich the log. Since Kubelet is running locally in nodes, the request would be responded faster and each node would only get one request one time. This could save kube-apiserver power to handle other requests. When this feature is enabled, you should see no difference in the kubernetes metadata added to logs, but the Kube-apiserver bottleneck should be avoided when cluster is large.
There are some configuration setup needed for this feature.
Role Configuration for Fluent Bit DaemonSet Example:
---apiVersion: v1kind: ServiceAccountmetadata:name: fluentbitdsnamespace: fluentbit-system---apiVersion: rbac.authorization.k8s.io/v1beta1kind: ClusterRolemetadata:name: fluentbitrules:- apiGroups: [""]resources:- namespaces- pods- nodes- nodes/proxyverbs:- get- list- watch---apiVersion: rbac.authorization.k8s.io/v1beta1kind: ClusterRoleBindingmetadata:name: fluentbitroleRef:apiGroup: rbac.authorization.k8s.iokind: ClusterRolename: fluentbitsubjects:- kind: ServiceAccountname: fluentbitdsnamespace: fluentbit-system
The difference is that kubelet need a special permission for resource
nodes/proxy to get HTTP request in. When creating the
clusterRole, you need to add
nodes/proxy into the rule for resource.
Fluent Bit Configuration Example:
[INPUT]Name tailTag kube.*Path /var/log/containers/*.logDB /var/log/flb_kube.dbParser dockerDocker_Mode OnMem_Buf_Limit 50MBSkip_Long_Lines OnRefresh_Interval 10[FILTER]Name kubernetesMatch kube.*Kube_URL https://kubernetes.default.svc.cluster.local:443Kube_CA_File /var/run/secrets/kubernetes.io/serviceaccount/ca.crtKube_Token_File /var/run/secrets/kubernetes.io/serviceaccount/tokenMerge_Log OnBuffer_Size 0Use_Kubelet trueKubelet_Port 10250
So for fluent bit configuration, you need to set the
Use_Kubelet to true to enable this feature.
DaemonSet config Example:
---apiVersion: apps/v1kind: DaemonSetmetadata:name: fluentbitnamespace: fluentbit-systemlabels:app.kubernetes.io/name: fluentbitspec:selector:matchLabels:name: fluentbittemplate:metadata:labels:name: fluentbitspec:serviceAccountName: fluentbitdscontainers:- name: fluent-bitimagePullPolicy: Alwaysimage: fluent/fluent-bit:latestvolumeMounts:- name: varlogmountPath: /var/log- name: varlibdockercontainersmountPath: /var/lib/docker/containersreadOnly: true- name: fluentbit-configmountPath: /fluent-bit/etc/resources:limits:memory: 1500Mirequests:cpu: 500mmemory: 500MihostNetwork: truednsPolicy: ClusterFirstWithHostNetvolumes:- name: varloghostPath:path: /var/log- name: varlibdockercontainershostPath:path: /var/lib/docker/containers- name: fluentbit-configconfigMap:name: fluentbit-config
The key point is to set
ClusterFirstWithHostNet that fluent bit DaemonSet could call Kubelet locally. Otherwise it could not resolve the dns for kubelet.
Now you are good to use this new feature!
Basically you should see no difference about your experience for enriching your log files with Kubernetes metadata.
To check if Fluent Bit is using the kubelet, you can check fluent bit logs and there should be a log like this:
[ info] [filter:kubernetes:kubernetes.0] testing connectivity with Kubelet...
And if you are in debug mode, you could see more:
[debug] [filter:kubernetes:kubernetes.0] Send out request to Kubelet for pods information.[debug] [filter:kubernetes:kubernetes.0] Request (ns=<namespace>, pod=node name) http_do=0, HTTP Status: 200[ info] [filter:kubernetes:kubernetes.0] connectivity OK[2021/02/05 10:33:35] [debug] [filter:kubernetes:kubernetes.0] Request (ns=<Namespace>, pod=<podName>) http_do=0, HTTP Status: 200[2021/02/05 10:33:35] [debug] [filter:kubernetes:kubernetes.0] kubelet find pod: <podName> and ns: <Namespace> match
The following section goes over specific log messages you may run into and how to solve them to ensure that Fluent Bit's Kubernetes filter is operating properly
If you are not seeing metadata added to your kubernetes logs and see the following in your log message, then you may be facing connectivity issues with the Kubernetes API server.
[2020/10/15 03:48:57] [ info] [filter_kube] testing connectivity with API server...[2020/10/15 03:48:57] [error] [filter_kube] upstream connection error[2020/10/15 03:48:57] [ warn] [filter_kube] could not get meta for POD
Potential fix #1: Check Kubernetes roles
When Fluent Bit is deployed as a DaemonSet it generally runs with specific roles that allow the application to talk to the Kubernetes API server. If you are deployed in a more restricted environment check that all the Kubernetes roles are set correctly.
Potential fix #2: Check Kubernetes IPv6
There may be cases where you have IPv6 on in the environment and you need to enable this within Fluent Bit. Under the service tag please set the following option
Potential fix #3: Check connectivity to Kube_URL
By default the Kube_URL is set to
https://kubernetes.default.svc:443 . Ensure that you have connectivity to this endpoint from within the cluster and that there are no special permission interfering with the connection.
In some cases, you may only see some objects being appended with metadata while other objects are not enriched. This can occur at times when local data is cached and does not contain the correct id for the kubernetes object that requires enrichment. For most Kubernetes objects the Kubernetes API server is updated which will then be reflected in Fluent Bit logs, however in some cases for
Pod objects this refresh to the Kubernetes API server can be skipped, causing metadata to be skipped.