kubernetes部署EFK（k8s）

精神世界 發表於 2022-5-15 18:13:00

Kubernetes 中比较流行的日志收集解决方案是 <code>Elasticsearch</code>、<code>Fluentd</code> 和 <code>Kibana</code>（EFK）技术栈，也是官方现在比较推荐的一种方案。
<code>Elasticsearch</code> 是一个实时的、分布式的可扩展的搜索引擎，允许进行全文、结构化搜索，它通常用于索引和搜索大量日志数据，也可用于搜索许多不同类型的文档。
Elasticsearch 通常与 <code>Kibana</code> 一起部署，Kibana 是 Elasticsearch 的一个功能强大的数据可视化 Dashboard，Kibana 允许你通过 web 界面来浏览 Elasticsearch 日志数据。
<code>Fluentd</code>是一个流行的开源数据收集器，我们将在 Kubernetes 集群节点上安装 Fluentd，通过获取容器日志文件、过滤和转换日志数据，然后将数据传递到 Elasticsearch 集群，在该集群中对其进行索引和存储。
我们先来配置启动一个可扩展的 Elasticsearch 集群，然后在 Kubernetes 集群中创建一个 Kibana 应用，最后通过 DaemonSet 来运行 Fluentd，以便它在每个 Kubernetes 工作节点上都可以运行一个 Pod。
1、创建 Elasticsearch 集群
在创建 Elasticsearch 集群之前，我们先创建一个命名空间，我们将在其中安装所有日志相关的资源对象。
新建一个 kube-logging.yaml 文件
<div class="cnblogs_code">
<pre>vim kube-logging.yaml
apiVersion: v1
kind: Namespace
metadata:
name: logging </pre>
<pre>$ kubectl create -f kube-logging.yaml
namespace/logging created
$ kubectl get ns
NAME STATUS AGE
default Active 244d
istio-system Active 100d
kube-ops Active 179d
kube-public Active 244d
kube-system Active 244d
logging Active 4h
monitoring Active 35d</pre>
</div>
现在创建了一个命名空间来存放我们的日志相关资源，接下来可以部署 EFK 相关组件，首先开始部署一个3节点的 Elasticsearch 集群。
一个关键点是我们应该设置参数<code>discover.zen.minimum_master_nodes=N/2+1</code>，其中<code>N</code>是 Elasticsearch 集群中符合主节点的节点数，比如我们这里3个节点，意味着<code>N</code>应该设置为2。这样，如果一个节点暂时与集群断开连接，则另外两个节点可以选择一个新的主节点，并且集群可以在最后一个节点尝试重新加入时继续运行，在扩展 Elasticsearch 集群时，一定要记住这个参数。
首先创建一个名为 elasticsearch 的无头服务，新建文件 elasticsearch-svc.yaml，文件内容如下
<div class="cnblogs_code">
<pre>kind: Service
apiVersion: v1
metadata:
name: elasticsearch
namespace: logging
labels:
app: elasticsearch
spec:
selector:
app: elasticsearch
clusterIP: None
ports:
- port: 9200
 name: rest
- port: 9300
 name: inter-node

$ kubectl create -f elasticsearch-svc.yaml
service/elasticsearch created
$ kubectl get services --namespace=logging
Output
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
elasticsearch ClusterIP None <none> 9200/TCP,9300/TCP 26s</pre>
</div>
定义了一个名为 elasticsearch 的 Service，指定标签 <code>app=elasticsearch</code>，当我们将 Elasticsearch StatefulSet 与此服务关联时，服务将返回带有标签 <code>app=elasticsearch</code>的 Elasticsearch Pods 的 DNS A 记录，然后设置 <code>clusterIP=None</code>，将该服务设置成无头服务。最后，我们分别定义端口9200、9300，分别用于与 REST API 交互，以及用于节点间通信。
现在我们已经为 Pod 设置了无头服务和一个稳定的域名<code>.elasticsearch.logging.svc.cluster.local</code>，接下来我们通过 StatefulSet 来创建具体的 Elasticsearch 的 Pod 应用。
Kubernetes StatefulSet 允许我们为 Pod 分配一个稳定的标识和持久化存储，Elasticsearch 需要稳定的存储来保证 Pod 在重新调度或者重启后的数据依然不变，所以需要使用 StatefulSet 来管理 Pod。
新建名为 elasticsearch-statefulset.yaml 的资源清单文件，首先粘贴下面内容：
<div class="cnblogs_code">
<pre>apiVersion: apps/v1
kind: StatefulSet
metadata:
name: es
namespace: logging
spec:
serviceName: elasticsearch
replicas: 3
selector:
matchLabels:
 app: elasticsearch
template:
metadata:
 labels:
 app: elasticsearch
spec:
 nodeSelector:
 es: log
 initContainers:
 - name: increase-vm-max-map
 image: busybox
 command: ["sysctl", "-w", "vm.max_map_count=262144"]
 securityContext:
 privileged: true
 - name: increase-fd-ulimit
 image: busybox
 command: ["sh", "-c", "ulimit -n 65536"]
 securityContext:
 privileged: true
 containers:
 - name: elasticsearch
 image: docker.elastic.co/elasticsearch/elasticsearch:7.6.2
 ports:
 - name: rest
 containerPort: 9200
 - name: inter
 containerPort: 9300
 resources:
 limits:
 cpu: 1000m
 requests:
 cpu: 1000m
 volumeMounts:
 - name: data
 mountPath: /usr/share/elasticsearch/data
 env:
 - name: cluster.name
 value: k8s-logs
 - name: node.name
 valueFrom:
 fieldRef:
 fieldPath: metadata.name
 - name: cluster.initial_master_nodes
 value: "es-0,es-1,es-2"
 - name: discovery.zen.minimum_master_nodes
 value: "2"
 - name: discovery.seed_hosts
 value: "elasticsearch"
 - name: ES_JAVA_OPTS
 value: "-Xms512m -Xmx512m"
 - name: network.host
 value: "0.0.0.0"
volumeClaimTemplates:
- metadata:
 name: data
 labels:
 app: elasticsearch
spec:
 accessModes: [ "ReadWriteOnce" ]
 storageClassName: rook-ceph-block
 resources:
 requests:
 storage: 50Gi
$ kubectl create -f elasticsearch-statefulset.yaml
statefulset.apps/es created
$ kubectl get sts -n logging
NAME READY AGE
es 3/3 83m
$ kubectl get pods -n logging
NAME READY STATUS RESTARTS AGE
es-0 1/1 Running 0 83m
es-1 1/1 Running 0 82m
es-2 1/1 Running 0 81m
$ kubectl get svc -n logging
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
elasticsearch ClusterIP None <none> 9200/TCP,9300/TCP 20h</pre>
</div>
该部分是定义 StatefulSet 中的 Pod，暴露了9200和9300两个端口，注意名称要和上面定义的 Service 保持一致。然后通过 volumeMount 声明了数据持久化目录，下面我们再来定义 VolumeClaims。最后就是我们在容器中设置的一些环境变量了：
<ul>
<li>cluster.name：Elasticsearch 集群的名称，我们这里命名成 k8s-logs。</li>
<li>node.name：节点的名称，通过 <code>metadata.name</code> 来获取。这将解析为 es-，取决于节点的指定顺序。</li>
<li>discovery.seed_hosts：此字段用于设置在 Elasticsearch 集群中节点相互连接的发现方法。由于我们之前配置的无头服务，我们的 Pod 具有唯一的 DNS 域<code>es-.elasticsearch.logging.svc.cluster.local</code>，因此我们相应地设置此变量。要了解有关 Elasticsearch 发现的更多信息，请参阅 Elasticsearch 官方文档：https://www.elastic.co/guide/en/elasticsearch/reference/current/modules-discovery.html。</li>
<li>discovery.zen.minimum_master_nodes：我们将其设置为<code>(N/2) + 1</code>，<code>N</code>是我们的群集中符合主节点的节点的数量。我们有3个 Elasticsearch 节点，因此我们将此值设置为2（向下舍入到最接近的整数）。要了解有关此参数的更多信息，请参阅官方 Elasticsearch 文档：https://www.elastic.co/guide/en/elasticsearch/reference/current/modules-node.html#split-brain。</li>
<li>ES_JAVA_OPTS：这里我们设置为<code>-Xms512m -Xmx512m</code>，告诉<code>JVM</code>使用<code>512 MB</code>的最小和最大堆。您应该根据群集的资源可用性和需求调整这些参数。要了解更多信息，请参阅设置堆大小的相关文档：https://www.elastic.co/guide/en/elasticsearch/reference/current/heap-size.html。</li>
</ul>
这里我们定义了几个在主应用程序之前运行的 Init 容器，这些初始容器按照定义的顺序依次执行，执行完成后才会启动主应用容器。
第一个名为 increase-vm-max-map 的容器用来增加操作系统对<code>mmap</code>计数的限制，默认情况下该值可能太低，导致内存不足的错误，要了解更多关于该设置的信息，可以查看 Elasticsearch 官方文档说明：https://www.elastic.co/guide/en/elasticsearch/reference/current/vm-max-map-count.html。
最后一个初始化容器是用来执行<code>ulimit</code>命令增加打开文件描述符的最大数量的。
<blockquote>此外 Elastisearch Notes for Production Use 文档还提到了由于性能原因最好禁用 swap，当然对于 Kubernetes 集群而言，最好也是禁用 swap 分区的。</blockquote>
我们这里使用 volumeClaimTemplates 来定义持久化模板，Kubernetes 会使用它为 Pod 创建 PersistentVolume，设置访问模式为<code>ReadWriteOnce</code>，这意味着它只能被 mount 到单个节点上进行读写，然后最重要的是使用了一个 StorageClass 对象，这里我们就直接使用前面创建的 NFS 类型 的 StorageClass 对象即可。最后，我们指定了每个 PersistentVolume 的大小为 50GB，我们可以根据自己的实际需要进行调整该值。
Pods 部署完成后，我们可以通过请求一个 REST API 来检查 Elasticsearch 集群是否正常运行。使用下面的命令将本地端口9200 转发到 Elasticsearch 节点（如es-0）对应的端口：
<div class="cnblogs_code">
<pre>$ kubectl port-forward es-0 9200:9200 --namespace=logging
Forwarding from 127.0.0.1:9200 -> 9200
Forwarding from [::1]:9200 -> 9200 </pre>
 #然后，在另外的终端窗口中，执行如下请求：
<pre>curl http://localhost:9200/_cluster/state?pretty</pre>
<pre>#当然也可不用这个方式直接进入到容器内执行</pre>
</div>
看到上面的信息就表明我们名为 k8s-logs 的 Elasticsearch 集群成功创建了3个节点：es-0，es-1，和es-2，当前主节点是 es-0。
2、创建 Kibana 服务
Elasticsearch 集群启动成功了，接下来我们可以来部署 Kibana 服务，新建一个名为 kibana.yaml 的文件，对应的文件内容如下：
<div class="cnblogs_code">
<pre>apiVersion: v1
kind: Service
metadata:
name: kibana
namespace: logging
labels:
app: kibana
spec:
ports:
- port: 5601
type: NodePort
selector:
app: kibana

---
apiVersion: apps/v1
kind: Deployment
metadata:
name: kibana
namespace: logging
labels:
app: kibana
spec:
selector:
matchLabels:
 app: kibana
template:
metadata:
 labels:
 app: kibana
spec:
 nodeSelector:
 es: log
 containers:
 - name: kibana
 image: docker.elastic.co/kibana/kibana:7.6.2
 resources:
 limits:
 cpu: 1000m
 requests:
 cpu: 1000m
 env:
 - name: ELASTICSEARCH_HOSTS
 value: http://elasticsearch:9200
 ports:
 - containerPort: 5601

$ kubectl create -f kibana.yaml
service/kibana created
deployment.apps/kibana created

$ kubectl get pods --namespace=logging
NAME READY STATUS RESTARTS AGE
es-0 1/1 Running 0 85m
es-1 1/1 Running 0 84m
es-2 1/1 Running 0 83m
kibana-5c565c47dd-xj4bd 1/1 Running 0 80m
$ kubectl get svc -n logging
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
elasticsearch ClusterIP None <none> 9200/TCP,9300/TCP 3h22m
kibana NodePort 10.111.223.99 <none> 5601:31139/TCP 3h20m</pre>
</div>
上面我们定义了两个资源对象，一个 Service 和 Deployment，为了测试方便，我们将 Service 设置为了 NodePort 类型，Kibana Pod 中配置都比较简单，唯一需要注意的是我们使用 <code>ELASTICSEARCH_HOSTS</code> 这个环境变量来设置Elasticsearch 集群的端点和端口，直接使用 Kubernetes DNS 即可，此端点对应服务名称为 elasticsearch，由于是一个 headless service，所以该域将解析为3个 Elasticsearch Pod 的 IP 地址列表。
如果 Pod 已经是 Running 状态了，证明应用已经部署成功了，然后可以通过 NodePort 来访问 Kibana 这个服务，在浏览器中打开<code>http://<任意节点IP>:31139</code>即可，如有部署了ingress-control也可以通过部署ingress进行访问。看到如下欢迎界面证明 Kibana 已经成功部署到了 Kubernetes集群之中。
3、部署 Fluentd
<code>Fluentd</code> 是一个高效的日志聚合器，是用 Ruby 编写的，并且可以很好地扩展。对于大部分企业来说，Fluentd 足够高效并且消耗的资源相对较少，另外一个工具<code>Fluent-bit</code>更轻量级，占用资源更少，但是插件相对 Fluentd 来说不够丰富，所以整体来说，Fluentd 更加成熟，使用更加广泛，所以我们这里也同样使用 Fluentd 来作为日志收集工具。
<h3 id="header-230a-6493" data-fold="unfold">工作原理</h3>
Fluentd 通过一组给定的数据源抓取日志数据，处理后（转换成结构化的数据格式）将它们转发给其他服务，比如 Elasticsearch、对象存储等等。Fluentd 支持超过300个日志存储和分析服务，所以在这方面是非常灵活的。主要运行步骤如下：
<ul>
<li>首先 Fluentd 从多个日志源获取数据</li>
<li>结构化并且标记这些数据</li>
<li>然后根据匹配的标签将数据发送到多个目标服务去</li>
<li><img src="https://img2022.cnblogs.com/blog/2636555/202205/2636555-20220515175719417-496790112.png" alt="" loading="lazy"></li>
</ul>
<h3 id="header-f0e9-57eb" data-fold="unfold">配置</h3>
一般来说我们是通过一个配置文件来告诉 Fluentd 如何采集、处理数据的，下面简单和大家介绍下 Fluentd 的配置方法。
日志源配置
比如我们这里为了收集 Kubernetes 节点上的所有容器日志，就需要做如下的日志源配置
<div class="cnblogs_code">
<pre><source>
@id fluentd-containers.log
@type tail # Fluentd 内置的输入方式，其原理是不停地从源文件中获取新的日志。
path /var/log/containers/*.log # 挂载的服务器Docker容器日志地址
pos_file /var/log/es-containers.log.pos
tag raw.kubernetes.* # 设置日志标签
read_from_head true
<parse> # 多行格式化成JSON
@type multi_format # 使用 multi-format-parser 解析器插件
<pattern>
 format json # JSON 解析器
 time_key time # 指定事件时间的时间字段
 time_format %Y-%m-%dT%H:%M:%S.%NZ# 时间格式
</pattern>
<pattern>
 format /^(?<time>.+) (?<stream>stdout|stderr) [^ ]* (?<log>.*)$/
 time_format %Y-%m-%dT%H:%M:%S.%N%:z
</pattern>
</parse>
</source></pre>
</div>
上面配置部分参数说明如下：
<ul>
<li>id：表示引用该日志源的唯一标识符，该标识可用于进一步过滤和路由结构化日志数据</li>
<li>type：Fluentd 内置的指令，<code>tail</code> 表示 Fluentd 从上次读取的位置通过 tail 不断获取数据，另外一个是 <code>http</code> 表示通过一个 GET 请求来收集数据。</li>
<li>path：<code>tail</code> 类型下的特定参数，告诉 Fluentd 采集 <code>/var/log/containers</code> 目录下的所有日志，这是 docker 在 Kubernetes 节点上用来存储运行容器 stdout 输出日志数据的目录。</li>
<li>pos_file：检查点，如果 Fluentd 程序重新启动了，它将使用此文件中的位置来恢复日志数据收集。</li>
<li>tag：用来将日志源与目标或者过滤器匹配的自定义字符串，Fluentd 匹配源/目标标签来路由日志数据。</li>
</ul>
路由配置
上面是日志源的配置，接下来看看如何将日志数据发送到 Elasticsearch：
<div class="cnblogs_code">
<pre><match **>
@id elasticsearch
@type elasticsearch
@log_level info
include_tag_key true
type_name fluentd
host "#{ENV['OUTPUT_HOST']}"
port "#{ENV['OUTPUT_PORT']}"
logstash_format true
<buffer>
@type file
path /var/log/fluentd-buffers/kubernetes.system.buffer
flush_mode interval
retry_type exponential_backoff
flush_thread_count 2
flush_interval 5s
retry_forever
retry_max_interval 30
chunk_limit_size "#{ENV['OUTPUT_BUFFER_CHUNK_LIMIT']}"
queue_limit_length "#{ENV['OUTPUT_BUFFER_QUEUE_LIMIT']}"
overflow_action block
</buffer></pre>
</div>
<ul>
<li>match：标识一个目标标签，后面是一个匹配日志源的正则表达式，我们这里想要捕获所有的日志并将它们发送给 Elasticsearch，所以需要配置成<code>**</code>。</li>
<li>id：目标的一个唯一标识符。</li>
<li>type：支持的输出插件标识符，我们这里要输出到 Elasticsearch，所以配置成 elasticsearch，这是 Fluentd 的一个内置插件。</li>
<li>log_level：指定要捕获的日志级别，我们这里配置成 <code>info</code>，表示任何该级别或者该级别以上（INFO、WARNING、ERROR）的日志都将被路由到 Elsasticsearch。</li>
<li>host/port：定义 Elasticsearch 的地址，也可以配置认证信息，我们的 Elasticsearch 不需要认证，所以这里直接指定 host 和 port 即可。</li>
<li>logstash_format：Elasticsearch 服务对日志数据构建反向索引进行搜索，将 logstash_format 设置为 <code>true</code>，Fluentd 将会以 logstash 格式来转发结构化的日志数据。</li>
<li>Buffer： Fluentd 允许在目标不可用时进行缓存，比如，如果网络出现故障或者 Elasticsearch 不可用的时候。缓冲区配置也有助于降低磁盘的 IO。</li>
</ul>
过滤
由于 Kubernetes 集群中应用太多，也还有很多历史数据，所以我们可以只将某些应用的日志进行收集，比如我们只采集具有 <code>logging=true</code> 这个 Label 标签的 Pod 日志，这个时候就需要使用 filter，如下所示：
<div class="cnblogs_code">
<pre># 删除无用的属性
<filter kubernetes.**>
@type record_transformer
remove_keys $.docker.container_id,$.kubernetes.container_image_id,$.kubernetes.pod_id,$.kubernetes.namespace_id,$.kubernetes.master_url,$.kubernetes.labels.pod-template-hash
</filter>
# 只保留具有logging=true标签的Pod日志
<filter kubernetes.**>
@id filter_log
@type grep
<regexp>
key $.kubernetes.labels.logging
pattern ^true$
</regexp>
</filter></pre>
</div>
<h3 id="header-f9eb-5ab2" data-fold="unfold">安装</h3>
要收集 Kubernetes 集群的日志，直接用 DasemonSet 控制器来部署 Fluentd 应用，这样，它就可以从 Kubernetes 节点上采集日志，确保在集群中的每个节点上始终运行一个 Fluentd 容器。当然可以直接使用 Helm 来进行一键安装，为了能够了解更多实现细节，我们这里还是采用手动方法来进行安装。
首先，我们通过 ConfigMap 对象来指定 Fluentd 配置文件，新建 fluentd-configmap.yaml 文件，文件内容如下：
<div class="cnblogs_code">
<pre>kind: ConfigMap
apiVersion: v1
metadata:
name: fluentd-config
namespace: logging
data:
system.conf: |-
<system>
 root_dir /tmp/fluentd-buffers/
</system>
containers.input.conf: |-
<source>
 @id fluentd-containers.log
 @type tail # Fluentd 内置的输入方式，其原理是不停地从源文件中获取新的日志。
 path /var/log/containers/*.log # 挂载的服务器Docker容器日志地址
 pos_file /var/log/es-containers.log.pos
 tag raw.kubernetes.* # 设置日志标签
 read_from_head true
 <parse> # 多行格式化成JSON
 @type multi_format # 使用 multi-format-parser 解析器插件
 <pattern>
 format json # JSON解析器
 time_key time # 指定事件时间的时间字段
 time_format %Y-%m-%dT%H:%M:%S.%NZ # 时间格式
 </pattern>
 <pattern>
 format /^(?<time>.+) (?<stream>stdout|stderr) [^ ]* (?<log>.*)$/
 time_format %Y-%m-%dT%H:%M:%S.%N%:z
 </pattern>
 </parse>
</source>
# 在日志输出中检测异常，并将其作为一条日志转发
# https://github.com/GoogleCloudPlatform/fluent-plugin-detect-exceptions
<match raw.kubernetes.**> # 匹配tag为raw.kubernetes.**日志信息
 @id raw.kubernetes
 @type detect_exceptions # 使用detect-exceptions插件处理异常栈信息
 remove_tag_prefix raw # 移除 raw 前缀
 message log
 stream stream
 multiline_flush_interval 5
 max_bytes 500000
 max_lines 1000
</match>

<filter **># 拼接日志
 @id filter_concat
 @type concat # Fluentd Filter 插件，用于连接多个事件中分隔的多行日志。
 key message
 multiline_end_regexp /\n$/# 以换行符“\n”拼接
 separator ""
</filter>

# 添加 Kubernetes metadata 数据
<filter kubernetes.**>
 @id filter_kubernetes_metadata
 @type kubernetes_metadata
</filter>

# 修复 ES 中的 JSON 字段
# 插件地址：https://github.com/repeatedly/fluent-plugin-multi-format-parser
<filter kubernetes.**>
 @id filter_parser
 @type parser # multi-format-parser多格式解析器插件
 key_name log # 在要解析的记录中指定字段名称。
 reserve_data true # 在解析结果中保留原始键值对。
 remove_key_name_field true# key_name 解析成功后删除字段。
 <parse>
 @type multi_format
 <pattern>
 format json
 </pattern>
 <pattern>
 format none
 </pattern>
 </parse>
</filter>

# 删除一些多余的属性
<filter kubernetes.**>
 @type record_transformer
 remove_keys $.docker.container_id,$.kubernetes.container_image_id,$.kubernetes.pod_id,$.kubernetes.namespace_id,$.kubernetes.master_url,$.kubernetes.labels.pod-template-hash
</filter>

# 只保留具有logging=true标签的Pod日志
<filter kubernetes.**>
 @id filter_log
 @type grep
 <regexp>
 key $.kubernetes.labels.logging
 pattern ^true$
 </regexp>
</filter>

###### 监听配置，一般用于日志聚合用 ######
forward.input.conf: |-
# 监听通过TCP发送的消息
<source>
 @id forward
 @type forward
</source>

output.conf: |-
<match **>
 @id elasticsearch
 @type elasticsearch
 @log_level info
 include_tag_key true
 host elasticsearch
 port 9200
 logstash_format true
 logstash_prefix k8s# 设置 index 前缀为 k8s
 request_timeout 30s
 <buffer>
 @type file
 path /var/log/fluentd-buffers/kubernetes.system.buffer
 flush_mode interval
 retry_type exponential_backoff
 flush_thread_count 2
 flush_interval 5s
 retry_forever
 retry_max_interval 30
 chunk_limit_size 2M
 queue_limit_length 8
 overflow_action block
 </buffer>
</match></pre>
</div>
上面配置文件中我们只配置了 docker 容器日志目录，收集到数据经过处理后发送到 <code>elasticsearch:9200</code> 服务。
然后新建一个 fluentd-daemonset.yaml 的文件，文件内容如下：
<div class="cnblogs_code">
<pre>apiVersion: v1
kind: ServiceAccount
metadata:
name: fluentd-es
namespace: logging
labels:
k8s-app: fluentd-es
kubernetes.io/cluster-service: "true"
addonmanager.kubernetes.io/mode: Reconcile
---
kind: ClusterRole
apiVersion: rbac.authorization.k8s.io/v1
metadata:
name: fluentd-es
labels:
k8s-app: fluentd-es
kubernetes.io/cluster-service: "true"
addonmanager.kubernetes.io/mode: Reconcile
rules:
- apiGroups:
- ""
resources:
- "namespaces"
- "pods"
verbs:
- "get"
- "watch"
- "list"
---
kind: ClusterRoleBinding
apiVersion: rbac.authorization.k8s.io/v1
metadata:
name: fluentd-es
labels:
k8s-app: fluentd-es
kubernetes.io/cluster-service: "true"
addonmanager.kubernetes.io/mode: Reconcile
subjects:
- kind: ServiceAccount
name: fluentd-es
namespace: logging
apiGroup: ""
roleRef:
kind: ClusterRole
name: fluentd-es
apiGroup: ""
---
apiVersion: apps/v1
kind: DaemonSet
metadata:
name: fluentd-es
namespace: logging
labels:
k8s-app: fluentd-es
kubernetes.io/cluster-service: "true"
addonmanager.kubernetes.io/mode: Reconcile
spec:
selector:
matchLabels:
 k8s-app: fluentd-es
template:
metadata:
 labels:
 k8s-app: fluentd-es
 kubernetes.io/cluster-service: "true"
 # 此注释确保如果节点被驱逐，fluentd不会被驱逐，支持关键的基于 pod 注释的优先级方案。
 annotations:
 scheduler.alpha.kubernetes.io/critical-pod: ''
spec:
 serviceAccountName: fluentd-es
 containers:
 - name: fluentd-es
 image: quay.io/fluentd_elasticsearch/fluentd:v3.0.1
 env:
 - name: FLUENTD_ARGS
 value: --no-supervisor -q
 resources:
 limits:
 memory: 500Mi
 requests:
 cpu: 100m
 memory: 200Mi
 volumeMounts:
 - name: varlog
 mountPath: /var/log
 - name: varlibdockercontainers
 mountPath: /data/docker/containers
 readOnly: true
 - name: config-volume
 mountPath: /etc/fluent/config.d
 nodeSelector:
 beta.kubernetes.io/fluentd-ds-ready: "true"
 tolerations:
 - operator: Exists
 terminationGracePeriodSeconds: 30
 volumes:
 - name: varlog
 hostPath:
 path: /var/log
 - name: varlibdockercontainers
 hostPath:
 path: /data/docker/containers
 - name: config-volume
 configMap:
 name: fluentd-config</pre>
</div>
我们将上面创建的 fluentd-config 这个 ConfigMap 对象通过 volumes 挂载到了 Fluentd 容器中，另外为了能够灵活控制哪些节点的日志可以被收集，所以我们这里还添加了一个 nodSelector 属性：
<div class="cnblogs_code">
<pre>nodeSelector:
beta.kubernetes.io/fluentd-ds-ready: "true"</pre>
</div>
意思就是要想采集节点的日志，那么我们就需要给节点打上上面的标签，比如我们这里只给节点4和节点6打上了该标签：
如果你需要在其他节点上采集日志，则需要给对应节点打上标签，使用如下命令：<code>kubectl label nodes node名 beta.kubernetes.io/fluentd-ds-ready=true</code>。
另外由于我们的集群使用的是 kubeadm 搭建的，默认情况下 master 节点有污点，所以如果要想也收集 master 节点的日志，则需要添加上容忍：
<div class="cnblogs_code">
<pre>tolerations:
- operator: Exists</pre>
</div>
ds的yaml文件要改
<div class="cnblogs_code">
<pre>$ kubectl create -f fluentd-configmap.yaml
configmap "fluentd-config" created
$ kubectl create -f fluentd-daemonset.yaml
serviceaccount "fluentd-es" created
clusterrole.rbac.authorization.k8s.io "fluentd-es" created
clusterrolebinding.rbac.authorization.k8s.io "fluentd-es" created
daemonset.apps "fluentd-es" created</pre>
</div>
Fluentd 启动成功后，这个时候就可以发送日志到 ES 了，但是我们这里是过滤了只采集具有 <code>logging=true</code> 标签的 Pod 日志，所以现在还没有任何数据会被采集。
下面我们部署一个简单的测试应用，新建 counter.yaml 文件，文件内容如下：
<div class="cnblogs_code">
<pre>$ kubectl create -f counter.yaml
$ kubectl get pods
NAME READY STATUS RESTARTS AGE
counter 1/1 Running 0 9h</pre>
</div>
Pod 创建并运行后，回到 Kibana Dashboard 页面，点击左侧最下面的 <code>management</code> 图标，然后点击 Kibana 下面的 <code>Index Patterns</code> 开始导入索引数据：
<div class="cnblogs_code">
<pre>curl -s "127.0.0.1:9200/_cat/indices?v"</pre>
</div>
查看索引是否存在
<img src="https://img2022.cnblogs.com/blog/2636555/202205/2636555-20220515181127420-208277523.png" alt="" loading="lazy">
 
 至此我们就成功部署了EFK来收集k8s集群的日志。 
来源：https://www.cnblogs.com/zjl-throb/p/16273904.html

頁: [1]

琼殿技术论坛's Archiver

kubernetes部署EFK（k8s）