ELK架构即周边知识

最新推荐文章于 2023-07-11 20:15:13 发布
最新推荐文章于 2023-07-11 20:15:13 发布
阅读量151 收藏 1
点赞数
文章标签： 搜索引擎 elasticsearch linux java es
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_37700260/article/details/108806825
版权

1. ELK简介

ELK 不是一款软件，而是 Elasticsearch、Logstash 和 Kibana 三种软件产品的首字母缩写。这三者都是开源软件，通常配合使用，而且又先后归于 Elastic.co 公司名下，所以被简称为 ELK Stack。根据 Google Trend 的信息显示，ELK Stack 已经成为目前最流行的集中式日志解决方案。

  • Elasticsearch：分布式搜索和分析引擎，具有高可伸缩、高可靠和易管理等特点。基于 Apache Lucene 构建，能对大容量的数据进行接近实时的存储、搜索和分析操作。通常被用作某些应用的基础搜索引擎，使其具有复杂的搜索功能；

  • Logstash：数据收集引擎。它支持动态的从各种数据源搜集数据，并对数据进行过滤、分析、丰富、统一格式等操作，然后存储到用户指定的位置；

  • Kibana：数据分析和可视化平台。通常与 Elasticsearch 配合使用，对其中数据进行搜索、分析和以统计图表的方式展示；

  • Filebeat：ELK 协议栈的新成员，一个轻量级开源日志文件数据搜集器，基于 Logstash-Forwarder 源代码开发，是对它的替代。在需要采集日志数据的 server 上安装 Filebeat，并指定日志目录或日志文件后，Filebeat 就能读取数据，迅速发送到 Logstash 进行解析，亦或直接发送到 Elasticsearch 进行集中式存储和分析。

2. EKL常用架构和使用场景

1. 最简单的架构

在这种架构中，只有一个 Logstash、Elasticsearch 和 Kibana 实例。Logstash 通过输入插件从多种数据源（比如日志文件、标准输入 Stdin 等）获取数据，再经过滤插件加工数据，然后经 Elasticsearch 输出插件输出到 Elasticsearch，通过 Kibana 展示。详见图 1。

图 1. 最简单架构

2. logstash作为日志搜集器

这种架构是对上面架构的扩展，把一个 Logstash 数据搜集节点扩展到多个，分布于多台机器，将解析好的数据发送到 Elasticsearch server 进行存储，最后在 Kibana 查询、生成日志报表等。详见图 2。

图 2. Logstash 作为日志搜索器

这种结构因为需要在各个服务器上部署 Logstash，而logstash比较消耗 CPU 和内存资源，所以比较适合计算资源丰富的服务器，否则容易造成服务器性能下降，甚至可能导致无法正常工作。

3. Beats作为日志搜集器

这种架构引入 Beats 作为日志搜集器。目前 Beats 包括四种：

  • Packetbeat（搜集网络流量数据）；

  • Topbeat（搜集系统、进程和文件系统级别的 CPU 和内存使用情况等数据）；

  • Filebeat（搜集文件数据）；

  • Winlogbeat（搜集 Windows 事件日志数据）。

Beats 将搜集到的数据发送到 Logstash，经 Logstash 解析、过滤后，将其发送到 Elasticsearch 存储，并由 Kibana 呈现给用户。详见图 3。

图 3. Beats 作为日志搜集器

这种架构解决了 Logstash 在各服务器节点上占用系统资源高的问题。相比 Logstash，Beats 所占系统的 CPU 和内存几乎可以忽略不计。另外，Beats 和 Logstash 之间支持 SSL/TLS 加密传输，客户端和服务器双向认证，保证了通信安全。

因此这种架构适合对数据安全性要求较高，同时各服务器性能比较敏感的场景。

4. 基于FileBeat架构的配置部署详解

3. 使用filebeat

filebeat主要用于收集和转发日志。filebeat监视指定的日志文件和位置，收集日志事件，并将它们转发到es或logstash进行索引。

安装

官网：https://www.elastic.co/guide/en/beats/filebeat/current/filebeat-installation.html

# curl -L -O https://artifacts.elastic.co/downloads/beats/filebeat/filebeat-6.5.2-x86_64.rpm
# sudo rpm -vi filebeat-6.5.2-x86_64.rpm

Filebeat的工作原理：启动Filebeat时，它会启动一个或多个inputs，这些inputs将查找指定的log的路径。对于查找到的每个日志，Filebeat将启动一个harvester。每个harvester读取单个日志的新内容，并将新日志数据发送到libbeat，libbeat聚合事件并将聚合数据发送到配置的output。

我们采用的是 filebeat -> kafka ->logstash -> es。

配置文件

filebeat 配置文件比较简单, 只需要配置一个filebeat.yml

input

#============== Filebeat prospectors ===========
filebeat.inputs:   # 6.3以前是 filebeat.prospectors:
- type: log        # input类型,默认为log，6.0以前配置是 - input_type: log
  paths:
    - /var/log/java/test-java.log
    - /var/log/java/*.log
    - /var/log/*/*.log
  fields:          
    log_topic: java_log     # 附加的可选字段,以向output添加额外的信息。output里面可以使用这个变量
  multiline.pattern: '^\['   #多行合并 同logstash的multiline用法相似
  multiline.negate: true
  multiline.match: after
 
- type: log     # 一个配置文件里面可以同时收集多个日志
  enabled: true
  paths:
    - /var/log/nginx/*.log
  fields:
    my_log_topic: nginx_log

常用配置

type:  指定input类型，有log、stdin、redis、tcp、syslog等

fields： 可以自定义添加字段，到output中去，后续可以使用这些字段，例如：

  fields:
    log_topic: mysql_slow  
    idc: szjf

tail_files: 默认为false。配置为true时，filebeat将从新文件的最后位置开始读取,而不是从开头读取新文件， 注意：如果配合日志轮循使用，新文件的第一行将被跳过。

此选项适用于Filebeat尚未处理的文件。如果先前运行了Filebeat并且文件的状态已经保留，tail_files则不会应用。

第一次运行Filebeat时，可以使用 tail_files: true 来避免索引旧的日志行。第一次运行后，建议禁用此选项。

registry filefilebeat会将自己处理日志文件的进度信息写入到registry文件中，以保证filebeat在重启之后能够接着处理未处理过的数据，而无需从头开始。

如果要让filebeat从头开始读文件，需要停止filebeat，然后删除registry file:

systemctl stop filebeat ;rm -fr /var/lib/filebeat/registry/* ; systemctl start filebaet

registry文件里字段的解释：

  • source： 日志文件的路径

  • offset：已经采集的日志的字节数;已经采集到日志的哪个字节位置

  • inode： 日志文件的inode号

  • device： 日志所在的磁盘编号

  • timestamp： 日志最后一次发生变化的时间戳

  • ttl： 采集失效时间，-1表示只要日志存在，就一直采集该日志

multiline:  https://www.elastic.co/guide/en/beats/filebeat/current/multiline-examples.html#multiline 处理多行合并

output

配置输出的位置，比如kafka，logstash，es，redis，file 等

#================================ Outputs =====================================
#-------------------------Kafka output ------------------------------
output.kafka:
  hosts: ["kafka01:9092","kafka02:9092","kafka03:9092]
  topic: '%{[fields.my_log_topic]}'
  partition.round_robin:
    reachable_only: false
  version: 0.10.0.0
  required_acks: 1
  compression: none
  max_message_bytes: 1000000
#output.logstash:
#  hosts: ["localhost:5044"]

还可以有一些其他配置，比如processor处理器配置（不是必需的）

#====================Preocessors=====================
processors:
  - drop_fields:    #删除字段，不再kibana里面展示，默认情况kibana里面会自动展示这些beat字段
      fields: ["beat.hostname","beat.version","beat.name","prospector.type","input.type"]


#也可以在logstash里面通过remove_field 删除字段
#mutate{
#        remove_field => ["[beat][hostname]","[beat][version]","input","prospector"]
#    }

配置完filebeat.yml，启动filebeat 即可。# /etc/init.d/filebeat start

4. es的分词器

es的分词器是es的主要核心功能， 在elasticsearch的plugins的目录下：可能设置自己的分词器，也可以自定义分词器。

分词器使用的两个情形：

  1. Index time analysis. 创建或者更新文档时，会对文档进行分词

  2. Search time analysis. 查询时，对查询语句分词

1. 指定查询时使用哪个分词器的方式有：

  • 查询时通过analyzer指定分词器

GET test_index/_search
{
  "query": {
    "match": {
      "name": {
        "query": "lin",
        "analyzer": "standard"
      }
    }
  }
}

  • 创建index mapping时指定search_analyzer

PUT test_index
{
  "mappings": {
    "doc": {
      "properties": {
        "title":{
          "type": "text",
          "analyzer": "whitespace",
          "search_analyzer": "standard"
        }
      }
    }
  }
}

索引时分词是通过配置 Index mapping中的每个字段的参数analyzer指定的

# 不指定分词时，会使用默认的standard
PUT test_index
{
  "mappings": {
    "doc": {
      "properties": {
        "title":{
          "type": "text",
          "analyzer": "whitespace"     #指定分词器，es内置有多种analyzer
        }
      }
    }}}

注意：

  • 明确字段是否需要分词，不需要分词的字段将type设置为keyword，可以节省空间和提高写性能。

2. 查看和设置分词器

1.查看

GET _analyze
{
  "analyzer": "standard",
  "text": "this is a test"
}
# 可以查看text的内容使用standard分词后的结果

{
  "tokens": [
    {
      "token": "this",
      "start_offset": 0,
      "end_offset": 4,
      "type": "<ALPHANUM>",
      "position": 0
    },
    {
      "token": "is",
      "start_offset": 5,
      "end_offset": 7,
      "type": "<ALPHANUM>",
      "position": 1
    },
    {
      "token": "a",
      "start_offset": 8,
      "end_offset": 9,
      "type": "<ALPHANUM>",
      "position": 2
    },
    {
      "token": "test",
      "start_offset": 10,
      "end_offset": 14,
      "type": "<ALPHANUM>",
      "position": 3
    }
  ]
}

2. 设置分词器

PUT test
{
  "settings": {
    "analysis": {    #自定义分词器
      "analyzer": {      # 关键字
        "my_analyzer":{   # 自定义的分词器
          "type":"standard",    #分词器类型standard
          "stopwords":"_english_"   #standard分词器的参数，默认的stopwords是\_none_
        }
      }
    }
  },
  "mappings": {
    "doc":{
      "properties": {
        "my_text":{
          "type": "text",
          "analyzer": "standard",  # my_text字段使用standard分词器
          "fields": {
            "english":{            # my_text.english字段使用上面自定义得my_analyzer分词器
              "type": "text", 
              "analyzer": "my_analyzer"
            }}}}}}}
POST test/_analyze
{
  "field": "my_text",    # my_text字段使用的是standard分词器
  "text": ["The test message."]
}
-------------->[the,test,message]

POST test/_analyze
{
  "field": "my_text.english",     #my_text.english使用的是my_analyzer分词器
  "text": ["The test message."]
}
------------>[test,message]

3. es内置了多种analyzer

  • standard  由以下组成

    • tokenizer：Standard Tokenizer

    • token filter：Standard Token Filter，Lower Case Token Filter，Stop Token Filter

analyzer API测试 ：
POST _analyze
{
  "analyzer": "standard",
  "text": "The 2 QUICK Brown-Foxes jumped over the lazy dog's bone."
}

得到结果：

{
  "tokens": [
    {
      "token": "the",
      "start_offset": 0,
      "end_offset": 3,
      "type": "<ALPHANUM>",
      "position": 0
    },
    {
      "token": "2",
      "start_offset": 4,
      "end_offset": 5,
      "type": "<NUM>",
      "position": 1
    },
    {
      "token": "quick",
      "start_offset": 6,
      "end_offset": 11,
      "type": "<ALPHANUM>",
      "position": 2
    },
    {
      "token": "brown",
      "start_offset": 12,
      "end_offset": 17,
      "type": "<ALPHANUM>",
      "position": 3
    },
    {
      "token": "foxes",
      "start_offset": 18,
      "end_offset": 23,
      "type": "<ALPHANUM>",
      "position": 4
    },
    {
      "token": "jumped",
      "start_offset": 24,
      "end_offset": 30,
      "type": "<ALPHANUM>",
      "position": 5
    },
    {
      "token": "over",
      "start_offset": 31,
      "end_offset": 35,
      "type": "<ALPHANUM>",
      "position": 6
    },
    {
      "token": "the",
      "start_offset": 36,
      "end_offset": 39,
      "type": "<ALPHANUM>",
      "position": 7
    },
    {
      "token": "lazy",
      "start_offset": 40,
      "end_offset": 44,
      "type": "<ALPHANUM>",
      "position": 8
    },
    {
      "token": "dog's",
      "start_offset": 45,
      "end_offset": 50,
      "type": "<ALPHANUM>",
      "position": 9
    },
    {
      "token": "bone",
      "start_offset": 51,
      "end_offset": 55,
      "type": "<ALPHANUM>",
      "position": 10
    }
  ]
}

  • whitespace  空格为分隔符

POST _analyze
{
  "analyzer": "whitespace",
  "text": "The 2 QUICK Brown-Foxes jumped over the lazy dog's bone."
}
-->  [ The,2,QUICK,Brown-Foxes,jumped,over,the,lazy,dog's,bone. ]

  • simple

POST _analyze
{
  "analyzer": "simple",
  "text": "The 2 QUICK Brown-Foxes jumped over the lazy dog's bone."
}
---> [ the, quick, brown, foxes, jumped, over, the, lazy, dog, s, bone ]

  • stop  默认stopwords用_english_

POST _analyze
{
  "analyzer": "stop",
  "text": "The 2 QUICK Brown-Foxes jumped over the lazy dog's bone."
}
-->[ quick, brown, foxes, jumped, over, lazy, dog, s, bone ]
可选参数：
# stopwords
# stopwords_path

  • keyword  不分词的

POST _analyze
{
  "analyzer": "keyword",
  "text": ["The 2 QUICK Brown-Foxes jumped over the lazy dog's bone."]
}
得到  "token": "The 2 QUICK Brown-Foxes jumped over the lazy dog's bone." 一条完整的语句

  • 第三方analyzer插件---中文分词（ik分词器）

es内置很多分词器，但是对中文分词并不友好，例如使用standard分词器对一句中文话进行分词，会分成一个字一个字的。这时可以使用第三方的Analyzer插件，比如 ik、pinyin等。这里以ik为例

1，首先安装插件，重启es：

# bin/elasticsearch-plugin install https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v6.3.0/elasticsearch-analysis-ik-6.3.0.zip
# /etc/init.d/elasticsearch restart

  1. 使用示例：

GET _analyze
{
  "analyzer": "ik_max_word",
  "text": "你好吗?我有一句话要对你说呀。"
}

分词结果

{
  "tokens": [
    {
      "token": "你好",
      "start_offset": 0,
      "end_offset": 2,
      "type": "CN_WORD",
      "position": 0
    },
    {
      "token": "好吗",
      "start_offset": 1,
      "end_offset": 3,
      "type": "CN_WORD",
      "position": 1
    },
    {
      "token": "我",
      "start_offset": 4,
      "end_offset": 5,
      "type": "CN_CHAR",
      "position": 2
    },
    {
      "token": "有",
      "start_offset": 5,
      "end_offset": 6,
      "type": "CN_CHAR",
      "position": 3
    },
    {
      "token": "一句话",
      "start_offset": 6,
      "end_offset": 9,
      "type": "CN_WORD",
      "position": 4
    },
    {
      "token": "一句",
      "start_offset": 6,
      "end_offset": 8,
      "type": "CN_WORD",
      "position": 5
    },
    {
      "token": "一",
      "start_offset": 6,
      "end_offset": 7,
      "type": "TYPE_CNUM",
      "position": 6
    },
    {
      "token": "句话",
      "start_offset": 7,
      "end_offset": 9,
      "type": "CN_WORD",
      "position": 7
    },
    {
      "token": "句",
      "start_offset": 7,
      "end_offset": 8,
      "type": "COUNT",
      "position": 8
    },
    {
      "token": "话",
      "start_offset": 8,
      "end_offset": 9,
      "type": "CN_CHAR",
      "position": 9
    },
    {
      "token": "要对",
      "start_offset": 9,
      "end_offset": 11,
      "type": "CN_WORD",
      "position": 10
    },
    {
      "token": "你",
      "start_offset": 11,
      "end_offset": 12,
      "type": "CN_CHAR",
      "position": 11
    },
    {
      "token": "说呀",
      "start_offset": 12,
      "end_offset": 14,
      "type": "CN_WORD",
      "position": 12
    }
  ]
}

  • 还可以用内置的 character filter, tokenizer, token filter 组装一个analyzer(custom analyzer)

custom

定制analyzer，由以下几部分组成

  • 0个或多个e character filters

  • 1个tokenizer

  • 0个或多个 token filters

PUT t_index
{
  "settings": {
    "analysis": {
      "analyzer": {
        "my_analyzer":{
          "type":"custom",
          "tokenizer":"standard",
          "char_filter":["html_strip"],
          "filter":["lowercase"]
        }
      }
    }
  }
}
POST t_index/_analyze
{
  "analyzer": "my_analyzer",
  "text": ["The 2 QUICK Brown-Foxes jumped over the lazy dog's <b> bone.</b>"]
}
得到：[the,2,quick,brown,foxes,jumped,over,the,lazy,dog's,bone]

自定义分词器

自定义分词需要在索引的配置中设定，如下所示：

PUT test_index
{
  "settings": {
    "analysis": {    # 分词设置，可以自定义
      "char_filter": {},   #char_filter  关键字
      "tokenizer": {},    #tokenizer 关键字
      "filter": {},     #filter  关键字
      "analyzer": {}    #analyzer 关键字
    }
  }
}
character filter  在tokenizer之前对原始文本进行处理，比如增加，删除，替换字符等

会影响后续tokenizer解析的position和offset信息

  • html strip  除去html标签和转换html实体

    • 参数：escaped_tags不删除的标签

POST _analyze
{
  "tokenizer": "keyword",
  "char_filter": ["html_strip"],
  "text": ["<p>I&apos;m so <b>happy</b>!</p>"]
}
得到：
      "token": """

I'm so happy!

"""
#配置示例
PUT t_index
{
  "settings": {
    "analysis": {
      "analyzer": {  #关键字
        "my_analyzer":{   #自定义analyzer
          "tokenizer":"keyword",
          "char_filter":["my_char_filter"]
        }
      },
      "char_filter": {  #关键字
        "my_char_filter":{   #自定义char_filter
          "type":"html_strip",
          "escaped_tags":["b"]  #不从文本中删除的HTML标记数组
        }
      }}}}
POST t_index/_analyze
{
  "analyzer": "my_analyzer",
  "text": ["<p>I&apos;m so <b>happy</b>!</p>"]
}
得到：
      "token": """

I'm so <b>happy</b>!

""",

mapping   映射类型，以下参数必须二选一

  • mappings 指定一组映射，每个映射格式为 key=>value

  • mappings_path 绝对路径或者相对于config路径  key=>value

PUT t_index
{
  "settings": {
    "analysis": {
      "analyzer": {     #关键字
        "my_analyzer":{   #自定义分词器
          "tokenizer":"standard",
          "char_filter":"my_char_filter"  
        }
      },
      "char_filter": {    #关键字
        "my_char_filter":{  #自定义char_filter
          "type":"mapping", 
          "mappings":[       #指明映射关系
            ":)=>happy",
            ":(=>sad"
          ]
        }}}}}
POST t_index/_analyze
{
  "analyzer": "my_analyzer",
  "text": ["i am so :)"]
}
得到 [i,am,so,happy]

pattern replace

  • pattern参数  正则

  • replacement 替换字符串 可以使用 9

  • flags  正则标志

tokenizer  将原始文档按照一定规则切分为单词

  • standard

    • 参数：max_token_length，最大token长度，默认是255

PUT t_index
{
  "settings": {
    "analysis": {
      "analyzer": {
        "my_analyzer":{
          "tokenizer":"my_tokenizer"
        }
      },
      "tokenizer": { 
        "my_tokenizer":{
          "type":"standard",
          "max_token_length":5      
        }}}}}
POST t_index/_analyze
{
  "analyzer": "my_analyzer",
  "text": ["The 2 QUICK Brown-Foxes jumped over the lazy dog's bone."]
}
得到   [ The, 2, QUICK, Brown, Foxes, jumpe, d, over, the, lazy, dog's, bone ]
# jumped 长度为6  在5这个位置被分割

  • letter   非字母时分成多个terms

POST _analyze
{
  "tokenizer": "letter",
  "text": ["The 2 QUICK Brown-Foxes jumped over the lazy dog's bone."]
}
得到 [ The, QUICK, Brown, Foxes, jumped, over, the, lazy, dog, s, bone ]

  • lowcase  跟letter tokenizer一样 ，同时将字母转化成小写

POST _analyze
{
  "tokenizer": "lowercase",
  "text": "The 2 QUICK Brown-Foxes jumped over the lazy dog's bone."
}
得到  [ the, quick, brown, foxes, jumped, over, the, lazy, dog, s, bone ]

  • whitespace  按照空白字符分成多个terms

    • 参数：max_token_length

POST _analyze
{
  "tokenizer": "whitespace",
  "text": "The 2 QUICK Brown-Foxes jumped over the lazy dog's bone."
}
得到 [ The, 2, QUICK, Brown-Foxes, jumped, over, the, lazy, dog's, bone. ]

  • keyword  空操作，输出完全相同的文本

    • 参数：buffer_size，单词一个term读入缓冲区的长度，默认256

POST _analyze
{
  "tokenizer": "keyword",
  "text": ["The 2 QUICK Brown-Foxes jumped over the lazy dog's bone."]
}
得到"token": "The 2 QUICK Brown-Foxes jumped over the lazy dog's bone." 一个完整的文本
token filter  针对tokenizer 输出的单词进行增删改等操作

  • lowercase  将输出的单词转化成小写

POST _analyze
{
  "filter": ["lowercase"],
  "text": ["The 2 QUICK Brown-Foxes jumped over the lazy dog's  bone"]
}
--->
"token": "the 2 quick brown-foxes jumped over the lazy dog's  bone"

PUT t_index
{
  "settings": {
    "analysis": {
      "analyzer": {
        "my_analyzer":{
          "type":"custom", 
          "tokenizer":"standard", 
          "filter":"lowercase"
        }
      }
    }
  }
}
POST t_index/_analyze
{
　　"analyzer": "my_analyzer",
    "text": ["The 2 QUICK Brown-Foxes jumped over the lazy dog's  bone"]
}

  • stop  从token流中删除stop words 。

参数有：
# stopwords   要使用的stopwords， 默认_english_
# stopwords_path
# ignore_case   设置为true则为小写，默认false# remove_trailing
PUT t_index
{
  "settings": {
    "analysis": {
      "analyzer": {
        "my_analyzer":{
          "type":"custom",
          "tokenizer":"standard",
          "filter":"my_filter"
        }
      },
      "filter": {
        "my_filter":{
          "type":"stop",
          "stopwords":["and","or","not"]
        }
      }
    }
  }
}
POST t_index/_analyze
{
  "analyzer": "my_analyzer",
  "text": ["lucky and happy not sad"]
}-------------->[lucky,happy,sad]
故事凌
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
ELK多种架构及优劣
01-27
众所周知，大数据平台组件是很复杂的。笔者之前接触的一个大数据平台解决方案，仅平台组件就达20多个，这还没有加上物联网系统各组件。而这庞大的系统整合问题，对于运维来说是很头疼的。所以，在大数据时代下的运维问题是日渐尖锐。有人把运维比作医生给病人看病，那么日志则是病人对自己的陈述。所以只有在海量分布式日志系统中有效的提取关键信息，才能对症下药。如果能把这些日志集中管理，并提供全文检索功能，不仅可以提高诊断的效率，同时可以起到实时系统监测、网络安全、事件管理和发现bug等功能。基于此，本文向大家推荐一款开源利器——ELK组件（Apache
ELK常见架构
NancyLCL的博客
12-16 246
相比上一个架构，该架构增加了filebeat模块，它是一个轻量级的日志收集处理工具，部署在客户 端，Filebeat占用资源少，适合于在各个服务器上搜集日志后传输给Logstash，但缺点是logstash如果出现故障，会造成日志丢失。该架构是最简单的一种架构，该架构通过logstash来收集日志，通过elasticsearch来分析，检索日志，通过kibana展示。该种架构使用fluentd来替换了Logstash，使用fluentd的插件同样可以直接将日志发送给 Elasticsearch。
常用的ELK/EFK架构
08-10 548
基础架构：1/ Kibana---->elasticsearch---->Logstash(收集) 2/ Kibana---->elasticsearch---->filebeat(收集) 3/ Kibana---->elasticsearch---->Logstash(过滤)---->filebeat(收集) 扩展架构：1/ Kibana---->...
ELK-架构&部署&实践总结
七路灯
05-10 302
介绍业务规模和架构选择，以及部署说明和实践配置。 基于7.11版本。 目录业务规模架构选择部署说明&实践配置新建用户和修改文件夹权限修改系统配置ElasticsearchKibanaLogstashFilebeat 业务规模 业务每天查询量在千万级，采集数据的规模上亿（后续会更大）。单台Logstash，数据延迟并不大，肉眼可见的Logstash的数据处理能力 架构选择 ELK架构有很多种，这里简单列出常用的几个： 架构1（最为简单） Logstash -> Elasticsearch.
FK-ELK日志架构系列1：总体设计架构
welcome66的专栏
05-22 307
FK-ELK日志架构系列，即Fluentd -> Kafka -> Logstash ->Elasticsearch ->Kibana。 该系列后续会不断完善架构及部署和配置过程。目前该套日志架构是部署在K8S之上的，所以主要介绍容器的部署及配置。 该系列目录： 日志采集（docker）：Fluentd的部署及配置 日志采集（VM）：Filebeat的部署及配置 日志转发：Kafka的部署及配置 日志消费：Logstash的部署及配置 日志存储：ES的部署及配置 ..
ELK架构和Filebeat工作原理详解
03-01
ELK不是一款软件，而是Elasticsearch、Logstash和Kibana三种软件产品的首字母缩写。这三者都是开源软件，通常配合使用，而且又先后归于Elastic.co公司名下，所以被简称为ELKStack。根据GoogleTrend的信息显示，ELK...
架构师日志平台ELKStack实践视频.zip
02-12
1.elk简介、ES安装.flv 2.es集群.flv 3-logstash快速入门.flv 4-logstash收集系统日志-file.flv 5-logstash收集java日志-codec.flv 6-kibana介绍.flv 7-logstash收集nginx访问日志-json.flv 8-logstash收集syslog...
分布式ELK平台 、 ES集群安装 、 扩展插件 、 总结和答疑
qq_36345864的博客
03-24 259
ELK简介 什么是ELK ELK是一整套解决方案，是三个软件产品的首字母缩写，很多公司都在使用，如何：Sina，携程，华为，美团等 ELK分别代表 -Elasticsearch:负责日志检索和存储 -Logstash:负责日志的收集分析，处理 -Kibana:负责日志的可视化 这三款软件都是开源软件，通常是配合使用，而且又先后归于Elastic.co公司名下，故被简称为EL...
filebeat如何过滤掉不要的日志，filebeat对json格式日志过滤，filebeat正则过滤日志
qq_32352777的博客
05-11 8654
Filebeat 是 Elastic Stack 的一部分，因此能够与 Logstash、Elasticsearch 和 Kibana 无缝协作。无论您要使用 Logstash 转换或充实日志和文件，还是在 Elasticsearch 中随意处理一些数据分析，亦或在 Kibana 中构建和分享仪表板，Filebeat 都能轻松地将您的数据发送至最关键的地方。
Filebeat 之多行日志处理
菜鸟厚非
05-26 5752
https://www.iamle.com/archives/2658.html https://www.cnblogs.com/toSeek/p/6120778.html
日志检测-filebeat+logstash-整理.docx
07-24
filebeat收集日志，转发给logstash过滤整理成json.再转发给socket server处理业务逻辑
Filebeat占用内存过大挂掉的问题【解决】
Mankel
11-09 2527
问题：filebeat启动一段时间后就会挂掉 1.docker-compose添加守护机制 一开始在docker-compose中添加了一个守护机制： ]# vim docker-compose.yml hostname: #在这行下面 restart: on-failure #容器发生error而退出(容器退出状态不为0)重启容器 发现只是持续的时间长了，并没有解决根本问题，而且当把内存跑满，还会影响其他的服务 后面发现每次重启filebeat，都会重新去读取文件，当内存跑满就挂了 发现问题就解决问
FileBeat部署文档
anguoan的博客
01-09 309
FileBeat部署文档
【分布式应用】Filebeat+ELK 部署、logstash filter四大过滤插件
最新发布
wang_dian1的博客
07-11 1319
语法：(?举例：1,3 })(?如果表达式匹配失败，会生成一个tags字段，字段值为 _grokparsefailure，需要重新检查上边的match配置解析是否正确。
ElasticSearch（九）：ELK 架构
Men-DD
07-28 4979
ELK架构 Logstash Logstash数据传输原理 Logstash配置文件结构 Logstash导入数据到ES 同步数据库数据到Elasticsearch FileBeat的工作原理 Filebeat安装 ELK整合实战 采集nginx服务器日志 使用FileBeats将日志发送到Logstash 配置Logstash接收FileBeat收集的数据 Logstash输出数据到Elasticsearch 利用Logstash过滤器解析日志 输出到Elasticsearch指定索引......
ElasticSearch 7.6.1安装包Logstash Kibana FileBeat ik分词器
张俊杰 的博客
02-14 889
ElasticSearch Logstash Kibana FileBeat ik分词器 链接: https://pan.baidu.com/s/1_Iv2R8pmYaHkoaOk_m8OuQ 提取码: 5ezt
28.Filebeat的高级配置-Filebeat部分
热门推荐
Mars Loo的博客
04-24 5万+
介绍Filebeat的高级配置，尤其介绍了Filebeat组件自己的配置选项的意义。
漫谈ELK在大数据运维中的应用
happytofly的博客
02-05 2078
圈子里关于大数据、云计算相关文章和讨论是越来越多，愈演愈烈。行业内企业也争前恐后，群雄逐鹿。而在大数据时代的运维挑站问题也就日渐突出，任重而道远了。本文旨在针对复杂的大数据运维系统推荐一把利器，达到抛砖引玉的效果，如果文中出现任何纰漏和错误的地方，恳请指正，欢迎讨论，希望大家不吝赐教。众所周知，大数据平台组件是很复杂的。笔者之前接触的一个大数据平台解决方案，仅平台组件就达20多个，这还没有加上物联...
filebeat：利用js过滤加工数据
liangf05的专栏
11-19 1827
1,打开filebeat配置文件：vim filebeat.yml （一般在/etc/filebeat） 2，找到processors: 设置块，注意yml配置文件，如果配置项在一行冒号后面有空格； 在processors： 下设置js脚步 要加工整理的数据格式是： "{mid:201,time:0,datas:[{addr:0,level:0,mes:44}],valve:1,changed:0,power:0,product:0,version:7}" 注意这不是json格式字符串，前后有双引号，是一
ELK架构：日志处理与电商平台集成案例
在实际业务实践中，如电商体系架构中，面临API整合、日志整合和负载均衡的问题时，ELK被用来解决日志管理难题。通过将日志存储在Elasticsearch中，而非直接依赖数据库，避免了数据量大和格式不一致带来的挑战。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值