elk快速部署、集成、调优

已于 2025-08-03 12:45:56 修改
阅读量480 收藏 9
点赞数 13
CC 4.0 BY-SA版权
分类专栏： 多宝盒 ElasticSearch 文章标签： elk springboot kibana 索引 查询
于 2025-08-03 12:39:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/taotao_guiwang/article/details/149837061

elk快速部署、集成、调优

1.部署

1.1 docker部署

参考：https://blog.csdn.net/taotao_guiwang/article/details/135508643
在这里插入图片描述

1.2 elk部署

# 赋权，在elk_install目录，执行：
chmod -R 777 .
# 执行
./elk_install.sh.sh
  • 安装分词器
# 默认安装在/home/install/elk
docker cp /home/install/elk/elasticsearch-analysis-ik-7.17.3.zip elasticsearch:/
# 进入容器，执行以下命令，然后重启容器
docker exec -it elasticsearch bash
elasticsearch-plugin install file:/elasticsearch-analysis-ik-7.17.3.zip

出现如图所示页面输入 y
在这里插入图片描述

# 在容器内执行
bin/elasticsearch-setup-passwords interactive
# 设置密码为：test@123456(PS:不建议修改为其他密码，因为配置文件里配的都是这个密码)

在这里插入图片描述

# 退出容器：
exit
# 重启容器：
docker restart elasticsearch logstash kibana

elastic访问地址：
http://10.86.97.210:9200/
账号：elastic
密码：test@123456
在这里插入图片描述
kibana访问地址：
http://10.86.97.210:5601/
账号：elastic
密码：test@123456

2. spring boot集成

2.1 创建索引

  • 转到，kibana：Management->开发工具：
    在这里插入图片描述
  • 执行：
PUT blog
{
    "mappings": {
        "properties": {
            "id":{
                "type":"long"
            },
            "title": {
                "type": "text"
            },
            "content": {
                "type": "text"
            },
            "author":{
                "type": "text",
                "fields": {
                    "keyword": {
                        "type": "keyword"
                    }
                }
            },
            "category":{
                "type": "keyword"
            },
            "createTime": {
                "type": "date",
                "format":"yyyy-MM-dd HH:mm:ss.SSS||yyyy-MM-dd'T'HH:mm:ss.SSS||yyyy-MM-dd HH:mm:ss||epoch_millis"
            },
            "updateTime": {
                "type": "date",
                "format":"yyyy-MM-dd HH:mm:ss.SSS||yyyy-MM-dd'T'HH:mm:ss.SSS||yyyy-MM-dd HH:mm:ss||epoch_millis"
            },
            "status":{
                "type":"integer"
            },
            "serialNum": {
                "type": "keyword"
            }
        }
    }
}

  • 执行效果：
    在这里插入图片描述

  • 查看blog信息：

GET /blog

在这里插入图片描述

2.2 构造数据

  • 数据，每个文档必须独占一行，不能换行：
{"index":{"_index":"blog","_id":1}}
{"blogId":1,"title":"Spring Data ElasticSearch学习教程1","content":"这是批量添加的文档1","author":"Iron Man","category":"ElasticSearch","status":1,"serialNum":"1","createTime":"2021-10-10 11:52:01.249","updateTime":null}
{"index":{"_index":"blog","_id":2}}
{"blogId":2,"title":"Spring Data ElasticSearch学习教程2","content":"这是批量添加的文档2","author":"Iron Man","category":"ElasticSearch","status":1,"serialNum":"2","createTime":"2021-10-10 11:52:02.249","updateTime":null}
{"index":{"_index":"blog","_id":3}}
{"blogId":3,"title":"Spring Data ElasticSearch学习教程3","content":"这是批量添加的文档3","author":"Captain America","category":"ElasticSearch","status":1,"serialNum":"3","createTime":"2021-10-10 11:52:03.249","updateTime":null}
{"index":{"_index":"blog","_id":4}}
{"blogId":4,"title":"Spring Data ElasticSearch学习教程4","content":"这是批量添加的文档4","author":"Captain America","category":"ElasticSearch","status":1,"serialNum":"4","createTime":"2021-10-10 11:52:04.249","updateTime":null}
{"index":{"_index":"blog","_id":5}}
{"blogId":5,"title":"Spring Data ElasticSearch学习教程5","content":"这是批量添加的文档5","author":"Spider Man","category":"ElasticSearch","status":1,"serialNum":"5","createTime":"2021-10-10 11:52:05.249","updateTime":null}
{"index":{"_index":"blog","_id":6}}
{"blogId":6,"title":"Java学习教程6","content":"这是批量添加的文档6","author":"Spider Man","category":"ElasticSearch","status":1,"serialNum":"6","createTime":"2021-10-10 11:52:06.249","updateTime":null}
{"index":{"_index":"blog","_id":7}}
{"blogId":7,"title":"Java学习教程7","content":"这是批量添加的文档7","author":"Iron Man","category":"ElasticSearch","status":1,"serialNum":"7","createTime":"2021-10-10 11:52:07.249","updateTime":null}
{"index":{"_index":"blog","_id":8}}
{"blogId":8,"title":"Java学习教程8","content":"这是批量添加的文档8","author":"Iron Man","category":"ElasticSearch","status":1,"serialNum":"8","createTime":"2021-10-10 11:52:08.249","updateTime":null}
{"index":{"_index":"blog","_id":9}}
{"blogId":9,"title":"Java学习教程9","content":"这是批量添加的文档9","author":"Captain America","category":"ElasticSearch","status":1,"serialNum":"9","createTime":"2021-10-10 11:52:09.249","updateTime":null}
{"index":{"_index":"blog","_id":10}}
{"blogId":10,"title":"Java学习教程10","content":"这是批量添加的文档10","author":"God Of Thunder","category":"ElasticSearch","status":1,"serialNum":"10","createTime":"2021-10-10 11:52:10.249","updateTime":null}
  • 执行效果：
    在这里插入图片描述
  • 查询数据：
GET /blog/_search
{
  "query": {
    "match_all": {}
  }
}

2.3 核心代码

2.3.1 常见操作

包括：添加单个文档、添加多个文档、修改单个文档数据、修改单个文档部分数据、修改多个文档部分数据、查看单个文档、删除单个文档（根据id）、删除单个文档（根据条件）、删除所有文档。

package com.elk;

import com.elk.entity.Blog;
import org.elasticsearch.index.query.QueryBuilders;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.elasticsearch.core.ElasticsearchRestTemplate;
import org.springframework.data.elasticsearch.core.document.Document;
import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates;
import org.springframework.data.elasticsearch.core.query.NativeSearchQuery;
import org.springframework.data.elasticsearch.core.query.NativeSearchQueryBuilder;
import org.springframework.data.elasticsearch.core.query.UpdateQuery;
import org.springframework.data.elasticsearch.core.query.UpdateResponse;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

//增删改查（RestTemplate方式)
@RestController
@RequestMapping("crudViaRestTemplate")
public class CrudViaRestTemplateController {
    @Autowired
    private ElasticsearchRestTemplate elasticsearchRestTemplate;
    @PostMapping("addDocument")
    public Blog addDocument() {
        Long id = 1L;
        Blog blog = new Blog();
        blog.setBlogId(id);
        blog.setTitle("Spring Data ElasticSearch学习教程" + id);
        blog.setContent("这是添加单个文档的实例" + id);
        blog.setAuthor("Tony");
        blog.setCategory("ElasticSearch");
        blog.setCreateTime(new Date());
        blog.setStatus(1);
        blog.setSerialNum(id.toString());
        return elasticsearchRestTemplate.save(blog);
    }
    @PostMapping("addDocuments")
    public Object addDocuments(Integer count) {
        List<Blog> blogs = new ArrayList<>();
        for (int i = 1; i <= count; i++) {
            Long id = (long)i;
            Blog blog = new Blog();
            blog.setBlogId(id);
            blog.setTitle("Spring Data ElasticSearch学习教程" + id);
            blog.setContent("这是添加单个文档的实例" + id);
            blog.setAuthor("Tony");
            blog.setCategory("ElasticSearch");
            blog.setCreateTime(new Date());
            blog.setStatus(1);
            blog.setSerialNum(id.toString());
            blogs.add(blog);
        }
        return elasticsearchRestTemplate.save(blogs);
    }
    /**
     * 跟新增是同一个方法。若id已存在，则修改。
     * 无法只修改某个字段，只能覆盖所有字段。若某个字段没有值，则会写入null。
     * @return 成功写入的数据
     */
    @PostMapping("editDocument")
    public Blog editDocument() {
        Long id = 1L;
        Blog blog = new Blog();
        blog.setBlogId(id);
        blog.setTitle("Spring Data ElasticSearch学习教程" + id);
        blog.setContent("这是修改单个文档的实例" + id);
        return elasticsearchRestTemplate.save(blog);
    }
    @PostMapping("editDocumentPart")
    public UpdateResponse editDocumentPart() {
        long id = 1L;
        Document document = Document.create();
        document.put("title", "修改后的标题" + id);
        document.put("content", "修改后的内容" + id);
        UpdateQuery updateQuery = UpdateQuery.builder(Long.toString(id))
                .withDocument(document)
                .build();
        UpdateResponse response = elasticsearchRestTemplate.update(updateQuery, IndexCoordinates.of("blog"));
        return response;
    }
    @PostMapping("editDocumentsPart")
    public void editDocumentsPart(int count) {
        List<UpdateQuery> updateQueryList = new ArrayList<>();
        for (int i = 1; i <= count; i++) {
            long id = (long) i;
            Document document = Document.create();
            document.put("title", "修改后的标题" + id);
            document.put("content", "修改后的内容" + id);
            UpdateQuery updateQuery = UpdateQuery.builder(Long.toString(id))
                    .withDocument(document)
                    .build();
            updateQueryList.add(updateQuery);
        }
        elasticsearchRestTemplate.bulkUpdate(updateQueryList, IndexCoordinates.of("blog"));
    }
    @GetMapping("findById")
    public Blog findById(Long id) {
        return elasticsearchRestTemplate.get(
                id.toString(), Blog.class, IndexCoordinates.of("blog"));
    }
    @PostMapping("deleteDocumentById")
    public String deleteDocumentById(Long id) {
        return elasticsearchRestTemplate.delete(id.toString(), Blog.class);
    }
    @PostMapping("deleteDocumentByQuery")
    public void deleteDocumentByQuery(String title) {
        NativeSearchQuery nativeSearchQuery = new NativeSearchQueryBuilder()
                .withQuery(QueryBuilders.matchQuery("title", title))
                .build();
        elasticsearchRestTemplate.delete(nativeSearchQuery, Blog.class, IndexCoordinates.of("blog"));
    }
    @PostMapping("deleteDocumentAll")
    public void deleteDocumentAll() {
        NativeSearchQuery nativeSearchQuery = new NativeSearchQueryBuilder()
                .withQuery(QueryBuilders.matchAllQuery())
                .build();
        elasticsearchRestTemplate.delete(nativeSearchQuery, Blog.class, IndexCoordinates.of("blog"));
    }
}

2.3.2 查询的方法

Query接口有3个抽象实现：
在这里插入图片描述
此处使用NativeSearchQuery。因为它更贴近ES，语法更偏向ES原来的命令。CriteriaQuery的语法跟JPA的差不多。

2.3.3构建Query

可通过new NativeSearchQueryBuilder()来构建NativeSearchQuery对象。NativeSearchQuery中有众多的方法来为我们实现复杂的查询与筛选等操作。其中build()返回NativeSearchQuery。
在这里插入图片描述

2.3.4 QueryBuilders构造复杂查询条件

NativeSearchQueryBuilder中接收QueryBuilder。

public NativeSearchQueryBuilder withQuery(QueryBuilder queryBuilder) {
	this.queryBuilder = queryBuilder;
	return this;
}

可以用QueryBuilders构造QueryBuilder对象：
在这里插入图片描述

2.3.5 基本查询

通过标题和内容来查找博客：

package com.elk;

import com.elk.entity.Blog;
import org.apache.commons.lang3.StringUtils;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.elasticsearch.core.ElasticsearchRestTemplate;
import org.springframework.data.elasticsearch.core.SearchHit;
import org.springframework.data.elasticsearch.core.SearchHits;
import org.springframework.data.elasticsearch.core.query.NativeSearchQueryBuilder;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.ArrayList;
import java.util.List;
// 动态查询
@RestController
@RequestMapping("dynamicQuery")
public class DynamicQueryController {
    @Autowired
    private ElasticsearchRestTemplate elasticsearchRestTemplate;
    // 简单查询
    @GetMapping("simple")
    public List<Blog> simple(String title, String content) {
        NativeSearchQueryBuilder query = new NativeSearchQueryBuilder();
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
        if (StringUtils.isNotBlank(title)) {
            boolQueryBuilder.must(QueryBuilders.matchQuery("title", title));
        }
        if (StringUtils.isNotBlank(content)) {
            boolQueryBuilder.must(QueryBuilders.matchQuery("content", content));
        }
        query.withQuery(boolQueryBuilder);
        SearchHits<Blog> searchHits = elasticsearchRestTemplate.search(query.build(), Blog.class);
        List<Blog> blogs = new ArrayList<>();
        for (SearchHit<Blog> searchHit : searchHits) {
            blogs.add(searchHit.getContent());
        }
        return blogs;
    }
}

postman调用：

在这里插入图片描述

2.3.6 分页排序

通过标题和作者来查找博客，分页，并根据创建时间倒序排序。

// 分页排序
    @GetMapping("pageAndSort")
    public Page<Blog> pageAndSort(String title, String author) {
        PageRequest pageRequest = PageRequest.of(0, 2);
        NativeSearchQueryBuilder query = new NativeSearchQueryBuilder();
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
        if (StringUtils.isNotBlank(title)) {
            boolQueryBuilder.must(QueryBuilders.matchQuery("title", title));
        }
        if (StringUtils.isNotBlank(author)) {
            boolQueryBuilder.must(QueryBuilders.matchQuery("author", author));
        }
        query.withQuery(boolQueryBuilder);
        query.withPageable(pageRequest);
        query.withSort(SortBuilders.fieldSort("createTime").order(SortOrder.DESC));
        SearchHits<Blog> searchHits = elasticsearchRestTemplate.search(query.build(), Blog.class);
        List<Blog> blogs = new ArrayList<>();
        for (SearchHit<Blog> searchHit : searchHits) {
            blogs.add(searchHit.getContent());
        }
        return new PageImpl<Blog>(blogs, pageRequest, searchHits.getTotalHits());
    }

postman调用：
在这里插入图片描述

2.3.7 去重

通过标题和作者来查找博客，根据作者来去重。

// 去重
    @GetMapping("collapse")
    public List<Blog> collapse(String title, String author) {
        PageRequest pageRequest = PageRequest.of(0, 2);
        NativeSearchQueryBuilder query = new NativeSearchQueryBuilder();
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
        if (StringUtils.isNotBlank(title)) {
            boolQueryBuilder.must(QueryBuilders.matchQuery("title", title));
        }
        if (StringUtils.isNotBlank(author)) {
            boolQueryBuilder.must(QueryBuilders.matchQuery("author", author));
        }
        query.withQuery(boolQueryBuilder);
        query.withPageable(pageRequest);
        query.withSort(SortBuilders.fieldSort("createTime").order(SortOrder.DESC));
        // 去重的字段不能是text类型。所以，author的mapping要有keyword，且通过author.keyword去重。
        query.withCollapseField("author.keyword");
        //query.withCollapseField("category");
        SearchHits<Blog> searchHits = elasticsearchRestTemplate.search(query.build(), Blog.class);
        List<Blog> blogs = new ArrayList<>();
        for (SearchHit<Blog> searchHit : searchHits) {
            blogs.add(searchHit.getContent());
        }
        return blogs;
    }

postman调用：
在这里插入图片描述

2.3.8 聚合

查询标题中带有“java”的每个作者的文章数量。

//聚合
    @GetMapping("aggregation")
    public Map<String, Long> aggregation() {
        NativeSearchQueryBuilder query = new NativeSearchQueryBuilder();
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
        boolQueryBuilder.must(QueryBuilders.matchQuery("title", "java"));
        query.withQuery(boolQueryBuilder);
        // 作为聚合的字段不能是text类型。所以，author的mapping要有keyword，且通过author.keyword聚合。
        query.addAggregation(AggregationBuilders.terms("per_count").field("author.keyword"));
        // 不需要获取source结果集，在aggregation里可以获取结果
        query.withSourceFilter(new FetchSourceFilterBuilder().build());
        SearchHits<Blog> searchHits = elasticsearchRestTemplate.search(query.build(), Blog.class);
        Aggregations aggregations = searchHits.getAggregations();
        assert aggregations != null;
        //因为结果为字符串类型 所以用ParsedStringTerms。其他还有ParsedLongTerms、ParsedDoubleTerms等
        ParsedStringTerms per_count = aggregations.get("per_count");
        Map<String, Long> map = new HashMap<>();
        for (Terms.Bucket bucket : per_count.getBuckets()) {
            map.put(bucket.getKeyAsString(), bucket.getDocCount());
        }
        return map;
    }

postman调用：
在这里插入图片描述

2.3.9 嵌套聚合

查询标题中带有“java”的每个作者的文章数量，再查出各个作者的最新的发文时间。

// 嵌套聚合
    @GetMapping("subAggregation")
    public Map<String, Map<String, Object>> subAggregation() {
        NativeSearchQueryBuilder query = new NativeSearchQueryBuilder();
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
        boolQueryBuilder.must(QueryBuilders.matchQuery("title", "java"));
        query.withQuery(boolQueryBuilder);
        query.addAggregation(AggregationBuilders.terms("per_count").field("author.keyword")
                .subAggregation(AggregationBuilders.max("latest_create_time").field("createTime"))
        );
        // 不需要获取source结果集，在aggregation里可以获取结果
        query.withSourceFilter(new FetchSourceFilterBuilder().build());
        SearchHits<Blog> searchHits = elasticsearchRestTemplate.search(query.build(), Blog.class);
        Aggregations aggregations = searchHits.getAggregations();
        assert aggregations != null;
        //因为结果为字符串类型 所以用ParsedStringTerms。其他还有ParsedLongTerms、ParsedDoubleTerms等
        ParsedStringTerms per_count = aggregations.get("per_count");
        Map<String, Map<String, Object>> map = new HashMap<>();
        for (Terms.Bucket bucket : per_count.getBuckets()) {
            Map<String, Object> objectMap = new HashMap<>();
            objectMap.put("docCount", bucket.getDocCount());
            ParsedMax parsedMax = bucket.getAggregations().get("latest_create_time");
            objectMap.put("latestCreateTime", parsedMax.getValueAsString());
            map.put(bucket.getKeyAsString(), objectMap);
        }
        return map;
    }

postman调用：
在这里插入图片描述

2.3.10 application.yml

server:
  port: 8080

spring:
  elasticsearch:
    rest:
      # 如果是集群，用逗号隔开
      uris: http://10.86.97.210:9200
      username: elastic
      password: test@123456
      connection-timeout: 1
      read-timeout: 30

  # 上边是客户端High Level REST Client的配置，推荐使用。

# 下边是reactive客户端的配置，非官方，不推荐。
#  data:
#    elasticsearch:
#      client:
#        reactive:
#          endpoints: 127.0.0.1:9200
#          username: xxx
#          password: yyy
#          connection-timeout: 1
#          socket-timeout: 30
#          use-ssl: false

2.3.11 pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>

	<groupId>com.elk</groupId>
	<artifactId>spring-boot-elk</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>jar</packaging>

	<name>spring-boot-elk</name>
	<description>Demo project for Spring Boot</description>

	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.3.12.RELEASE</version>
		<relativePath /> <!-- lookup parent from repository -->
	</parent>

	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
		<java.version>1.8</java.version>
	</properties>

	<dependencies>
		<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-elasticsearch</artifactId>
		</dependency>

		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
			<optional>true</optional>
		</dependency>

		<dependency>
			<groupId>org.apache.commons</groupId>
			<artifactId>commons-lang3</artifactId>
			<version>3.12.0</version> <!-- 推荐稳定版本 -->
		</dependency>

	  </dependencies>
	
	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>
</project>

3.相关资源

百度网盘：https://pan.baidu.com/s/1qlabJ7m8BDm77GbDuHmbNQ?pwd=41ac

在这里插入图片描述

ELK 企业级日志分析系统
Decp_的博客
07-06 1252
ELK平台是一套完整的日志集中处理解决方案，将 ElasticSearch、Logstash 和 Kiabana 三个开源工具配合使用， 完成更强大的用户对日志的查询、排序、统计需求。ElasticSearch：是基于Lucene（一个全文检索引擎的架构）开发的分布式存储检索引擎，用来存储各类日志。Elasticsearch 是用 Java 开发的，可通过 RESTful Web 接口，让用户可以通过浏览器与 Elasticsearch 通信。
ELK大型环境部署
08-15
在进行ELK部署时，对于 iptables 的配置和优化也是至关重要的。文档中提到了需要清理原有的iptables规则，并开放必要的端口来确保ELK各组件之间的通信不受阻碍，同时还要防止未授权访问。这通常涉及使用iptables命令...
ELK部署与使用详解
qq_51470789的博客
07-14 1102
ELK实战部署
ELK日志分析实战宝典：从入门到服务器部署与应用（含ELK，部署启动全流程）
weixin_45065854的博客
01-10 1712
它提供了一个分布式多用户能力的全文搜索引擎。Elasticsearch是用Java开发的，并作为Apache许可条款下的开放源码发布，是第二流行的企业搜索引擎。设计用于云计算中，能够达到实时搜索，稳定，可靠，快速，安装使用方便。在elasticsearch中，所有节点的数据是均等的。
ELK 企业级日志分析系统之集群部署
2301_76858832的博客
07-12 1979
node1节点（ 2 C / 4 G）：node1 / 192.168 .247 .80 node2节点（ 2 C / 4 G）：node2 / 192.168 .247 .90 Apache节点：apache / 192.168 .247 .131输入采用标准输入，输出采用标准输出（类似管道），新版本默认使用 rubydebug 格式输出使用 rubydebug 输出详细格式显示，codec 为一种编解码器使用 Logstash 将信息写入 Elasticsearch 中。
elk6.4.3安装部署指导手册
zxcsd11的博客
12-30 720
本文意在指导elk6.4.3安装配置文档，包含elasticsearch、elasticsearch-head、filebat、logsearch、kibana等插件的安装配置，并抓取系统日志。
Docker Compose 部署 ELK 技术栈优化：资源配置与性能调优
2501_92489088的博客
06-21 745
本文从资源配置、性能调优、网络优化等方面，详细介绍了如何使用Docker Compose部署ELK技术栈。通过合理的资源分配、性能优化和网络安全策略，可以有效地提高ELK技术栈的性能和稳定性。集成更多数据源，拓展ELK技术栈的应用场景。深入研究Elasticsearch和Logstash的内部机制，挖掘更多性能优化手段。探索自动化运维工具，简化ELK技术栈的部署和管理过程。通过不断优化和改进，ELK技术栈将更好地服务于数据分析和日志管理领域，为企业的数字化转型提供有力支持。
日志分析体系：ELK Stack 与 OpenTelemetry 集成方案
2501_92585248的博客
06-27 736
从最初Elasticsearch、Logstash、Kibana的三角组合，到新增Fluentd后的四件套架构，这套工具正在经历静默革命。就像老式收音机升级为智能音箱，Fluentd现在不仅能做日志管道的"搬运工"，还能处理数据清洗和路由分发。OpenTelemetry的出现就像给系统装上了"透视眼"，不仅能捕获代码级别的性能数据，还能自动生成分布式 traces。将索引按季度划分，同时设置30天滚动窗口，这样既能保证实时查询速度，又能节省存储成本。这种"数据湖+数据溪"的架构，正在重构我们的监控范式。
Java性能调优
刘皇叔说Java的博客
08-12 1140
性能调优的策略Java 性能调优是一项综合性工作，需要从代码、JVM 配置、I/O、数据库、并发处理、缓存、部署等多个方面进行优化。通过合理的调优策略，可以显著提升应用的性能，确保系统在高负载下稳定、高效地运行。定期的性能监控和分析也同样重要，可以帮助快速定位和解决性能瓶颈问题。批量Java 性能调优是一项复杂且多层次的工作，涉及代码、JVM 配置、并发处理、内存管理等多个方面。
ELK 日志分析系统
kgc302的博客
07-01 1145
在数字化转型加速的今天，企业IT系统每天产生海量日志数据，涵盖应用运行状态、用户行为、安全事件等关键信息。然而，传统日志管理方式因分散存储、检索效率低、缺乏深度分析能力，已难以满足高效运维与业务洞察的需求。ELK(Elasticsearch + Logstash + Kibana)作为业界主流的开源日志分析解决方案，通过 Elasticsearch 的分布式搜索与分析能力、Logstash 的数据管道处理、Kibana 的可视化交互，构建了从日志采集、清洗、存储到实时分析的完整闭环。
【大数据环境中的AI部署】：AutoGLM部署与调优策略
[真正的Agent来了，智谱新模型AutoGLM的相关应用，以及AutoGLM的python代码部署实战](https://food-town.jp/product/images/M000223/P00000419_1716960005_image_main.png) # 1. 大数据环境与AI技术概述 ## 1.1 ...
ELK堆栈部署实践指南与详解
- 系统的测试和调优，确保整个ELK栈高效运行。 ELK技术栈的应用场景非常广泛，从简单的日志分析到复杂的业务监控和数据探索，都可以使用ELK来实现。在大数据时代，随着数据量的不断增长，ELK技术栈在处理、分析和...
Kubernetes ELK集成指南：ElasticSearch，Kibana，Logstash部署详解
恢复策略通常涉及到如何快速恢复ELK服务到正常运行状态，包括灾难恢复和数据迁移等场景。 总结 在Kubernetes上部署ELK栈涉及到复杂的配置和管理操作。通过对Elasticsearch、Kibana、Logstash的深入配置和集群管理...
ELK集群部署、操作与升级全攻略：日志管理与数据分析
4. Zookeeper和Kafka的集成：介绍了Zookeeper在分布式系统中的角色，以及Kafka的基本操作和测试配置策略，强调了它们在ELK架构中的协同工作。 5. Logstash的应用：作为数据管道的关键组件，Logstash被用来收集和...
基于ELK Stack的实时日志分析与智能告警实践指南
qq_35716689的博客
08-02 589
本文分享了在生产环境中基于ELK Stack搭建实时日志分析与智能告警平台的完整实战经验，包括日志采集、存储管理、可视化与告警、自动化运维等关键技术环节，并总结了常见问题与最佳实践，助力运维和开发团队快速响应故障，提高系统可靠性。
K8S部署ELK（二）：部署Kafka消息队列
weixin_74812406的博客
08-02 676
K8S部署ELK（二）：部署Kafka消息队列
K8S部署ELK（四）：部署logstash
weixin_74812406的博客
08-03 439
Logstash 是一个开源的数据收集引擎，具有实时管道处理能力，属于 Elastic Stack（原 ELK Stack）的一部分，常与 Elasticsearch 和 Kibana 配合使用。
K8S部署ELK（五）：集成Kibana实现日志可视化
最新发布
weixin_74812406的博客
08-03 468
Kibana 是一个开源的数据可视化和分析平台，是 Elastic Stack（原 ELK Stack）的核心组件之一，专门设计用于与 Elasticsearch 协同工作。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

core321

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值