Dubbo进修系列之十六（ELK海量日记剖析框架）

  外卖公司怎样婚配骑手和定单？淘宝怎样举行商品引荐？也许读者兴致婚配？另有海量数据存储搜刮、及时日记剖析、运用程序监控等场景，Elasticsearch也许可以供应一些思绪，作为业界最具影响力的海量搜刮与剖析产物，搜刮软件公司 Elastic 上市了！首日市值翻倍！Elastic 从小东西「逆袭」成为上市公司，依托其手艺影响者浩瀚企业，并增进悉数行业生长的形式革新，向浩瀚盼望创业的程序员证明了一个原理：手艺创业是可行的，而且有着优越的远景。你要不要尝尝呢？

预备：

Idea2019.03/Gradle5.6.2/JDK11.0.4/RHEL7.6/VMware15Pro/Lombok0.27/logback1.2.3/SpringBoot2.2.0RELEASE/ElasticSearch7.2.0/LogStash7.2.0/Kibana7.2.0/NodeJs10.14.2/npm6.4.1/Git2.18.0

难度：新手--兵士--老兵--巨匠

目的：

1.Logback运用温习

2.Linux下ELK框架搭建

3.Springboot整合ELK完成海量日记处置惩罚框架

4.Springboot下运用ES的API

步骤：

为了碰见种种题目，同时坚持时效性，我只管运用最新的软件版本。代码地点：个中的day21，https://github.com/xiexiaobiao/dubbo-project.git

Part1 Linux下的ELK

1.先引见下ELK套件：

• ElasticSearch：(以下简称ES)搜刮引擎。基于Lucene打造，特点是散布式、零设置、自动发明、索引自动分片、索引副本机制，最轻易的就是Restful接口。可以程度扩大，每秒钟可处置惩罚海量事宜，同时可以自动治理索引和查询在集群中的散布体式格局，以完成极为流通的操纵。
• Logstash：数据收集器。可统一时候收集多泉源的数据，以连续流传输，并能及时剖析和转换数据，能自定义过滤器，末了将数据发送到指定存储库， 固然，ES 是其首选存储库。其采纳可插拔框架，具有 200 多个插件。可将差别的输入挑选、过滤器和输出挑选夹杂搭配。
• Kibana：ES数据可视化东西，如柱状图、线状图、饼图、朝阳图等，这些相似于经常使用的报表东西，支撑权限接见掌握，另有特定的查询语法来举行庞杂的查询操纵。

着实：ES可以用作文档型存储，相似MongoDB，适用于非事件型散布式存储场景。API异常雄厚，但也存在肯定的难度和庞杂度。

典范的 ELK 套件计划：

 

• Beats：假如考虑到机械负载题目，另有轻量级(比拟Logstash)的beat组件级数据收集器，能从不计其数台机械和体系向 Logstash 或 ES 发送数据，Beats是一个系列，有Filebeat/Packetbeat/Winlogbeat/Heartbeat/Auditbeat等，用于收集差别泉源种别的数据。假如再加上缓冲层，可演变成以下壮大架构，并发才能更上一层楼！

 

 

2.Linux假造机的装置、收集、文件同享、YUM装置见我下篇，也许网搜，想必进入这个文章的linux也该略有基本了。

3.我这里 ELK 三者悉数装置在一台Linux假造机(IP:192.168.1.204)上，注重下载的ELK版本要一致，现在最新为V7.4.2，但下载着实蜗牛速率，只好先用点已有的旧货上场，抱歉！

4.最先ES的装置：下载elasticsearch-7.2.0-linux-x86_64.tar.gz，放/usr/elastic下，并解压，ES不能运用root用户启动，会提醒毛病！

 

 

 切换为普通用户，并将文件主更新为普通用户，再启动：

[root@localhost ~]# chown -Rv biao /usr/elastic/
[biao@localhost usr]$ ./elastic/elasticsearch-7.2.0/bin/elasticsearch

5.初次启动测试：

[root@localhost ~]# curl localhost:9200
[root@localhost ~]# curl localhost:9300

 

 6.默许状况下，ES 只许可本机接见，假如需要长途接见，可以修正 ES 装置目次的config/elasticsearch.yml文件，去掉network.host的诠释，并将它的值改成地点OS的IP：192.168.1.204，然后重新启动 ES。

[root@localhost ~]# vim /usr/elastic/elasticsearch-7.2.0/config/elasticsearch.yml

 

假如需要从window主机接见，注重翻开Linux响应的端口或直接封闭防火墙， URL接见：http://192.168.1.204:9200/再次启动涌现毛病，提醒有3个题目，各个击破！

 

每一个历程最大同时翻开文件数太小：

[root@localhost usr]# sysctl -w vm.max_map_count=262144
vm.max_map_count = 262144

ulimit 用于限定 shell 启动历程所占用的资本：

[root@localhost usr]# vim /etc/security/limits.conf

 

检察设置后的值：

[root@localhost usr]# ulimit -Hn
[root@localhost usr]# ulimit -Sn

末了设置一个seed_host,见步骤6中的第一图，按Ctrl+c退出。

7.最先装置elasticsearch-head：一款ES集群可视化治理东西，可直接操纵ES的数据，这也太野了吧，生产中必需要加以限定！这个东西有多种体式格局装置，比方doker/plugin/npm等，因linux上环境短缺，我就直接在window上运用npm装置了(window上先装置node.js环境即可运用npm)，这实际上是将elasticsearch-head自力运转，参考背面的(整合ELK团体目的架构图)：

D盘根目次下，运用git bash敕令，下载源码：

git clone git://github.com/mobz/elasticsearch-head.git

下载源码完成后CMD敕令行操纵：

C:\Users\KOOL>D:
D:\>cd D:\elasticsearch-head
D:\elasticsearch-head>npm install -g cnpm --registry=https://registry.npm.taobao.org
D:\elasticsearch-head>npm install
D:\elasticsearch-head>npm run start

以下图即为装置胜利！

 

8.接见：http://localhost:9100/

输入ES的 IP+port --> connect， 假如此时显现空缺，请先运用 http://192.168.1.204:9200/ 测试确保外部可以衔接ES，然后检察：

 

即可确以为跨域题目，需修正ES设置文件elasticsearch.yml，在文件末端到场以下设置，注重冒号后的空格！

• http.cors.enabled: true #是不是许可跨域
• http.cors.allow-origin: "*"

 

9.再重启ES，衔接ES端，可以发明ES对logstash/kibana都做了存储，果然是自家的，特别照顾，前缀有点号辨别：

检察indices信息，以下为已启动了Logstash和Kibana的状况：

 

node信息：

 

检察shard信息：

 

10.最先Logstash装置：

下载文件logstash-7.2.0.tar.gz，略，放/usr/logstash下，解压，测试logstash启动是不是一般：

[root@localhost logstash]cd logstash-7.2.0
[root@localhost logstash-7.2.0]# ./bin/logstash -e 'input { stdin { } } output { stdout {} }'

 

启动后，输入hello world，以下则胜利！ctrl+D退出。

 

别的，可以下载测试数据做测试：

[root@localhost logstash-7.2.0]# wget http://files.grouplens.org/datasets/movielens/ml-latest-small.zip
[root@localhost logstash-7.2.0]# unzip ml-latest-small.zip
[root@localhost logstash-7.2.0]# vim config/logstash-test.conf

logstash-test.conf内容以下：

input {
  file {
    path => "/usr/logstash/logstash-7.2.0/ml-latest-small/movies.csv" #注重修正为本身的目次
    start_position => "beginning"
    sincedb_path => "/dev/null"
  }
}
filter {
  csv {
    separator => ","
    columns => ["id","content","genre"]
  }
  mutate {
    split => { "genre" => "|" }
    remove_field => ["path", "host","@timestamp","message"]
  }
  mutate {

    split => ["content", "("]
    add_field => { "title" => "%{[content][0]}"}
    add_field => { "year" => "%{[content][2]}"}
  }
  mutate {
    convert => {
      "year" => "integer"
    }
    strip => ["title"]
    remove_field => ["path", "host","@timestamp","message","content"]
  }
}
output {
   elasticsearch {
     hosts => http://192.168.1.204:9200 #注重修正为本身的ES
     index => "movies"
     document_id => "%{id}"
   }
  stdout {}
}

运转下测试数据，注重先启动ES：

[root@localhost logstash-7.2.0]# ./bin/logstash -f /usr/logstash/logstash-7.2.0/config/logstash-test.conf

报错：There is insufficient memory for the Java Runtime Environment to continue.假造机的内存不够，以下敕令检察内存状况：

[root@localhost logstash-7.2.0]# free -h

发起直接假造机修正为 4G 内存，再跑此测试数据！运转胜利后，先放着。

11.最先Kibana装置：下载，略，kibana-7.2.0-linux-x86_64.tar.gz复制到目次/usr/kibana下，解压：

[root@localhost ~]# cp /mnt/hgfs/00sharetoVM/kibana-7.2.0-linux-x86_64.tar.gz  /usr/kibana

以root启动会提醒不能运用root运转，可运用加 --allow-root 参数处理，这里我直接换成普通用户：

[root@localhost usr]# chown -Rv biao /usr/kibana/
[biao@localhost kibana-7.2.0-linux-x86_64]$ pwd
/usr/kibana/kibana-7.2.0-linux-x86_64
[biao@localhost kibana-7.2.0-linux-x86_64]$ vim config/kibana.yml

#以下为设置项目：

server.port: 5601
server.host: "192.168.1.204"  #假造机的IP
elasticsearch.hosts: ["http://192.168.1.204:9200"]
kibana.index: ".kibana"

启动Kibana，注重先启动ES：

[biao@localhost kibana-7.2.0-linux-x86_64]$ ./bin/kibana

 

再配合上面处于启动状况的Logstash测试数据，外部翻开URL地点：http://192.168.1.204:5601/

 

12.启动Kibana，如碰到毛病：Elasticsearch cluster did not respond with license information.只需细致设置 ES ，不是缺乏xpack插件，7.X已集成该插件了！

[biao@localhost elasticsearch-7.2.0]$ vim config/elasticsearch.yml

以下为设置项：

cluster.name: my-application
node.name: node-1
path.data: /tmp/es/data
path.logs: /tmp/es/logs
network.host: 192.168.1.204  #发起不要写为网上的0.0.0.0
http.port: 9200
discovery.seed_hosts: ["192.168.1.204"]
cluster.initial_master_nodes: ["node-1"]

Part2 验收测试

1.先完成Springboot运用整合ELK做日记处置惩罚：团体目的架构以下图：

 

2.建立springboot工程，我运用idea直接建一个简朴的gradle project，终究挣脱前面的mall项目了！

 

3.引入依靠，异常发起逐渐引入，运用过程中视察缺乏依靠对运用的影响，如许能更好的进修各个组件的作用：

dependencies {
    testCompile group: 'junit', name: 'junit', version: '4.12'
    // https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-parent
    compile group: 'org.springframework.boot', name: 'spring-boot-starter-parent', version: '2.2.0.RELEASE', ext: 'pom'

    //Core starter, including auto-configuration support, logging and YAML
    compile group: 'org.springframework.boot', name: 'spring-boot-starter', version: '2.2.0.RELEASE'
    //Starter for testing Spring Boot applications with libraries including JUnit, Hamcrest and Mockito
    testCompile group: 'org.springframework.boot', name: 'spring-boot-starter-test', version: '2.2.0.RELEASE'
    //Starter for building web, including RESTful, applications using Spring MVC. Uses Tomcat as the default embedded container
    compile group: 'org.springframework.boot', name: 'spring-boot-starter-web', version: '2.2.0.RELEASE'
    //
    testCompile group: 'ch.qos.logback', name: 'logback-classic', version: '1.2.3'
    // https://mvnrepository.com/artifact/net.logstash.logback/logstash-logback-encoder
    compile group: 'net.logstash.logback', name: 'logstash-logback-encoder', version: '6.2'
    // 原本这里的scope应当为providedCompile，即只存在于编译和测试阶段，但好像gradle没法辨认，maven环境下未测试
    compile group: 'org.projectlombok', name: 'lombok', version: '1.18.10'
    // https://mvnrepository.com/artifact/org.elasticsearch.client/elasticsearch-rest-high-level-client
    compile group: 'org.elasticsearch.client', name: 'elasticsearch-rest-high-level-client', version: '7.2.0'
    // https://mvnrepository.com/artifact/org.elasticsearch/elasticsearch
    compile group: 'org.elasticsearch', name: 'elasticsearch', version: '7.2.0'
    // https://mvnrepository.com/artifact/org.elasticsearch.client/transport
    compile group: 'org.elasticsearch.client', name: 'transport', version: '7.2.0'
}

4.建立类，注重这里直接将Controller放进口类ApplicationMain内里的，简朴粗犷!

@RestController
@SpringBootApplication
//@Slf4j
public class ApplicationMain {

    private final Logger log = LoggerFactory.getLogger(ApplicationMain.class);

    public static void main(String[] args) {
        SpringApplication.run(ApplicationMain.class,args);
        System.out.println("ELK Application started.>>>>>>>>>>>>>>>>>>>>>>>>>>>");
    }

    @RequestMapping("/test")
    public String test() throws InterruptedException {
        for (int i = 0; i < 10; i++) {
            Thread.sleep(1000);
            log.info("log from ELK app time: {}",System.currentTimeMillis());
        }
        return "ELK test success";
    }
}

5.建立logback-spring文件，再温习下logback的运用，SLF4J是鸠合了种种日记组件的框架，运用了门面形式，appender/logger/root是个中三大件，这里就是运用logback将日记传给Logstash。别的，我还定义了一个file范例的log输出，可以看到项目代码地点的目次下的log文件：

<?xml version="1.0" encoding="UTF-8"?>
<!--该日记将日记级别差别的log信息保存到差别的文件中 -->
<configuration>
    <include resource="org/springframework/boot/logging/logback/defaults.xml" />

    <!--springProperty:在properties/yml文件中找到对应的设置项 -->
    <springProperty scope="context" name="springAppName" source="spring.application.name" />
    <springProperty scope="context" name="logFilePath" source="logging.config.path" />

    <!-- 日记在工程中的输出位置 -->
    <property name="LOG_FILE" value="${BUILD_FOLDER:-build}/${springAppName}" />

    <!-- 掌握台的日记输出款式 -->
    <property name="CONSOLE_LOG_PATTERN"
              value="%clr(%d{yyyy-MM-dd HH:mm:ss.SSS}){faint} %clr(${LOG_LEVEL_PATTERN:-%5p}) %clr(${PID:- }){magenta} %clr(---){faint} %clr([%15.15t]){faint} %m%n${LOG_EXCEPTION_CONVERSION_WORD:-%wEx}}" />

    <!-- 掌握台输出 appender-->
    <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
            <level>INFO</level>
        </filter>
        <!-- 日记输出编码 -->
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>${CONSOLE_LOG_PATTERN}</pattern>
            <charset>utf8</charset>
        </encoder>
    </appender>

    <!-- 为logstash输出的JSON花样的Appender -->
    <appender name="logstash"
              class="net.logstash.logback.appender.LogstashTcpSocketAppender">
        <destination>192.168.1.204:9665</destination>
        <!-- 日记输出编码 -->
        <encoder class="net.logstash.logback.encoder.LoggingEventCompositeJsonEncoder">
            <providers>
                <timestamp>
                    <timeZone>UTC</timeZone>
                </timestamp>
                <pattern>
                    <pattern>
                        {
                        "severity": "%level",
                        "service": "${springAppName:-}",
                        "trace": "%X{X-B3-TraceId:-}",
                        "span": "%X{X-B3-SpanId:-}",
                        "exportable": "%X{X-Span-Export:-}",
                        "pid": "${PID:-}",
                        "thread": "%thread",
                        "class": "%logger{40}",
                        "rest": "%message"
                        }
                    </pattern>
                </pattern>
            </providers>
        </encoder>
    </appender>

    <!--文件花样输出appender-->
    <appender name="file" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!--定义日记输出的途径-->
        <!--这里的scheduler.manager.server.home 没有在上面的设置中设定，所以会运用java启动时设置的值-->
        <!--比方经由过程 java -Dscheduler.manager.server.home=/path/to XXXX 设置该属性-->
        <file>${logging.path}/spring-boot/elk.log</file>
        <!--定义日记转动的战略-->
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!--定义文件转动时的文件名的花样-->
            <fileNamePattern>${scheduler.manager.server.home}/logs/${app.name}.%d{yyyy-MM-dd.HH}.log
            </fileNamePattern>
            <!--60天的时候周期，日记量最大20GB-->
            <maxHistory>60</maxHistory>
            <!-- 该属性在 1.1.6版本后 才最先支撑-->
            <totalSizeCap>20GB</totalSizeCap>
        </rollingPolicy>
        <triggeringPolicy class="ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy">
            <!--每一个日记文件最大100MB-->
            <maxFileSize>100MB</maxFileSize>
        </triggeringPolicy>
        <!--定义输出花样-->
        <encoder>
            <pattern>%d [%thread] %-5level %logger{36} [%file : %line] - %msg%n</pattern>
        </encoder>
    </appender>

    <!--logger 用来设置某一个包也许细致的某一个类的日记打印级别以及指定appender-->
    <!--经由过程 LoggerFactory.getLogger("mytest") 可以获取到这个logger-->
    <!--因为这个logger自动继承了root的appender，root中已有stdout的appender了，本身这边又引入了stdout的appender-->
    <!--假如没有设置 additivity="false" ,就会致使一条日记在掌握台输出两次的状况,经由过程appender-ref做好分工，root担任console和logstash
      此logger担任file输出-->
    <!--additivity示意要不要运用rootLogger设置的appender举行输出-->
    <logger name="test" level="INFO" additivity="false">
        <appender-ref ref="file"/>
    </logger>

    <!-- 根logger，也是一种logger，且只要一个level属性 -->
    <root level="INFO">
        <appender-ref ref="console" />
        <appender-ref ref="logstash" />
    </root>

</configuration>

6.建立application.yml文件，用于上面的文件中做值援用：

spring:
  application:
    name: ELK Application
logging:
  config:
    path: ./logs

7.新建一个logstash启动设置文件：

[root@localhost logstash-7.2.0]# vim config/logstash-java.conf

内容以下，注重这里的port是运用接入的端口，output则是ES：

input{
   tcp {
     port  => 9665
     codec => json_lines
    }

}
output{
   elasticsearch{
     hosts => ["192.168.1.204:9200"]
 }
}

8.启动logstash：

[root@localhost logstash-7.2.0]# ./bin/logstash -f /usr/logstash/logstash-7.2.0/config/logstash-java.conf

如运用启动后涌现毛病：

Log destination 192.168.1.204:2004: connection failed. java.net.ConnectException: Connection refused: connect

请细致检查logstash-java.conf 和logback-spring.xml 的端口设置，必需一致！

9.启动递次：

ES --> Kibana --> Logstash --> ELK Application

10.URL接见：http://localhost:8080/test，运用发生log：

 

URL接见Kibana ，略作下设置：http://192.168.1.204:5601/

 

 下一步：

 

  下一步：

 

至此，海量日记剖析框架完成！哪来的海量？？？这还不简朴，上面的代码中轮回 i 改成一百亿，去掉sleep！特此声明，对海量试验结果概不担任！至于kibana那些雄厚多彩的展示和KQL查询，列位自行去探究吧！

 

11.来操纵一把 ES Java API:

官方文档中有运用 org.elasticsearch.client.transport.TransportClient 做 ES 的外部 client ，再去操纵ES，但运用后却发明已 deprecated ！换一个吧，我找到io.searchbox.client.JestClient，结果最新是2018年的，这？！再举行寻觅一番，有个 org.elasticsearch.client.RestHighLevelClient 是最新的，且支撑同步和异步挪用，赶忙又换掉前面的，唉，就像猴子下山一样，好累，代码换了三波！这里只是运用了一个保存API，其他另有许多，可参考官网，运用体式格局相似。

代码就是在ApplicationMain中再增加一个APItest测试要领：

@RequestMapping("/api")
    public String APItest() throws InterruptedException, IOException {
        /** scheme 选项 http/tcp
         * 1. java客户端的体式格局是以tcp协定在9300端口上举行通讯
         * 2. http客户端的体式格局是以http协定在9200端口上举行通讯
         */
        RestHighLevelClient client = new RestHighLevelClient(
                //builder可以继承增加多个HttpHost
                RestClient.builder(
                        new HttpHost("192.168.1.204", 9200, "http")));

         /** 有四种差别的体式格局来发生JSON花样的文档（document）
            .Manually (aka do it yourself) using native byte[] or as a String
            .Using a Map that will be automatically converted to its JSON equivalent
            .Using a third party library to serialize your beans such as Jackson
            .Using built-in helpers XContentFactory.jsonBuilder()
         */
        XContentBuilder builder = XContentFactory.jsonBuilder();
        builder.startObject();
        {
            builder.field("user", "biao");
            builder.timeField("postDate", new Date());
            builder.field("message", "trying out Elasticsearch");
        }
        builder.endObject();
        String index = "my_temp_index";
        IndexRequest indexRequest = new IndexRequest(index)
                .id("1")
                .timeout(TimeValue.timeValueSeconds(1))
                .setRefreshPolicy(WriteRequest.RefreshPolicy.WAIT_UNTIL)
                .opType(DocWriteRequest.OpType.INDEX)
                .source(builder);

        //Synchronous execution
        IndexResponse indexResponse = client.index(indexRequest, RequestOptions.DEFAULT);
        System.out.println(indexResponse.toString());

        //asynchronous execution,
        // client.indexAsync(indexRequest, RequestOptions.DEFAULT, listener);

        client.close();
        return "ELK API test success";
    }

    ActionListener listener = new ActionListener() {
        @Override
        public void onResponse(Object o) {
            System.out.println("ELK API ASYN test success");
        }

        @Override
        public void onFailure(Exception e) {
            System.out.println("ELK API ASYN test failed");
        }
    };

 

同步测试：URL接见：http://localhost:8080/api

 

结果以下，Index保存胜利，到达测试目的！

 

异步测试：特别注重要将 client.close() 诠释掉，并完成 ActionListener 类：URL接见：http://localhost:8080/api

结果以下，Index保存胜利，掩盖了上面同步测试生成的index内容(是不是掩盖可设置)，到达测试目的！

 

 

 

复盘记：

1.ELK是一个可伸缩的框架，可按需举行裁剪，个中Logstash是一个 点对点 的信息收集器，假如流量庞大，可以到场MQ或Redis缓冲，

2.ES身世就是散布式的，所以集群体式格局可以做到多Node，多Shard，运用主从复制与冗余存储备份战略，自动均衡数据存储点负载，

3.关于ES的观点，有个很好的对照图，假如用过Mongodb，应当就好明白，只注重“文档”一词，不是指我们常说的word/pdf文件，而是一种有花样的形貌型结构化数据，比方JSON：

 

4.再次注重ELK中各conf文件的IP绑定观点，不发起运用0.0.0.0，事实上生产环境也不会直接全开！细致剖析我在前篇《Linux下Redis集群》中有诠释，这里的bind相似，不再赘述。

5.ES分库分片设置：

• number_of_shards：每一个索引的主分片数，默许值是 5 。这个设置在索引建立后不能修正。
• number_of_replicas：每一个主分片的副本数，默许值是 1 。关于运动的索引库，这个设置可以随时修正。

以下运用ES-Head体式格局，建立一个index，并设置为一个node上3个shard，每一个shard有2个replica：

 

以上也可运用CURL体式格局：

curl -X PUT "localhost:9200/my_temp_index?pretty" -H 'Content-Type: application/json' -d'
{
    "settings": {
        "number_of_shards" :   1,
        "number_of_replicas" : 0
    }
}
'

 

细致展示以下：

 

然后，我们可以用 update-index-settings API 动态修正副本数，也可运用CURL体式格局：

 

修正后的结果：

 

5.ES为何快！？中心就是倒序索引和特别的文件紧缩，至于细致，内容略多，在此仅作个引子。

6.本文完整没用到dubbo，只是为了题目的连接，故保存。

本文完毕！

引荐浏览：

• Linux下Redis集群
• Dubbo进修系列之十五（Seata散布式事件计划TCC形式）
• Dubbo进修系列之十四（Seata散布式事件计划AT形式）
• Dubbo进修系列之十三（Mycat数据库代办）
• Dubbo进修系列之十二（Quartz使命调理）