背景
测试环境，k8s集群部署在3个节点的虚拟机服务器上；需要收集集群中pod日志。

创建 Elasticsearch 集群

创建命名空间

  1. $ kubectl create -f kube-logging.yaml
  3. apiVersion: v1
  4. kind: Namespace
  5. metadata:
  6.   name: logging

创建了一个命名空间来存放我们的日志相关资源，接下来可以部署 EFK 相关组件，由于在测试环境，首先开始部署一个单节点的 Elasticsearch 。

创建elasticsearch service 服务

  1. $ kubectl create -f elasticsearch-svc.yaml
  3. kind: Service
  4. apiVersion: v1
  5. metadata:
  6.   name: elasticsearch
  7.   namespace: logging
  8.   labels:
  9.     app: elasticsearch
  10. spec:
  11.   selector:
  12.     app: elasticsearch
  13.   clusterIP: None
  14.   ports:
  15.     - port: 9200
  16.       name: rest
  17.     - port: 9300
  18.       name: inter-node

在测试环境中k8s集群部署在3个虚拟机上，为了数据能够落盘，但是没有可用的磁盘可以挂载，我们只有选择使用本地文件目录local persistent volume,具体创建过程参考本文

  1. $ kubectl get svc -n logging
  2. NAME            TYPE        CLUSTER-IP   EXTERNAL-IP   PORT(S)             AGE
  3. elasticsearch   ClusterIP   None         <none>        9200/TCP,9300/TCP   27h

我们已经为 Pod 设置了无头服务和一个稳定的域名.elasticsearch.logging.svc.cluster.local，接下来我们通过 StatefulSet 来创建具体的 Elasticsearch 的 Pod 应用。

Kubernetes StatefulSet 允许我们为 Pod 分配一个稳定的标识和持久化存储，Elasticsearch 需要稳定的存储来保证 Pod 在重新调度或者重启后的数据依然不变，所以需要使用 StatefulSet 来管理 Pod。

创建Elasticsearch StatefulSet 服务

创建数据目录

本文采用的是虚拟机创建的k8s集群，所有的存储使用本地存储，数据存放到集群中一台node节点上，因此创建本地存储之前，需要先行在对应节点上创建数据目录

  1. #ssh k8s-worker-node1
  2. mkidr -p /data/elasticsearch
  4. chmod 777 /data/elasticsearch -R

创建本地PersistentVolume存储

  1. apiVersion: v1
  2. kind: PersistentVolume
  3. metadata:
  4.   name: es-pv
  5. spec:
  6.   capacity:
  7.     storage: 10Gi
  8.   volumeMode: Filesystem
  9.   accessModes:
  10.   - ReadWriteOnce
  11.   persistentVolumeReclaimPolicy: Delete
  12.   storageClassName: local-storage
  13.   local:
  14.     path: /data/elasticsearch
  15.   nodeAffinity:
  16.     required:
  17.       nodeSelectorTerms:
  18.       - matchExpressions:
  19.         - key: kubernetes.io/hostname
  20.           operator: In
  21.           values:
  22.           - k8s-worker-node1

node打标签

由于我们的集群使用的是 kubeadm 搭建的，默认情况下 master 节点有污点，部署时pod不会被调度到master节点上，我们可以给node打标签来解决这个问题，来选择将pod部署到哪个node节点上。

  1. #查询集群节点服务器的labels
  2. $ kubectl get node --show-labels
  4. #根据下面完整的statefulset文件中可以看出nodeSelector会调度到es=log的节点上
  5. .....
  6.     spec:
  7.       nodeSelector:
  8.         es: log
  9. .....
  11. #因此我们需要给node节点添加标签label
  12. #kubectl label nodes <node-name> <label-key>=<label-value> 
  13. $ kubectl label nodes k8s-worker-node2 es=log

创建statefulset

完整的 Elasticsearch StatefulSet 资源清单文件内容如下：

  1. elasticsearch-statefulset.yaml 
  2. apiVersion: apps/v1
  3. kind: StatefulSet
  4. metadata:
  5.   name: es
  6.   namespace: logging
  7. spec:
  8.   serviceName: elasticsearch
  9.   replicas: 1                #线上最好3个或着奇数个
  10.   selector:
  11.     matchLabels:
  12.       app: elasticsearch
  13.   template:
  14.     metadata:
  15.       labels: 
  16.         app: elasticsearch
  17.     spec:
  18.       nodeSelector:
  19.         es: log
  20.       initContainers:
  21.       - name: increase-vm-max-map
  22.         image: busybox
  23.         command: ["sysctl", "-w", "vm.max_map_count=262144"]
  24.         securityContext:
  25.           privileged: true
  26.       - name: increase-fd-ulimit
  27.         image: busybox
  28.         command: ["sh", "-c", "ulimit -n 65536"]
  29.         securityContext:
  30.           privileged: true
  31.       containers:
  32.       - name: elasticsearch
  33.         image: docker.elastic.co/elasticsearch/elasticsearch:7.6.2
  34.         ports:
  35.         - name: rest
  36.           containerPort: 9200
  37.         - name: inter
  38.           containerPort: 9300
  39.         resources:
  40.           limits:
  41.             cpu: 1000m
  42.           requests:
  43.             cpu: 1000m
  44.         volumeMounts:
  45.         - name: data
  46.           mountPath: /usr/share/elasticsearch/data
  47.         env:
  48.         - name: cluster.name
  49.           value: k8s-logs
  50.         - name: node.name
  51.           valueFrom:
  52.             fieldRef:
  53.               fieldPath: metadata.name
  54.         - name: cluster.initial_master_nodes
  55.           value: "es-0"            #由于测试环境，这里只选择一个es
  56.         - name: discovery.zen.minimum_master_nodes
  57.           value: "1"               #线上环境设置为2
  58.         - name: discovery.seed_hosts
  59.           value: "elasticsearch"
  60.         - name: ES_JAVA_OPTS
  61.           value: "-Xms512m -Xmx512m"
  62.         - name: network.host
  63.           value: "0.0.0.0"
  64.   volumeClaimTemplates:
  65.   - metadata:
  66.       name: data
  67.       labels:
  68.         app: elasticsearch
  69.     spec:
  70.       accessModes: [ "ReadWriteOnce" ]
  71.       storageClassName: local-storage
  72.       resources:
  73.         requests:
  74.           storage: 10Gi

我们这里使用 volumeClaimTemplates 来定义持久化模板，Kubernetes 会使用它为 Pod 创建 PersistentVolume，设置访问模式为ReadWriteOnce，这意味着它只能被 mount 到单个节点上进行读写，然后最重要的是使用了一个 StorageClass 对象，这里我们就直接使用前面创建的 本地pv 类型的名为local-storage对象即可。
最后，我们指定了每个 PersistentVolume 的大小为 10GB，我们可以根据自己的实际需要进行调整该值。

  • cluster.name：Elasticsearch 集群的名称，我们这里命名成 k8s-logs。node.name：节点的名称，通过 metadata.name 来获取。这将解析为 es-[0,1,2]，取决于节点的指定顺序。
  • discovery.seed_hosts：此字段用于设置在 Elasticsearch 集群中节点相互连接的发现方法。由于我们之前配置的无头服务，我们的 Pod 具有唯一的 DNS 域es-[0,1,2].elasticsearch.logging.svc.cluster.local，因此我们相应地设置此变量。
  • discovery.zen.minimum_master_nodes：我们将其设置为(N/2) + 1，N是我们的群集中符合主节点的节点的数量。如果线上有3个 Elasticsearch 节点，因此我们将此值设置为2（向下舍入到最接近的整数）。
  • ES_JAVA_OPTS：这里我们设置为-Xms512m -Xmx512m，告诉JVM使用512 MB的最小和最大堆。应该根据群集的资源可用性和需求调整这些参数。

直接使用kubectl工具部署即可

  1. $ kubectl create -f elasticsearch-statefulset.yaml

添加成功后，可以看到logging命名空间下所有的资源

  1. $ kubectl get sts -n logging
  2. NAME   READY   AGE
  3. es     0/1     2m21s
  4. $ kubectl get pods -n logging
  5. NAME   READY   STATUS    RESTARTS   AGE
  6. es-0   0/1     Pending   0          2m31s

创建 Kibana 服务

Elasticsearch 集群启动成功了，接下来我们可以来部署 Kibana 服务，新建一个名为 kibana.yaml 的文件，对应的文件内容如下：

  1. apiVersion: v1
  2. kind: Service
  3. metadata:
  4.   name: kibana
  5.   namespace: logging
  6.   labels:
  7.     app: kibana
  8. spec:
  9.   ports:
  10.   - port: 5601
  11.   type: NodePort
  12.   selector:
  13.     app: kibana
  15. ---
  16. apiVersion: apps/v1
  17. kind: Deployment
  18. metadata:
  19.   name: kibana
  20.   namespace: logging
  21.   labels:
  22.     app: kibana
  23. spec:
  24.   selector:
  25.     matchLabels:
  26.       app: kibana
  27.   template:
  28.     metadata:
  29.       labels:
  30.         app: kibana
  31.     spec:
  32.       nodeSelector:
  33.         es: log
  34.       containers:
  35.       - name: kibana
  36.         image: docker.elastic.co/kibana/kibana:7.6.2
  37.         resources:
  38.           limits:
  39.             cpu: 1000m
  40.           requests:
  41.             cpu: 1000m
  42.         env:
  43.         - name: ELASTICSEARCH_HOSTS
  44.           value: http://elasticsearch:9200
  45.         ports:
  46.         - containerPort: 5601

上面我们定义了两个资源对象，一个 Service 和 Deployment，为了测试方便，我们将 Service 设置为了 NodePort 类型，Kibana Pod 中配置都比较简单，唯一需要注意的是我们使用 ELASTICSEARCH_HOSTS 这个环境变量来设置Elasticsearch 集群的端点和端口，直接使用 Kubernetes DNS 即可，此端点对应服务名称为 elasticsearch，由于是一个 headless service，所以该域将解析为 Elasticsearch Pod 的 IP 地址列表。

配置完成后，直接使用 kubectl 工具创建：

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

创建完成后，可以查看 Kibana Pod 的运行状态：

  1. kubectl get pod,svc -n logging
  2. NAME                          READY   STATUS    RESTARTS   AGE
  3. pod/es-0                      1/1     Running   0          82m
  4. pod/kibana-7dc465fbc8-hh95t   1/1     Running   0          83s
  6. NAME                    TYPE        CLUSTER-IP     EXTERNAL-IP   PORT(S)             AGE
  7. service/elasticsearch   ClusterIP   None           <none>        9200/TCP,9300/TCP   28h
  8. service/kibana          NodePort    10.96.49.149   <none>        5601:49609/TCP      28m

如果部署过程中出现imagePullBackOff的情况，可以手动拉下镜像保存到本地镜像仓库，然后替换kibana.yaml镜像即可。

如果 Pod 已经是 Running 状态了，证明应用已经部署成功了，然后可以通过 NodePort 来访问 Kibana 这个服务，在浏览器中打开http://<任意节点IP>:49609即可，如果看到如下界面证明 Kibana 已经成功部署到了 Kubernetes集群之中。

image.png

部署 Fluentd

image.png
Fluentd 是一个高效的日志聚合器，是用 Ruby 编写的，并且可以很好地扩展。对于大部分企业来说，Fluentd 足够高效并且消耗的资源相对较少，另外一个工具Fluent-bit更轻量级，占用资源更少，但是插件相对 Fluentd 来说不够丰富，所以整体来说，Fluentd 更加成熟，使用更加广泛，所以我们这里也同样使用 Fluentd 来作为日志收集工具。

工作原理

Fluentd 通过一组给定的数据源抓取日志数据，处理后（转换成结构化的数据格式）将它们转发给其他服务，比如 Elasticsearch、对象存储等等。Fluentd 支持超过300个日志存储和分析服务，所以在这方面是非常灵活的。

主要运行步骤如下：
首先 Fluentd 从多个日志源获取数据；
结构化并且标记这些数据；
然后根据匹配的标签将数据发送到多个目标服务去。

image.png

配置

一般来说我们是通过一个配置文件来告诉 Fluentd 如何采集、处理数据的，下面简单和大家介绍下 Fluentd 的配置方法。

日志源配置

比如我们这里为了收集 Kubernetes 节点上的所有容器日志，就需要做如下的日志源配置：

  1. <source>
  2.   @id fluentd-containers.log
  3.   @type tail                             # Fluentd 内置的输入方式，其原理是不停地从源文件中获取新的日志。
  4.   path /var/log/containers/*.log         # 挂载的服务器Docker容器日志地址
  5.   pos_file /var/log/es-containers.log.pos
  6.   tag raw.kubernetes.*                   # 设置日志标签
  7.   read_from_head true
  8.   <parse>                                # 多行格式化成JSON
  9.     @type multi_format                   # 使用 multi-format-parser 解析器插件
  10.     <pattern>
  11.       format json                        # JSON 解析器
  12.       time_key time                      # 指定事件时间的时间字段
  13.       time_format %Y-%m-%dT%H:%M:%S.%NZ  # 时间格式
  14.     </pattern>
  15.     <pattern>
  16.       format /^(?<time>.+) (?<stream>stdout|stderr) [^ ]* (?<log>.*)$/
  17.       time_format %Y-%m-%dT%H:%M:%S.%N%:z
  18.     </pattern>
  19.   </parse>
  20. </source>

上面配置部分参数说明如下：

id：表示引用该日志源的唯一标识符，该标识可用于进一步过滤和路由结构化日志数据
type：Fluentd 内置的指令，tail 表示 Fluentd 从上次读取的位置通过 tail 不断获取数据，另外一个是 http 表示通过一个 GET 请求来收集数据。
path：tail 类型下的特定参数，告诉 Fluentd 采集 /var/log/containers 目录下的所有日志，这是 docker 在 Kubernetes 节点上用来存储运行容器 stdout 输出日志数据的目录。
pos_file：检查点，如果 Fluentd 程序重新启动了，它将使用此文件中的位置来恢复日志数据收集。
tag：用来将日志源与目标或者过滤器匹配的自定义字符串，Fluentd 匹配源/目标标签来路由日志数据。

路由配置

上面是日志源的配置，接下来看看如何将日志数据发送到 Elasticsearch：

  1. <match **>
  2. @id elasticsearch
  3. @type elasticsearch
  4. @log_level info
  5. include_tag_key true
  6. type_name fluentd
  7. host "#{ENV['OUTPUT_HOST']}"
  8. port "#{ENV['OUTPUT_PORT']}"
  9. logstash_format true
  10. <buffer>
  11. @type file
  12. path /var/log/fluentd-buffers/kubernetes.system.buffer
  13. flush_mode interval
  14. retry_type exponential_backoff
  15. flush_thread_count 2
  16. flush_interval 5s
  17. retry_forever
  18. retry_max_interval 30
  19. chunk_limit_size "#{ENV['OUTPUT_BUFFER_CHUNK_LIMIT']}"
  20. queue_limit_length "#{ENV['OUTPUT_BUFFER_QUEUE_LIMIT']}"
  21. overflow_action block
  22. </buffer>
  • match：标识一个目标标签，后面是一个匹配日志源的正则表达式，我们这里想要捕获所有的日志并将它们发送给 Elasticsearch，所以需要配置成**。
  • id：目标的一个唯一标识符。
  • type：支持的输出插件标识符，我们这里要输出到 Elasticsearch，所以配置成 elasticsearch，这是 Fluentd 的一个内置插件。
  • log_level：指定要捕获的日志级别，我们这里配置成 info，表示任何该级别或者该级别以上（INFO、WARNING、ERROR）的日志都将被路由到 Elsasticsearch。
  • host/port：定义 Elasticsearch 的地址，也可以配置认证信息，我们的 Elasticsearch 不需要认证，所以这里直接指定 host 和 port 即可。
  • logstash_format：Elasticsearch 服务对日志数据构建反向索引进行搜索，将 logstash_format 设置为 true，Fluentd 将会以 logstash 格式来转发结构化的日志数据。
  • Buffer： Fluentd 允许在目标不可用时进行缓存，比如，如果网络出现故障或者 Elasticsearch 不可用的时候。缓冲区配置也有助于降低磁盘的 IO。

过滤

由于 Kubernetes 集群中应用太多，也还有很多历史数据，所以我们可以只将某些应用的日志进行收集，比如我们只采集具有 logging=true 这个 Label 标签的 Pod 日志，这个时候就需要使用 filter，如下所示：

  1. # 删除无用的属性
  2. <filter kubernetes.**>
  3.   @type record_transformer
  4.   remove_keys $.docker.container_id,$.kubernetes.container_image_id,$.kubernetes.pod_id,$.kubernetes.namespace_id,$.kubernetes.master_url,$.kubernetes.labels.pod-template-hash
  5. </filter>
  6. # 只保留具有logging=true标签的Pod日志
  7. <filter kubernetes.**>
  8.   @id filter_log
  9.   @type grep
  10.   <regexp>
  11.     key $.kubernetes.labels.logging
  12.     pattern ^true$
  13.   </regexp>
  14. </filter>

安装

要收集 Kubernetes 集群的日志，直接用 DasemonSet 控制器来部署 Fluentd 应用，这样，它就可以从 Kubernetes 节点上采集日志，确保在集群中的每个节点上始终运行一个 Fluentd 容器。当然可以直接使用 Helm 来进行一键安装，为了能够了解更多实现细节，我们这里还是采用手动方法来进行安装。

fluentd配置文件

首先，我们通过 ConfigMap 对象来指定 Fluentd 配置文件，新建 fluentd-configmap.yaml 文件，文件内容如下：

  1. kind: ConfigMap
  2. apiVersion: v1
  3. metadata:
  4.   name: fluentd-config
  5.   namespace: logging
  6. data:
  7.   system.conf: |-
  8.     <system>
  9.       root_dir /tmp/fluentd-buffers/
  10.     </system>
  11.   containers.input.conf: |-
  12.     <source>
  13.       @id fluentd-containers.log
  14.       @type tail                              # Fluentd 内置的输入方式，其原理是不停地从源文件中获取新的日志。
  15.       path /var/log/containers/*.log          # 挂载的服务器Docker容器日志地址
  16.       pos_file /var/log/es-containers.log.pos
  17.       tag raw.kubernetes.*                    # 设置日志标签
  18.       read_from_head true
  19.       <parse>                                 # 多行格式化成JSON
  20.         @type multi_format                    # 使用 multi-format-parser 解析器插件
  21.         <pattern>
  22.           format json                         # JSON解析器
  23.           time_key time                       # 指定事件时间的时间字段
  24.           time_format %Y-%m-%dT%H:%M:%S.%NZ   # 时间格式
  25.         </pattern>
  26.         <pattern>
  27.           format /^(?<time>.+) (?<stream>stdout|stderr) [^ ]* (?<log>.*)$/
  28.           time_format %Y-%m-%dT%H:%M:%S.%N%:z
  29.         </pattern>
  30.       </parse>
  31.     </source>
  32.     # 在日志输出中检测异常，并将其作为一条日志转发 
  33.     # https://github.com/GoogleCloudPlatform/fluent-plugin-detect-exceptions
  34.     <match raw.kubernetes.**>           # 匹配tag为raw.kubernetes.**日志信息
  35.       @id raw.kubernetes
  36.       @type detect_exceptions           # 使用detect-exceptions插件处理异常栈信息
  37.       remove_tag_prefix raw             # 移除 raw 前缀
  38.       message log                       
  39.       stream stream                     
  40.       multiline_flush_interval 5
  41.       max_bytes 500000
  42.       max_lines 1000
  43.     </match>
  45.     <filter **>  # 拼接日志
  46.       @id filter_concat
  47.       @type concat                # Fluentd Filter 插件，用于连接多个事件中分隔的多行日志。
  48.       key message
  49.       multiline_end_regexp /\n$/  # 以换行符“\n”拼接
  50.       separator ""
  51.     </filter> 
  53.     # 添加 Kubernetes metadata 数据
  54.     <filter kubernetes.**>
  55.       @id filter_kubernetes_metadata
  56.       @type kubernetes_metadata
  57.     </filter>
  59.     # 修复 ES 中的 JSON 字段
  60.     # 插件地址：https://github.com/repeatedly/fluent-plugin-multi-format-parser
  61.     <filter kubernetes.**>
  62.       @id filter_parser
  63.       @type parser                # multi-format-parser多格式解析器插件
  64.       key_name log                # 在要解析的记录中指定字段名称。
  65.       reserve_data true           # 在解析结果中保留原始键值对。
  66.       remove_key_name_field true  # key_name 解析成功后删除字段。
  67.       <parse>
  68.         @type multi_format
  69.         <pattern>
  70.           format json
  71.         </pattern>
  72.         <pattern>
  73.           format none
  74.         </pattern>
  75.       </parse>
  76.     </filter>
  78.     # 删除一些多余的属性
  79.     <filter kubernetes.**>
  80.       @type record_transformer
  81.       remove_keys $.docker.container_id,$.kubernetes.container_image_id,$.kubernetes.pod_id,$.kubernetes.namespace_id,$.kubernetes.master_url,$.kubernetes.labels.pod-template-hash
  82.     </filter>
  84.     # 只保留具有logging=true标签的Pod日志
  85.     <filter kubernetes.**>
  86.       @id filter_log
  87.       @type grep
  88.       <regexp>
  89.         key $.kubernetes.labels.logging
  90.         pattern ^true$
  91.       </regexp>
  92.     </filter>
  94.   ###### 监听配置，一般用于日志聚合用 ######
  95.   forward.input.conf: |-
  96.     # 监听通过TCP发送的消息
  97.     <source>
  98.       @id forward
  99.       @type forward
  100.     </source>
  102.   output.conf: |-
  103.     <match **>
  104.       @id elasticsearch
  105.       @type elasticsearch
  106.       @log_level info
  107.       include_tag_key true
  108.       host elasticsearch
  109.       port 9200
  110.       logstash_format true
  111.       logstash_prefix k8s  # 设置 index 前缀为 k8s
  112.       request_timeout    30s
  113.       <buffer>
  114.         @type file
  115.         path /var/log/fluentd-buffers/kubernetes.system.buffer
  116.         flush_mode interval
  117.         retry_type exponential_backoff
  118.         flush_thread_count 2
  119.         flush_interval 5s
  120.         retry_forever
  121.         retry_max_interval 30
  122.         chunk_limit_size 2M
  123.         queue_limit_length 8
  124.         overflow_action block
  125.       </buffer>
  126.     </match>

fluentd-daemonset配置

上面配置文件中我们只配置了 docker 容器日志目录，收集到数据经过处理后发送到 elasticsearch:9200 服务。
然后新建一个 fluentd-daemonset.yaml 的文件，文件内容如下：

  1. apiVersion: v1
  2. kind: ServiceAccount
  3. metadata:
  4.   name: fluentd-es
  5.   namespace: logging
  6.   labels:
  7.     k8s-app: fluentd-es
  8.     kubernetes.io/cluster-service: "true"
  9.     addonmanager.kubernetes.io/mode: Reconcile
  10. ---
  11. kind: ClusterRole
  12. apiVersion: rbac.authorization.k8s.io/v1
  13. metadata:
  14.   name: fluentd-es
  15.   labels:
  16.     k8s-app: fluentd-es
  17.     kubernetes.io/cluster-service: "true"
  18.     addonmanager.kubernetes.io/mode: Reconcile
  19. rules:
  20. - apiGroups:
  21.   - ""
  22.   resources:
  23.   - "namespaces"
  24.   - "pods"
  25.   verbs:
  26.   - "get"
  27.   - "watch"
  28.   - "list"
  29. ---
  30. kind: ClusterRoleBinding
  31. apiVersion: rbac.authorization.k8s.io/v1
  32. metadata:
  33.   name: fluentd-es
  34.   labels:
  35.     k8s-app: fluentd-es
  36.     kubernetes.io/cluster-service: "true"
  37.     addonmanager.kubernetes.io/mode: Reconcile
  38. subjects:
  39. - kind: ServiceAccount
  40.   name: fluentd-es
  41.   namespace: logging
  42.   apiGroup: ""
  43. roleRef:
  44.   kind: ClusterRole
  45.   name: fluentd-es
  46.   apiGroup: ""
  47. ---
  48. apiVersion: apps/v1
  49. kind: DaemonSet
  50. metadata:
  51.   name: fluentd-es
  52.   namespace: logging
  53.   labels:
  54.     k8s-app: fluentd-es
  55.     kubernetes.io/cluster-service: "true"
  56.     addonmanager.kubernetes.io/mode: Reconcile
  57. spec:
  58.   selector:
  59.     matchLabels:
  60.       k8s-app: fluentd-es
  61.   template:
  62.     metadata:
  63.       labels:
  64.         k8s-app: fluentd-es
  65.         kubernetes.io/cluster-service: "true"
  66.       # 此注释确保如果节点被驱逐，fluentd不会被驱逐，支持关键的基于 pod 注释的优先级方案。
  67.       annotations:
  68.         scheduler.alpha.kubernetes.io/critical-pod: ''
  69.     spec:
  70.       serviceAccountName: fluentd-es
  71.       containers:
  72.       - name: fluentd-es
  73.         image: quay.io/fluentd_elasticsearch/fluentd:v3.0.1
  74.         env:
  75.         - name: FLUENTD_ARGS
  76.           value: --no-supervisor -q
  77.         resources:
  78.           limits:
  79.             memory: 500Mi
  80.           requests:
  81.             cpu: 100m
  82.             memory: 200Mi
  83.         volumeMounts:
  84.         - name: varlog
  85.           mountPath: /var/log
  86.         - name: varlibdockercontainers
  87.           mountPath: /var/lib/docker/containers
  88.           readOnly: true
  89.         - name: config-volume
  90.           mountPath: /etc/fluent/config.d
  91.       nodeSelector:
  92.         beta.kubernetes.io/fluentd-ds-ready: "true"
  93.       tolerations:
  94.       - operator: Exists
  95.       terminationGracePeriodSeconds: 30
  96.       volumes:
  97.       - name: varlog
  98.         hostPath:
  99.           path: /var/log
  100.       - name: varlibdockercontainers
  101.         hostPath:
  102.           path: /var/lib/docker/containers
  103.       - name: config-volume
  104.         configMap:
  105.           name: fluentd-config

节点打标签

我们将上面创建的 fluentd-config 这个 ConfigMap 对象通过 volumes 挂载到了 Fluentd 容器中，另外为了能够灵活控制哪些节点的日志可以被收集，所以我们这里还添加了一个 nodSelector 属性：

  1. nodeSelector:
  2.   beta.kubernetes.io/fluentd-ds-ready: "true"

意思就是要想采集节点的日志，那么我们就需要给节点打上上面的标签

  1. #给node节点添加标签label
  2. #kubectl label nodes <node-name> <label-key>=<label-value> 
  4. kubectl label nodes node名 beta.kubernetes.io/fluentd-ds-ready=true

注意：如果我们不想采集master节点上的日志我们可以给master节点打污点。

安装fluentd

分别创建上面的 ConfigMap 对象和 DaemonSet：

  1. $ kubectl create -f fluentd-configmap.yaml
  2. configmap "fluentd-config" created
  3. $ kubectl create -f fluentd-daemonset.yaml
  4. serviceaccount "fluentd-es" created
  5. clusterrole.rbac.authorization.k8s.io "fluentd-es" created
  6. clusterrolebinding.rbac.authorization.k8s.io "fluentd-es" created
  7. daemonset.apps "fluentd-es" created

创建完成后，查看对应的 Pods 列表，检查是否部署成功：

  1. $ kubectl get pod -n logging
  2. NAME                      READY   STATUS    RESTARTS   AGE
  3. es-0                      1/1     Running   0          156m
  4. fluentd-es-lhjnr          1/1     Running   0          53s
  5. fluentd-es-tpmlk          1/1     Running   0          64s
  6. kibana-7dc465fbc8-hh95t   1/1     Running   0          75m

Fluentd 启动成功后，这个时候就可以发送日志到 ES 了，但是我们这里是过滤了只采集具有 logging=true 标签的 Pod 日志，所以现在还没有任何数据会被采集。

测试

下面我们部署一个简单的测试应用， 新建 counter.yaml 文件，文件内容如下：

  1. apiVersion: v1
  2. kind: Pod
  3. metadata:
  4.   name: counter
  5.   labels:
  6.     logging: "true"  # 一定要具有该标签才会被采集
  7. spec:
  8.   containers:
  9.   - name: count
  10.     image: busybox
  11.     args: [/bin/sh, -c,
  12.             'i=0; while true; do echo "$i: $(date)"; i=$((i+1)); sleep 1; done']

该 Pod 只是简单将日志信息打印到 stdout，所以正常来说 Fluentd 会收集到这个日志数据，在 Kibana 中也就可以找到对应的日志数据了，使用 kubectl 工具创建该 Pod：

  1. $ kubectl create -f counter.yaml
  2. $ kubectl get pods
  3. NAME                             READY   STATUS    RESTARTS   AGE
  4. counter                          1/1     Running   0          9h

Pod 创建并运行后，回到 Kibana Dashboard 页面，点击左侧最下面的 management 图标，然后点击 Kibana 下面的 Index Patterns 开始导入索引数据：
image.png
在这里可以配置我们需要的 Elasticsearch 索引，前面 Fluentd 配置文件中我们采集的日志使用的是 logstash 格式，定义了一个 k8s 的前缀，所以这里只需要在文本框中输入k8s-*即可匹配到 Elasticsearch 集群中采集的 Kubernetes 集群日志数据，然后点击下一步，进入以下页面：
image.png
在该页面中配置使用哪个字段按时间过滤日志数据，在下拉列表中，选择@timestamp字段，然后点击Create index pattern
image.png

创建完成后，点击左侧导航菜单中的Discover，然后就可以看到一些直方图和最近采集到的日志数据了。
image.png
当我们把鼠标放到搜索栏时，会出现所有字段，我们点击某个需要的字段，就可以筛选我们需要的字段。
image.png

image.png

本文参考整理自https://www.qikqiak.com/post/install-efk-stack-on-k8s/