------> 課程視頻同步分享在今日頭條和B站

大家好，我是博哥愛運維。

OK，到目前為止，我們的服務順利容器化并上了K8s，同時也能通過外部網(wǎng)絡進行請求訪問，相關的服務數(shù)據(jù)也能進行持久化存儲了，那么接下來很關鍵的事情，就是怎么去收集服務產(chǎn)生的日志進行數(shù)據(jù)分析及問題排查，下面會以生產(chǎn)中的經(jīng)驗來詳細講解這些內(nèi)容。

K8S日志收集體系

現(xiàn)在市面上大多數(shù)課程都是以EFK來作來K8s項目的日志解決方案，它包括三個組件：Elasticsearch, Fluentd（filebeat）, Kibana；Elasticsearch 是日志存儲和日志搜索引擎，F(xiàn)luentd 負責把k8s集群的日志發(fā)送給 Elasticsearch, Kibana 則是可視化界面查看和檢索存儲在 Elasticsearch 的數(shù)據(jù)。

但根據(jù)生產(chǎn)中實際使用情況來看，它有以下弊端：

1、日志收集籠統(tǒng)
EFK是在每個kubernetes的NODE節(jié)點以daemonset的形式啟動一個fluentd的pod，來收集NODE節(jié)點上的日志，如容器日志（/var/log/containers/*.log），但里面無法作細分，想要的和不想要的都收集進來了，帶來的后面就是磁盤IO壓力會比較大，日志過濾麻煩。

2、無法收集對應POD里面的業(yè)務日志
上面第1點只能收集pod的stdout日志，但是pod內(nèi)如有需要收集的業(yè)務日志，像pod內(nèi)的/tmp/datalog/*.log，那EFK是無能為力的，只能是在pod內(nèi)啟動多個容器（filebeat）去收集容器內(nèi)日志，但這又會帶來的是pod多容器性能的損耗，這個接下來會詳細講到。

3、fluentd的采集速率性能較低，只能不到filebeat的1/10的性能。

基于此，我通過調(diào)研發(fā)現(xiàn)了阿里開源的智能容器采集工具 Log-Pilot，github地址：https://github.com/AliyunContainerService/log-pilot

下面以sidecar 模式和log-pilot這兩種方式的日志收集形式做個詳細對比說明：

第一種模式是 sidecar 模式，這種需要我們在每個 Pod 中都附帶一個 logging 容器來進行本 Pod 內(nèi)部容器的日志采集，一般采用共享卷的方式，但是對于這一種模式來說，很明顯的一個問題就是占用的資源比較多，尤其是在集群規(guī)模比較大的情況下，或者說單個節(jié)點上容器特別多的情況下，它會占用過多的系統(tǒng)資源，同時也對日志存儲后端占用過多的連接數(shù)。當我們的集群規(guī)模越大，這種部署模式引發(fā)的潛在問題就越大。

另一種模式是 Node 模式，這種模式是我們在每個 Node 節(jié)點上僅需布署一個 logging 容器來進行本 Node 所有容器的日志采集。這樣跟前面的模式相比最明顯的優(yōu)勢就是占用資源比較少，同樣在集群規(guī)模比較大的情況下表現(xiàn)出的優(yōu)勢越明顯，同時這也是社區(qū)推薦的一種模式。

經(jīng)過多方面測試，log-pilot對現(xiàn)有業(yè)務pod侵入性很小，只需要在原有pod的內(nèi)傳入幾行env環(huán)境變量，即可對此pod相關的日志進行收集，已經(jīng)測試了后端接收的工具有l(wèi)ogstash、elasticsearch、kafka、redis、file，均OK，下面開始部署整個日志收集環(huán)境。

我們這里用一個tomcat服務來模擬業(yè)務服務，用log-pilot分別收集它的stdout以及容器內(nèi)的業(yè)務數(shù)據(jù)日志文件到指定后端存儲，2023課程會以真實生產(chǎn)的一個日志傳輸架構來做測試：

模擬業(yè)務服務   日志收集       日志存儲     消費日志         消費目的服務
tomcat ---> log-pilot ---> kafka ---> filebeat ---> elasticsearch ---> kibana

1、部署測試用的kafka

Apache Kafka是一種流行的分布式消息傳遞系統(tǒng)，設計用于處理大規(guī)模的數(shù)據(jù)流。它在日志傳輸和流數(shù)據(jù)處理領域尤為重要。以下是Kafka的一些關鍵特性，以及它們?nèi)绾芜m用于日志傳輸體系：

1. 高吞吐量和可伸縮性：
   • Kafka能夠處理高速數(shù)據(jù)流，支持大量數(shù)據(jù)的讀寫操作。它通過分區(qū)（partitions）和分布式架構來實現(xiàn)高吞吐量和水平擴展。
   • 在日志傳輸中，這意味著Kafka可以高效地收集和分發(fā)大量的日志數(shù)據(jù)，滿足大型系統(tǒng)的需求。
2. 持久性和可靠性：
   • Kafka將數(shù)據(jù)存儲在磁盤上，并支持數(shù)據(jù)的復制，確保信息不會因為單點故障而丟失。
   • 對于日志管理來說，這確保了日志數(shù)據(jù)的安全和完整性，即使在系統(tǒng)故障的情況下也能保持日志的可用性。
3. 實時處理：
   • Kafka支持實時數(shù)據(jù)流處理，使得數(shù)據(jù)在產(chǎn)生后立即可用。
   • 在日志系統(tǒng)中，這允許實時監(jiān)控和分析日志數(shù)據(jù)，有助于快速故障排除和系統(tǒng)性能監(jiān)控。
4. 分布式架構：
   • Kafka的分布式特性意味著它可以跨多個服務器和數(shù)據(jù)中心運行，提高了容錯能力和系統(tǒng)的穩(wěn)定性。
   • 在分布式日志系統(tǒng)中，這有助于管理跨地域或多個服務的日志數(shù)據(jù)，提供更好的可擴展性和冗余。
5. 靈活的消費模型：
   • Kafka支持發(fā)布-訂閱和隊列兩種消息模式，使消費者能夠靈活地讀取數(shù)據(jù)。
   • 日志傳輸中，這使得不同的系統(tǒng)和應用可以根據(jù)需要訂閱特定類型的日志數(shù)據(jù)。
6. 低延遲：
   • Kafka設計用于低延遲消息傳遞，這對于需要快速響應的日志分析和監(jiān)控系統(tǒng)至關重要。

結合日志傳輸體系，Kafka的這些特性使其成為一個理想的中央日志聚合點。它不僅能夠高效地收集來自不同源的日志數(shù)據(jù)，還能將這些數(shù)據(jù)實時分發(fā)給各種日志分析和監(jiān)控工具，支持大數(shù)據(jù)分析、實時監(jiān)控和快速故障檢測。

在Apache Kafka中，幾個核心概念包括主題（Topic）、分區(qū)（Partition）和消費組（Consumer Group）。這些概念是Kafka高效消息處理和分布式數(shù)據(jù)流管理的基石。下面是對這些概念的簡要介紹：

1. 主題 (Topic):
   • Kafka中的主題是消息的分類或者說是一個消息通道。生產(chǎn)者（Producers）將消息發(fā)送到特定的主題，而消費者（Consumers）從主題中讀取消息。
   • 主題可以被視為消息的邏輯分類。每個主題可以有多個生產(chǎn)者向其發(fā)送數(shù)據(jù)，也可以有多個消費者從中讀取數(shù)據(jù)。
2. 分區(qū) (Partition):
   • 為了提高可伸縮性和并行處理能力，Kafka中的每個主題可以被分割成多個分區(qū)。
   • 分區(qū)允許主題中的消息在多個服務器（Broker）之間分布，從而實現(xiàn)數(shù)據(jù)的負載均衡和并行處理。每個分區(qū)都是有序且不變的消息序列。
   • 每條消息在被添加到分區(qū)時都會被賦予一個唯一的序列號，稱為偏移量（Offset）。
   • 生產(chǎn)者在發(fā)送消息時可以指定消息應該發(fā)送到哪個分區(qū)，或者讓Kafka根據(jù)消息的Key自動選擇分區(qū)。
3. 消費組 (Consumer Group):
   • 消費者可以單獨工作，也可以作為消費組的一部分來消費消息。消費組允許一組消費者共同訂閱一個或多個主題，并協(xié)作消費消息。
   • 在一個消費組內(nèi)，每個分區(qū)的消息只會被組內(nèi)的一個消費者讀取。這保證了消息只被消費一次，同時實現(xiàn)了負載均衡。
   • 如果一個消費組有多個消費者，Kafka會自動將主題的分區(qū)分配給不同的消費者，以實現(xiàn)并行處理。
   • 消費組的概念使得Kafka可以靈活地支持多種消費模式，包括發(fā)布-訂閱和點對點。

結合日志傳輸體系，這些特性使Kafka能夠有效地處理來自多個源的大量日志數(shù)據(jù)。主題和分區(qū)支持高吞吐量的數(shù)據(jù)寫入和讀取，而消費組則允許多個消費者協(xié)作，確保日志數(shù)據(jù)的高效處理和分析。通過這種方式，Kafka可以作為一個強大的中央日志聚合系統(tǒng)，支持復雜的日志處理和分析需求。

準備一個測試用的kafka服務

# 部署前準備 10.0.1.201(這臺作為二進制k8s集群的部署節(jié)點，上面會是裝好docker服務的狀態(tài))

# 準備好 docker-compose 命令
ln -svf /etc/kubeasz/bin/docker-compose /usr/bin/docker-compose

# 準備好文件 docker-compose.yml：
#——------------------------------
version: '2'
services:
  zookeeper:
    image: bogeit/zookeeper
    ports:
      - "2181:2181"
    restart: unless-stopped

  kafka:
    image: bogeit/kafka:2.8.1
    ports:
      - "9092:9092"
    environment:
      DOCKER_API_VERSION: 1.22
      KAFKA_ADVERTISED_HOST_NAME: 10.0.1.201
      KAFKA_ZOOKEEPER_CONNECT: zookeeper:2181
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - /mnt/kafka:/kafka
    restart: unless-stopped

#——------------------------------

# 1. docker-compose setup:
# docker-compose up -d
Recreating kafka-docker-compose_kafka_1   ... done
Starting kafka-docker-compose_zookeeper_1 ... done

# 2. result look:
# docker-compose ps
              Name                            Command               State                    Ports                  
--------------------------------------------------------------------------------------------------------------------
kafka-docker-compose_kafka_1       start-kafka.sh                   Up      0.0.0.0:9092->9092/tcp                  
kafka-docker-compose_zookeeper_1   /bin/sh -c /usr/sbin/sshd  ...   Up      0.0.0.0:2181->2181/tcp, 22/tcp,         
                                                                            2888/tcp, 3888/tcp                      
# 3. run test-docker
bash-4.4# docker run --rm -v /var/run/docker.sock:/var/run/docker.sock -e HOST_IP=10.0.1.201 -e ZK=10.0.1.201:2181 -i -t wurstmeister/kafka /bin/bash

# 4. list topic
bash-4.4# kafka-topics.sh --zookeeper 10.0.1.201:2181 --list
tomcat-access
tomcat-syslog

# 5. consumer topic data:
bash-4.4# kafka-console-consumer.sh --bootstrap-server 10.0.1.201:9092 --topic tomcat-access --from-beginning

2、部署日志收集服務 log-pilot (適配容器運行時 Containerd)

# 先創(chuàng)建一個namespace
kubectl create ns ns-elastic

# 部署yaml


---
apiVersion: v1
kind: ConfigMap
metadata:
  name: log-pilot5-configuration
  namespace: ns-elastic
data:
  logging_output: "kafka"
  kafka_brokers: "10.0.1.201:9092"
  kafka_version: "0.10.0"
  kafka_topics: "tomcat-syslog,tomcat-access"
  #kafka_username: "user"
  #kafka_password: "bogeit"

---
apiVersion: v1
data:
  filebeat.tpl: |+
    {{range .configList}}
    - type: log
      enabled: true
      paths:
          - {{ .HostDir }}/{{ .File }}
      scan_frequency: 5s
      fields_under_root: true
      {{if eq .Format "json"}}
      json.keys_under_root: true
      {{end}}
      fields:
          {{range $key, $value := .Tags}}
          {{ $key }}: {{ $value }}
          {{end}}
          {{range $key, $value := $.container}}
          {{ $key }}: {{ $value }}
          {{end}}
      tail_files: false
      close_inactive: 2h
      close_eof: false
      close_removed: true
      clean_removed: true
      close_renamed: false

    {{end}}

kind: ConfigMap
metadata:
  name: filebeat5-tpl
  namespace: ns-elastic

---
apiVersion: v1
data:
  config.filebeat: |+
    #!/bin/sh

    set -e

    FILEBEAT_CONFIG=/etc/filebeat/filebeat.yml
    if [ -f "$FILEBEAT_CONFIG" ]; then
        echo "$FILEBEAT_CONFIG has been existed"
        exit
    fi

    mkdir -p /etc/filebeat/prospectors.d

    assert_not_empty() {
        arg=$1
        shift
        if [ -z "$arg" ]; then
            echo "$@"
            exit 1
        fi
    }

    cd $(dirname $0)

    base() {
    cat >> $FILEBEAT_CONFIG << EOF
    path.config: /etc/filebeat
    path.logs: /var/log/filebeat
    path.data: /var/lib/filebeat/data
    filebeat.registry_file: /var/lib/filebeat/registry
    filebeat.shutdown_timeout: ${FILEBEAT_SHUTDOWN_TIMEOUT:-0}
    logging.level: ${FILEBEAT_LOG_LEVEL:-info}
    logging.metrics.enabled: ${FILEBEAT_METRICS_ENABLED:-false}
    logging.files.rotateeverybytes: ${FILEBEAT_LOG_MAX_SIZE:-104857600}
    logging.files.keepfiles: ${FILEBEAT_LOG_MAX_FILE:-10}
    logging.files.permissions: ${FILEBEAT_LOG_PERMISSION:-0600}
    ${FILEBEAT_MAX_PROCS:+max_procs: ${FILEBEAT_MAX_PROCS}}
    setup.template.name: "${FILEBEAT_INDEX:-filebeat}"
    setup.template.pattern: "${FILEBEAT_INDEX:-filebeat}-*"
    filebeat.config:
        prospectors:
            enabled: true
            path: \${path.config}/prospectors.d/*.yml
            reload.enabled: true
            reload.period: 10s
    EOF
    }

    es() {
    if [ -f "/run/secrets/es_credential" ]; then
        ELASTICSEARCH_USER=$(cat /run/secrets/es_credential | awk -F":" '{ print $1 }')
        ELASTICSEARCH_PASSWORD=$(cat /run/secrets/es_credential | awk -F":" '{ print $2 }')
    fi

    if [ -n "$ELASTICSEARCH_HOSTS" ]; then
        ELASTICSEARCH_HOSTS=$(echo $ELASTICSEARCH_HOSTS|awk -F, '{for(i=1;i<=NF;i++){printf "\"%s\",", $i}}')
        ELASTICSEARCH_HOSTS=${ELASTICSEARCH_HOSTS%,}
    else
        assert_not_empty "$ELASTICSEARCH_HOST" "ELASTICSEARCH_HOST required"
        assert_not_empty "$ELASTICSEARCH_PORT" "ELASTICSEARCH_PORT required"
        ELASTICSEARCH_HOSTS="\"$ELASTICSEARCH_HOST:$ELASTICSEARCH_PORT\""
    fi

    cat >> $FILEBEAT_CONFIG << EOF
    $(base)
    output.elasticsearch:
        hosts: [$ELASTICSEARCH_HOSTS]
        index: ${ELASTICSEARCH_INDEX:-filebeat}-%{+yyyy.MM.dd}
        ${ELASTICSEARCH_SCHEME:+protocol: ${ELASTICSEARCH_SCHEME}}
        ${ELASTICSEARCH_USER:+username: ${ELASTICSEARCH_USER}}
        ${ELASTICSEARCH_PASSWORD:+password: ${ELASTICSEARCH_PASSWORD}}
        ${ELASTICSEARCH_WORKER:+worker: ${ELASTICSEARCH_WORKER}}
        ${ELASTICSEARCH_PATH:+path: ${ELASTICSEARCH_PATH}}
        ${ELASTICSEARCH_BULK_MAX_SIZE:+bulk_max_size: ${ELASTICSEARCH_BULK_MAX_SIZE}}
    EOF
    }

    default() {
    echo "use default output"
    cat >> $FILEBEAT_CONFIG << EOF
    $(base)
    output.console:
        pretty: ${CONSOLE_PRETTY:-false}
    EOF
    }

    file() {
    assert_not_empty "$FILE_PATH" "FILE_PATH required"

    cat >> $FILEBEAT_CONFIG << EOF
    $(base)
    output.file:
        path: $FILE_PATH
        ${FILE_NAME:+filename: ${FILE_NAME}}
        ${FILE_ROTATE_SIZE:+rotate_every_kb: ${FILE_ROTATE_SIZE}}
        ${FILE_NUMBER_OF_FILES:+number_of_files: ${FILE_NUMBER_OF_FILES}}
        ${FILE_PERMISSIONS:+permissions: ${FILE_PERMISSIONS}}
    EOF
    }

    logstash() {
    assert_not_empty "$LOGSTASH_HOST" "LOGSTASH_HOST required"
    assert_not_empty "$LOGSTASH_PORT" "LOGSTASH_PORT required"

    cat >> $FILEBEAT_CONFIG << EOF
    $(base)
    output.logstash:
        hosts: ["$LOGSTASH_HOST:$LOGSTASH_PORT"]
        index: ${FILEBEAT_INDEX:-filebeat}-%{+yyyy.MM.dd}
        ${LOGSTASH_WORKER:+worker: ${LOGSTASH_WORKER}}
        ${LOGSTASH_LOADBALANCE:+loadbalance: ${LOGSTASH_LOADBALANCE}}
        ${LOGSTASH_BULK_MAX_SIZE:+bulk_max_size: ${LOGSTASH_BULK_MAX_SIZE}}
        ${LOGSTASH_SLOW_START:+slow_start: ${LOGSTASH_SLOW_START}}
    EOF
    }

    redis() {
    assert_not_empty "$REDIS_HOST" "REDIS_HOST required"
    assert_not_empty "$REDIS_PORT" "REDIS_PORT required"

    cat >> $FILEBEAT_CONFIG << EOF
    $(base)
    output.redis:
        hosts: ["$REDIS_HOST:$REDIS_PORT"]
        key: "%{[fields.topic]:filebeat}"
        ${REDIS_WORKER:+worker: ${REDIS_WORKER}}
        ${REDIS_PASSWORD:+password: ${REDIS_PASSWORD}}
        ${REDIS_DATATYPE:+datatype: ${REDIS_DATATYPE}}
        ${REDIS_LOADBALANCE:+loadbalance: ${REDIS_LOADBALANCE}}
        ${REDIS_TIMEOUT:+timeout: ${REDIS_TIMEOUT}}
        ${REDIS_BULK_MAX_SIZE:+bulk_max_size: ${REDIS_BULK_MAX_SIZE}}
    EOF
    }

    kafka() {
    assert_not_empty "$KAFKA_BROKERS" "KAFKA_BROKERS required"
    KAFKA_BROKERS=$(echo $KAFKA_BROKERS|awk -F, '{for(i=1;i<=NF;i++){printf "\"%s\",", $i}}')
    KAFKA_BROKERS=${KAFKA_BROKERS%,}

    cat >> $FILEBEAT_CONFIG << EOF
    $(base)
    output.kafka:
        hosts: [$KAFKA_BROKERS]
        topic: '%{[topic]}'
        codec.format:
            string: '%{[message]}'
        ${KAFKA_VERSION:+version: ${KAFKA_VERSION}}
        ${KAFKA_USERNAME:+username: ${KAFKA_USERNAME}}
        ${KAFKA_PASSWORD:+password: ${KAFKA_PASSWORD}}
        ${KAFKA_WORKER:+worker: ${KAFKA_WORKER}}
        ${KAFKA_PARTITION_KEY:+key: ${KAFKA_PARTITION_KEY}}
        ${KAFKA_PARTITION:+partition: ${KAFKA_PARTITION}}
        ${KAFKA_CLIENT_ID:+client_id: ${KAFKA_CLIENT_ID}}
        ${KAFKA_METADATA:+metadata: ${KAFKA_METADATA}}
        ${KAFKA_BULK_MAX_SIZE:+bulk_max_size: ${KAFKA_BULK_MAX_SIZE}}
        ${KAFKA_BROKER_TIMEOUT:+broker_timeout: ${KAFKA_BROKER_TIMEOUT}}
        ${KAFKA_CHANNEL_BUFFER_SIZE:+channel_buffer_size: ${KAFKA_CHANNEL_BUFFER_SIZE}}
        ${KAFKA_KEEP_ALIVE:+keep_alive ${KAFKA_KEEP_ALIVE}}
        ${KAFKA_MAX_MESSAGE_BYTES:+max_message_bytes: ${KAFKA_MAX_MESSAGE_BYTES}}
        ${KAFKA_REQUIRE_ACKS:+required_acks: ${KAFKA_REQUIRE_ACKS}}
    EOF
    }

    count(){
    cat >> $FILEBEAT_CONFIG << EOF
    $(base)
    output.count:
    EOF
    }

    if [ -n "$FILEBEAT_OUTPUT" ]; then
        LOGGING_OUTPUT=$FILEBEAT_OUTPUT
    fi

    case "$LOGGING_OUTPUT" in
        elasticsearch)
            es;;
        logstash)
            logstash;;
        file)
            file;;
        redis)
            redis;;
        kafka)
            kafka;;
        count)
            count;;
        *)
            default
    esac



kind: ConfigMap
metadata:
  name: config5.filebeat
  namespace: ns-elastic

---
apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: log-pilot5
  namespace: ns-elastic
  labels:
    k8s-app: log-pilot5
spec:
  updateStrategy:
    type: RollingUpdate
  selector:
    matchLabels:
      k8s-app: log-pilot5
  template:
    metadata:
      labels:
        k8s-app: log-pilot5
    spec:
      tolerations:
      - key: node-role.kubernetes.io/master
        effect: NoSchedule
      - effect: NoSchedule
        key: ToBeDeletedByClusterAutoscaler
        operator: Exists
      containers:
      - name: log-pilot5
        image: williamguozi/log-pilot-filebeat:containerd
        imagePullPolicy: IfNotPresent
        env:
          - name: "LOGGING_OUTPUT"
            valueFrom:
              configMapKeyRef:
                name: log-pilot5-configuration
                key: logging_output
          - name: "KAFKA_BROKERS"
            valueFrom:
              configMapKeyRef:
                name: log-pilot5-configuration
                key: kafka_brokers
          - name: "KAFKA_VERSION"
            valueFrom:
              configMapKeyRef:
                name: log-pilot5-configuration
                key: kafka_version
          - name: "KAFKA_USERNAME"
            valueFrom:
              configMapKeyRef:
                name: log-pilot5-configuration
                key: kafka_username
          - name: "KAFKA_PASSWORD"
            valueFrom:
              configMapKeyRef:
                name: log-pilot5-configuration
                key: kafka_password
          - name: "NODE_NAME"
            valueFrom:
              fieldRef:
                fieldPath: spec.nodeName
        volumeMounts:
        - name: sock
          mountPath: /var/run/containerd/containerd.sock
        - name: logs
          mountPath: /var/log/filebeat
        - name: state
          mountPath: /var/lib/filebeat
        - name: root
          mountPath: /host
          readOnly: true
        - name: localtime
          mountPath: /etc/localtime
        - name: config-volume
          mountPath: /etc/filebeat/config
        - name: filebeat-tpl
          mountPath: /pilot/filebeat.tpl
          subPath: filebeat.tpl
        - name: config-filebeat
          mountPath: /pilot/config.filebeat
          subPath: config.filebeat
        securityContext:
          capabilities:
            add:
            - SYS_ADMIN
      terminationGracePeriodSeconds: 30
      volumes:
      - name: sock
        hostPath:
          path: /var/run/containerd/containerd.sock
          type: Socket
      - name: logs
        hostPath:
          path: /var/log/filebeat
          type: DirectoryOrCreate
      - name: state
        hostPath:
          path: /var/lib/filebeat
          type: DirectoryOrCreate
      - name: root
        hostPath:
          path: /
          type: Directory
      - name: localtime
        hostPath:
          path: /etc/localtime
          type: File
      - name: config-volume
        configMap:
          name: log-pilot5-configuration
          items:
          - key: kafka_topics
            path: kafka_topics
      - name: filebeat-tpl
        configMap:
          name: filebeat5-tpl
      - name: config-filebeat
        configMap:
          name: config5.filebeat
          defaultMode: 0777

3、部署測試用的tomcat服務

vim tomcat-test.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    app: tomcat
  name: tomcat
spec:
  replicas: 1
  selector:
    matchLabels:
      app: tomcat
  template:
    metadata:
      labels:
        app: tomcat
    spec:
      tolerations:
      - key: "node-role.kubernetes.io/master"
        effect: "NoSchedule"
      containers:
      - name: tomcat
        image: "tomcat:7.0"
        env:      # 注意點一，添加相應的環(huán)境變量（下面收集了兩塊日志1、stdout 2、/usr/local/tomcat/logs/catalina.*.log）
        - name: aliyun_logs_tomcat-syslog   # 如日志發(fā)送到es，那index名稱為 tomcat-syslog
          value: "stdout"
        - name: aliyun_logs_tomcat-access   # 如日志發(fā)送到es，那index名稱為 tomcat-access
          value: "/usr/local/tomcat/logs/catalina.*.log"
        volumeMounts:   # 注意點二，對pod內(nèi)要收集的業(yè)務日志目錄需要進行共享，可以收集多個目錄下的日志文件
          - name: tomcat-log
            mountPath: /usr/local/tomcat/logs
      volumes:
        - name: tomcat-log
          emptyDir: {}

4、部署es 和 kibana

這里的elasticsearch和kibana服務我們就用上節(jié)課部署的服務接著使用即可

第25關 利用operator部署生產(chǎn)級別的Elasticserach集群和kibana文章來源地址http://www.zghlxwxcb.cn/news/detail-769571.html

5、部署 filebeat 服務

---
apiVersion: v1
kind: ConfigMap
metadata:
  name: filebeat-config-test
data:
  filebeat.yml: |
    filebeat.inputs:
    - type: kafka
      hosts: ["10.0.1.201:9092"]
      topics: ["tomcat-syslog"]
      group_id: "filebeat"
      #username: "$ConnectionString"
      #password: "<your connection string>"
      ssl.enabled: false
    filebeat.shutdown_timeout: 30s
    output:
      elasticsearch:
        enabled: true
        hosts: ['quickstart-es-http.es:9200']
        username: elastic
        password: 5e84VTJBPO3H84Ec5xt43fc3
        indices:
          - index: "test-%{+yyyy.MM.dd}"
    logging.level: info


---

apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    app-name: filebeat
  name: filebeat-test
spec:
  replicas: 1
  selector:
    matchLabels:
      app-name: filebeat
  template:
    metadata:
      labels:
        app-name: filebeat
    spec:
      containers:
      - command:
        - filebeat
        - -e
        - -c
        - /etc/filebeat.yml
        env:
        - name: TZ
          value: Asia/Shanghai
        image: docker.io/elastic/filebeat:8.11.3
        imagePullPolicy: IfNotPresent
        name: filebeat
        resources:
          limits:
            cpu: 100m
            memory: 200M
          requests:
            cpu: 100m
            memory: 200M
        volumeMounts:
        - mountPath: /etc/filebeat.yml
          name: filebeat-config
          subPath: filebeat.yml
      volumes:
      - configMap:
          defaultMode: 420
          name: filebeat-config-test
        name: filebeat-config

到了這里，關于第26關 K8s日志收集揭秘：利用Log-pilot收集POD內(nèi)業(yè)務日志文件的文章就介紹完了。如果您還想了解更多內(nèi)容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關文章，希望大家以后多多支持TOY模板網(wǎng)！