This article explains why centralized logging is essential for modern micro‑service systems, outlines an ELK‑based architecture with Filebeat, Kafka, Logstash, Elasticsearch and Kibana, and provides detailed configuration examples for both file‑based and Kubernetes‑based log collection, plus visualization techniques.
The Venus log platform at iQiyi migrated from an ElasticSearch‑Kibana architecture to an Iceberg‑based data lake with Trino, cutting storage and compute costs by over 70%, boosting stability by 85%, and efficiently supporting billions of daily logs through write‑heavy, low‑query workloads.
Learn step‑by‑step how to install and configure Elasticsearch, Kibana, and Logstash, integrate them with a Spring Boot 2.4.12 application, and use Kibana to view logs, covering environment setup, service startup, configuration files, and sample code.
This article presents a traffic‑driven quality assurance framework for an Elasticsearch‑based search service, detailing active and inactive code protection strategies, automated scenario generation from Dubbo logs, template fingerprinting, de‑duplication, expected result pools, and validation rules to ensure comprehensive test coverage and reliable regression.
This article details the design and implementation of a highly available, high‑performance membership system serving over a billion users, covering dual‑center Elasticsearch clusters, traffic‑isolated three‑cluster ES architecture, Redis dual‑center caching, MySQL partitioned clusters, migration strategies, and refined flow‑control and degradation mechanisms.
This guide shows how to quickly create a complete image-and-text search solution using Volcano Engine's ESCloud, the CLIP model for feature extraction, and Python, covering data preparation, environment setup, index mapping, bulk indexing, and both text-to-image and image-to-image queries.
This article explains how Elasticsearch pagination works with from/size, why deep paging can cause performance problems, and compares alternative techniques such as Scroll, Scroll‑Scan, Sliced Scroll, Search After, and point‑in‑time (PIT) searches for handling large result sets efficiently.
Didi hardened its massive Elasticsearch deployment—spanning 66 clusters and thousands of nodes—by adding a custom security plugin that authenticates requests at the cluster level, implementing a one‑click toggle and staged rolling upgrades, ultimately enabling authentication across all clusters and dramatically reducing data‑leak risk.
By integrating ZSTD compression into Didi’s Elasticsearch 7.6, the team cut CPU usage by about 15 %, reduced index storage roughly 30 %, boosted write throughput up to 25 %, and eliminated over 20 servers, demonstrating a faster, more storage‑efficient solution for petabyte‑scale log ingestion.
Didi upgraded its self‑developed Elasticsearch from JDK 11/G1 to JDK 17, adopting ZGC for latency‑critical clusters and tuned G1 for throughput, which eliminated long GC pauses, reduced query latency by up to 96%, cut CPU usage, and dramatically improved stability across multiple production clusters.
The article examines a 7‑node Elasticsearch cluster with 500 million documents, uncovering excessive heap usage, high OS memory pressure, numerous deleted documents, large translog, low query‑cache hit rate, and an over‑sharded design, then offers concrete tuning and redesign recommendations to restore performance.
This article details the end‑to‑end high‑availability architecture—including dual‑center Elasticsearch clusters, Redis caching with distributed locks, and a dual‑center MySQL partitioned setup—that enables a membership platform serving billions of users to sustain massive traffic while ensuring data consistency and rapid recovery.
This article explains Didi's self‑developed DCDR system that replicates Elasticsearch indices across data‑center clusters, detailing its design goals, core mechanisms, chain construction, historical data recovery, real‑time sync, and data‑quality validation to ensure high availability and strong consistency.
This article compares Elasticsearch and ClickHouse by examining their underlying architectures, node roles, query languages, and performance through a series of benchmark tests using Docker‑compose, Vector data pipelines, and Python SDKs, revealing ClickHouse’s superior speed in most query scenarios despite lacking advanced search features.
This article compares Elasticsearch and ClickHouse across architecture, query capabilities, and performance using Docker‑compose stacks and Python SDK tests, demonstrating that ClickHouse often delivers superior speed, especially in aggregation and regex queries, while highlighting each system’s design trade‑offs.
This article introduces advanced Elasticsearch query techniques, covering boolean queries with must/must_not/should clauses, range and fuzzy queries, filter usage that does not affect scoring, and single- and multi-field sorting, each illustrated with concrete request examples.
The article compares four MySQL‑to‑Elasticsearch synchronization approaches—synchronous dual‑write, asynchronous dual‑write via MQ, timer‑based SQL extraction, and binlog‑based real‑time sync—evaluates their trade‑offs, and recommends practical tools such as Canal, DTS, and Databus for implementation.
This article compares Elasticsearch and ClickHouse as log‑search solutions, detailing their architectures, Docker‑compose deployments, data‑ingestion pipelines with Vector, query syntax differences, and benchmark results that show ClickHouse generally outperforms Elasticsearch in speed and aggregation efficiency.
This article explains the design, implementation, and iterative optimization of Boss Circle's recommendation engine, covering the initial simple ranking, the introduction of Elasticsearch‑based scoring, multi‑pool data sources, machine‑learning experiments, real‑time feature handling, and future personalization challenges.
This article provides a detailed overview of Elasticsearch, covering its underlying Lucene technology, data types, indexing mechanisms, cluster architecture, shard and replica management, mapping definitions, installation steps, health monitoring, write and storage processes, and performance optimization techniques for production deployments.
This article compares Elasticsearch and ClickHouse by describing their architectures, presenting Docker‑based test stacks, showing code snippets for deployment, data ingestion, and queries, and reporting performance results that demonstrate ClickHouse generally outperforms Elasticsearch in log‑analytics scenarios.
This guide explains the three main ELK deployment architectures, compares Logstash and Filebeat collectors, introduces a cache‑queue option for high‑volume logs, and provides practical solutions for multiline log merging, timestamp correction, and module‑level filtering in Kibana, helping operations teams build efficient log pipelines.
This article analyzes a 7‑node Elasticsearch cluster with 500 million documents, revealing excessive shard count, high heap and OS memory usage, large translog, low query‑cache hit rate, and heavy I/O, and offers concrete recommendations on mapping, sharding, JVM tuning, and resource management to restore performance.
The article describes how a membership system serving billions of users across multiple platforms achieves high performance and high availability through dual‑center Elasticsearch clusters, traffic‑isolated three‑cluster ES architecture, Redis caching with distributed locks, dual‑center MySQL partitioning, and fine‑grained flow‑control and degradation strategies.
This article details the end‑to‑end process of moving Qunar's massive Elasticsearch logging cluster from a saturated data‑center to a new facility, covering background constraints, migration planning, manual and automated steps, performance‑tuning parameters, shard‑balancing techniques, and the final outcomes achieved.
This article explains how large hotel‑booking platforms such as Airbnb, Booking.com and OYO use a micro‑service architecture—including hotel management, customer search/booking, and view‑booking services—combined with load balancers, Kafka, Elasticsearch, Redis, Cassandra and Hadoop to achieve a seamless, high‑throughput booking flow.
This guide demonstrates how to integrate Spring Boot 2.3.10 with Elasticsearch 7.8 using the high‑level REST client, covering required Maven dependencies, index creation, retrieval, deletion, document CRUD operations, bulk processing, and a variety of advanced search techniques such as paging, sorting, filtering, range, highlighting, aggregations, and grouping.
The article investigates a deadlock caused by Elasticsearch BulkProcessor during massive MQ message processing, explains how thread‑pool contention and retry logic lead to lock starvation, and proposes version upgrades or disabling retries to restore stable consumption.
This guide demonstrates how to integrate Spring Boot 2.3.10 with Elasticsearch 7.8, covering Maven dependencies, application configuration, data model annotations, repository interfaces, custom query methods, and comprehensive JUnit tests using both repository and ElasticsearchRestTemplate approaches.
This article compares PostgreSQL and Elasticsearch for full‑text search in Django applications, presenting performance benchmarks on up to 1.5 million records, discussing setup complexity, features like stemming and fuzziness, and concluding that PostgreSQL is preferable for most projects without massive data scales.
This guide explains why Logstash may import fewer rows from a large PostgreSQL table into Elasticsearch, and provides two practical solutions—ID comparison via shell scripts and accelerated comparison using Redis—to quickly identify and resolve data inconsistencies.
This article presents comprehensive best‑practice recommendations for optimizing Elasticsearch deployments, covering hardware selection, RAID choices, index and shard planning, query and caching strategies, bulk indexing, refresh intervals, monitoring tools, version upgrades, and lifecycle management to achieve high performance, reliability, and scalability.
This tutorial walks through installing the Elasticsearch PHP client, creating and managing indices, performing single and bulk document operations, executing queries, updates, deletions, and demonstrates integration with ThinkPHP6 for product search and management.
This article explores the challenges of distributed join queries, detailing MySQL sharding‑jdbc join implementation, routing strategies, and code examples, then examines Elasticsearch‑SQL join capabilities, various join algorithms, and practical considerations for using nested types, offering insights for optimizing performance in distributed data environments.
This article details the design and implementation of a highly available, high‑performance membership platform serving over a billion users, covering Elasticsearch dual‑center clusters, traffic‑isolated clusters, deep ES optimizations, Redis caching strategies, MySQL dual‑center partitioning, seamless migration, and fine‑grained flow‑control and degradation mechanisms.
This article details a comprehensive investigation of an out‑of‑memory crash in a critical Elasticsearch cluster, explains how GC logs and heap dumps revealed a to‑space‑exhausted condition, and describes the G1GC tuning parameters that eliminated the nightly spikes and stabilized performance.
This article details the background, challenges, migration plan, automation, and performance‑tuning techniques used to relocate a petabyte‑scale Elasticsearch logging cluster from one data center to another, highlighting practical lessons and measurable improvements in stability and migration speed.
This article details the design and implementation of a highly available, high‑performance membership system that serves over a billion users, covering Elasticsearch dual‑center HA, traffic‑isolated clusters, Redis caching, MySQL dual‑center partitioning, seamless migration, and refined flow‑control and degradation strategies.
Elasticsearch 8.8.0, the latest release of the Lucene‑based distributed search engine, introduces numerous bug fixes across aggregations, allocation, application and authorization, deprecates certain allocation settings, and adds new capabilities such as templated search APIs, JWT authentication, DLM enhancements, health metrics, ingest node licensing checks, machine‑learning query extensions, ranking improvements, search enhancements, and TSDB support.
The article introduces the ECP system, a backend platform built on Elasticsearch that standardizes, automates, and visualizes index refresh workflows, addressing manual bottlenecks, data cleaning challenges, and coupling issues while providing task management, permission control, and environment isolation for high‑efficiency index operations.
This article presents a comprehensive engineering case study of a high‑traffic membership system, detailing the dual‑center Elasticsearch high‑availability design, traffic‑isolated three‑cluster ES architecture, Redis caching strategy, dual‑center MySQL partitioning and migration plan, abnormal member relationship governance, and future fine‑grained flow‑control and downgrade policies.
This article compares Elasticsearch and ClickHouse for log analytics by detailing their architectures, setting up Docker‑Compose stacks, ingesting synthetic syslog data with Vector, running equivalent queries, and measuring performance, revealing ClickHouse’s superior speed in most scenarios.
By defining index sorting on the publish_time field when creating the Elasticsearch index, the team transformed a multi‑second full‑scan query into a sub‑50 ms operation, demonstrating that pre‑ordered storage dramatically speeds up large‑result‑set sorts while modestly affecting write throughput.
This article compares Elasticsearch and ClickHouse as log‑analytics solutions, detailing their architectures, node roles, data ingestion pipelines, query capabilities, and benchmark results, ultimately showing ClickHouse’s superior performance in most tested scenarios.
This article details the design and implementation of a high‑performance, highly available membership platform serving billions of users, covering dual‑center Elasticsearch clusters, traffic‑isolated three‑cluster ES architecture, Redis caching strategies, MySQL dual‑center partitioning, seamless migration, and fine‑grained flow‑control and degradation mechanisms.
This article compares four common approaches for synchronizing MySQL data to Elasticsearch—synchronous dual write, asynchronous dual write via message queues, scheduled tasks, and binlog‑based data subscription—detailing their advantages, drawbacks, implementation steps, and tool choices such as Canal, Maxwell, and Python‑MySQL‑Replication.
This guide explains why Logstash may import fewer rows than exist in a PostgreSQL table, and provides two practical methods—shell‑script ID comparison and Redis‑accelerated set operations—to reliably detect and troubleshoot missing records in Elasticsearch.
This article presents a practical comparison between Elasticsearch and ClickHouse, detailing their architectures, Docker‑Compose deployment, data ingestion pipelines, a series of representative queries, and benchmark results that show ClickHouse generally outperforms Elasticsearch in basic search and aggregation scenarios.
This article compares Elasticsearch and ClickHouse by describing their architectures, demonstrating a Docker‑compose test environment, executing equivalent queries via both systems, and presenting performance results that show ClickHouse generally outperforms Elasticsearch in basic search and aggregation scenarios for log data.
This article compares Elasticsearch and ClickHouse by outlining their architectures, detailing deployment configurations, presenting benchmark queries and performance results, and concluding that ClickHouse generally outperforms Elasticsearch in many basic search and aggregation scenarios, while also noting each system's strengths and limitations.
This tutorial walks through using Spring Boot with Elasticsearch's Java High Level REST Client, covering project setup, dependency configuration, client creation, index mapping, data insertion, various search techniques, and aggregation analysis, all with complete code examples.
Alibaba Cloud unveiled the fully serverless Elasticsearch architecture at the 2023 Elastic China Developer Conference, highlighting cloud‑native upgrades, the OpenStore storage engine, and TimeStream time‑series enhancements that dramatically improve cost efficiency, scalability, and query performance.
This article details the design and implementation of a high‑availability, billion‑scale membership system, covering Elasticsearch dual‑center clusters, traffic‑isolated architectures, deep ES optimizations, Redis caching strategies, MySQL migration with dual‑center partitioning, abnormal member relationship handling, and future fine‑grained flow‑control and degradation plans.
This article explains the challenges of testing in a rapidly evolving banking system and introduces a traffic recording and replay platform that automates test case generation, improves coverage, and reduces manual effort through web‑server, network‑stack, and application‑level recording techniques.
At the 2023 Elastic China Developer Conference in Shenzhen, Peng Cheng of Hello Technology will demonstrate how migrating online machine‑learning predictions into Elasticsearch can exploit its distributed architecture to rank thousands of models, expand model types and computational depth, and unlock new growth opportunities for business applications, underscoring the event’s status as China’s premier Elasticsearch open‑source technology forum.
Echo is a full‑stack open‑source Java community system built with Spring Boot, MyBatis, MySQL, Redis, Kafka and Elasticsearch, offering modules like posts, comments and notifications, and the article provides its core tech stack, development environment, local setup steps, deployment architecture, demo screenshots and source code access.
This guide explores practical strategies for managing Elasticsearch indexes, covering management approaches, structural maintenance, data synchronization, refresh policies, and deep pagination techniques to avoid common pitfalls and ensure reliable search performance.
This article explains how to design and implement a real‑time, multi‑tenant site search system by migrating data from MySQL to Elasticsearch using Kafka and MySQL binlog, covering architecture decisions, data schema, Docker deployment, and core SpringBoot/Kotlin code for event collection and indexing.
This article explains the concepts of database sharding, compares vertical and horizontal partitioning, discusses ID‑range and modulo sharding methods, analyzes the read‑amplification problem caused by non‑sharding keys, and presents practical solutions such as auxiliary index tables, Elasticsearch integration, and TiDB adoption.
This article explains how a location‑based service platform uses geofencing, R‑tree indexing, ray‑casting algorithms, and Elasticsearch GEO queries to determine service eligibility, allocate on‑site engineers, plan routes, and enable autonomous order scheduling for a C2B recycling business.
This article explains how to construct near real-time Elasticsearch indexes for petabyte‑scale datasets by comparing MySQL limitations, introducing ES fundamentals, leveraging Hive and wide tables, and employing binlog‑based tools like Canal and Otter for low‑latency data synchronization.
This article documents the evolution of a data platform, explains Elasticsearch and Lucene fundamentals, and presents practical index and search performance optimizations—including bulk writes, refresh control, memory allocation, doc‑values tuning, and pagination strategies—that enable cross‑month queries and sub‑second responses on billions of records.
The article describes how a large‑scale membership system serving over a billion users achieves high performance and availability through dual‑center Elasticsearch clusters, traffic‑isolated three‑cluster designs, Redis caching with distributed locks, and a seamless migration from SQL Server to sharded MySQL, while also detailing operational safeguards and fine‑grained flow‑control strategies.
This article provides a comprehensive, hands‑on tutorial for configuring Alibaba Canal and its client‑adapter to capture MySQL binlog changes and synchronize them into Elasticsearch, covering environment setup, Docker commands, YAML configuration files, index mapping, adapter startup, and common troubleshooting scenarios.
The article describes how an e‑commerce product ranking system was migrated to the new “Liao Yue” platform, decoupling it from the search module, introducing fresh metrics and Elasticsearch‑based sorting, then optimizing storage by separating B‑end and C‑end data—cutting costs 60%—with a gray‑scale rollout, dual‑read validation, rollback safeguards, and completing the two‑week, zero‑failure migration that delivered a closed‑loop, faster iteration system.
This article describes how a membership platform serving over ten billion users achieves high performance and fault tolerance through a dual‑center Elasticsearch cluster, traffic‑isolated three‑cluster ES design, Redis multi‑center caching, and a seamless migration from SQL Server to a partitioned MySQL architecture, while detailing operational safeguards and fine‑grained flow‑control strategies.
This comprehensive guide explains what Elasticsearch does, its underlying Lucene technology, core concepts such as clusters, shards, replicas, mapping, indexing and storage mechanisms, and provides practical performance‑tuning advice for building and operating a robust distributed search engine.
This article explores four common approaches for synchronizing product data from MySQL to Elasticsearch in e‑commerce systems—synchronous dual write, asynchronous dual write with message queues, scheduled tasks, and binlog‑based data subscription—detailing their advantages, drawbacks, and implementation considerations.
This article examines a business requirement to filter and rank up to 100,000 records from a pool of tens of millions, presenting and evaluating four technical solutions—multithreaded ClickHouse pagination, Elasticsearch scroll‑scan deep paging, an ES‑HBase combined query, and a RediSearch + RedisJSON approach—along with performance data and code examples.
This article explores four common approaches for synchronizing product data from MySQL to Elasticsearch—including synchronous dual writes, asynchronous messaging, scheduled jobs, and binlog‑based data subscription—detailing their advantages, drawbacks, and implementation considerations for e‑commerce search systems.
This article examines four common approaches for synchronizing product data from MySQL to Elasticsearch—synchronous dual write, asynchronous dual write with message queues, scheduled batch jobs, and binlog‑based data subscription—detailing their advantages, drawbacks, and implementation considerations.
This article details Meituan's search‑engine optimization for its food‑delivery platform, describing the performance bottlenecks of Elasticsearch's inverted‑list query and merge phases, the design of a run‑length‑encoding (RLE) index, custom hash‑map term look‑ups, sparse RoaringBitmap structures, integration steps, and the resulting 84% latency reduction.
This article introduces the ELK stack’s core components, compares three typical deployment architectures—including Logstash‑only, Filebeat‑assisted, and Kafka‑backed designs—highlights their trade‑offs, and provides practical solutions for multiline log merging, timestamp correction, and module‑specific filtering using Logstash and Filebeat configurations.
This article details the evolution of Ctrip's log infrastructure, describing the shift from fragmented departmental logging to a unified Elasticsearch-based platform, the migration to ClickHouse for cost‑effective, high‑performance storage, and the subsequent Log 3.0 redesign that leverages Kubernetes, sharding, and a unified query governance layer to handle petabyte‑scale data.
This tutorial provides a thorough overview of Elasticsearch 7.13.2 query techniques—including term, terms, range, prefix, wildcard, boolean, filter, and aggregation queries—showing both raw DSL syntax and equivalent Java High Level REST Client code, enabling developers to quickly master search operations on large datasets.
This article explains how to handle massive order volumes by classifying data into hot and cold tiers, storing them in MySQL, Elasticsearch, and Hive, and implementing sharding and partitioning strategies—including shard keys, modulo routing, and combined database‑table distribution—to achieve high throughput and low cost.
This tutorial walks through setting up an Elasticsearch server, creating a Java REST client, implementing a custom GET‑with‑body request, building a reusable ESClient wrapper with common CRUD and search methods, and providing Groovy performance test cases for indexing and querying.
This article compares Elasticsearch and ClickHouse in terms of write throughput, query speed, and server cost, then provides a step‑by‑step deployment guide for a private data pipeline using Zookeeper, Kafka, FileBeat, and ClickHouse, along with common issues and their solutions.
This tutorial explains how to install and configure Elasticsearch and Kibana, demonstrates CRUD operations, bulk data import, and shows how to use Logstash to ingest, transform, and index flight JSON data, covering both batch and near‑real‑time processing techniques.
The article explains how to handle billions of daily orders by classifying data into hot and cold segments, storing them in MySQL, Elasticsearch, and Hive, and applying sharding and partitioning techniques at both table and database levels to achieve scalable performance.
This article explains Elasticsearch’s core concepts—including inverted indexes, shard architecture, node roles, and the detailed write‑read‑search workflow—so readers can grasp how the system achieves near‑real‑time search and reliable data storage.
This article explains Elasticsearch's inverted index structure, sharding and replica concepts, cluster node roles, and the detailed write, read, search, delete, and update processes, illustrating how data moves from memory to disk and becomes searchable in near real‑time.
This article explains the fundamentals of structured and unstructured data, introduces Lucene’s inverted index, and details how Elasticsearch builds on Lucene to provide distributed, near‑real‑time search with concepts such as clusters, shards, replicas, routing, and performance optimizations.
This guide explains the different Elasticsearch node types, their default roles, how to configure master‑eligible, data, ingest, and coordinating‑only nodes, and provides best‑practice recommendations for planning and scaling large clusters to ensure stability and performance.
This article provides a comprehensive guide to Elasticsearch 7.x DSL query syntax, explaining core keywords, field mappings, various query types such as match, term, range, fuzzy, and bool, and includes practical code examples for building effective search queries.
The article provides a step‑by‑step guide for integrating Elasticsearch into a Spring Boot project, including Maven dependency configuration, creating a RestHighLevelClient, performing index and document CRUD operations, bulk processing, and advanced search queries with highlighting.
This tutorial explains how to create, query, update, and delete Elasticsearch indices and documents using RESTful HTTP requests, covering basic CRUD operations, various query types, pagination, sorting, aggregations, highlighting, and mapping definitions with practical JSON examples.
This article explains Elasticsearch’s fundamental building blocks, cluster roles, shard and replica strategies, master election, split‑brain prevention, inverted index structure, and the complete search and indexing lifecycle for handling large‑scale data efficiently.
This article details Meituan's search‑engine team optimization of Elasticsearch for a high‑traffic LBS scenario, describing the performance bottlenecks in term‑posting retrieval and merging, the design of a run‑length‑encoding (RLE) inverted index, its integration as a plugin, extensive benchmarking, and the resulting 84% reduction in TP99 query latency.
This article explains how a large‑scale membership system achieves high performance and high availability by using a dual‑center Elasticsearch cluster, traffic‑isolated three‑cluster architecture, Redis caching with dual‑center clusters, and a MySQL partitioned dual‑center setup, while also detailing optimization, migration, and fine‑grained flow‑control strategies.
This article analyzes Elasticsearch’s three pagination methods—from/size, scroll, and search after—explaining their internal query and fetch phases, performance trade‑offs for deep paging, and provides Java implementation examples and practical recommendations.
This article compares Solr and Elasticsearch, examining their cloud, analytics, and cognitive search capabilities, and provides guidance on selecting the most suitable engine based on factors such as deployment complexity, resource requirements, scalability, integration with Hadoop ecosystems, and specific organizational use cases.
The paper presents the design and deployment of a hundred‑billion‑scale real‑time monitoring platform that meets stringent data‑collection, analysis, storage, alerting and visualization requirements, compares Oceanus + Elastic Stack against a Zabbix‑Prometheus‑Grafana stack, selects the former, and details performance‑and cost‑optimizations that enable massive, low‑latency monitoring while maintaining high availability.
This article presents a comprehensive, three‑part guide on the current state of full‑stack operations monitoring, common challenges and solutions, and a real‑world use case, illustrating how Alibaba Cloud Elasticsearch can improve observability, boost performance, and cut costs for complex distributed systems.
This article details the design, architecture, and implementation of Meituan's Logan real‑time logging platform, covering its workflow, multi‑terminal collection SDK, ingestion, Flink‑based processing, consumption layers, stability measures, and future roadmap, illustrating how it improves fault diagnosis and system reliability.
Meituan's food‑delivery search team identified heavy CPU and latency hotspots in Elasticsearch's posting‑list query and merge phases, then redesigned the inverted index using Run‑Length Encoding, hash‑based term lookup, index sorting and a custom SparseRoaringDocIdSet, ultimately reducing TP99 search latency by 84% and cutting CPU usage dramatically.
This article describes Liulishuo's migration to a Flink‑based real‑time data warehouse, covering background, benefits, technology selection (storage, Flink platform, dimension table connectors), overall architecture, concrete Hudi and Elasticsearch ingestion examples, processing SQL, and future outlook for unified batch‑streaming storage.
This guide walks you through the full Elasticsearch data‑modeling workflow, covering business‑driven design, handling large data volumes, optimal settings, mapping choices, and complex parent‑child relationships, while providing practical code examples and visual diagrams for immediate application.
The investigation revealed that Elasticsearch RestClient’s built‑in round‑robin and dead‑node blacklisting redirected traffic from failed data‑node addresses—mistakenly included in the static IP list—onto a single client node, causing severe load imbalance and timeouts, which were eliminated after correcting the IP list.
This article explains why MySQL LIKE queries are inefficient for search, introduces Elasticsearch as a high‑performance alternative, and provides a complete Spring Boot integration tutorial—including version compatibility, Maven dependencies, Java configuration, entity mapping, repository interfaces, service and controller code, and testing steps—to implement CRUD‑style full‑text search for a book catalog.
