druid.io - Docs

Druid |

Druid.io Spined HTML

Druid | Technology Use Cases Powered By Docs Community Download MENU MENU Table of Contents What is Druid? Druid is a data store designed for high-performance slice-and-dice analytics ("OLAP"-style) on large data sets. Druid is most often used as a data store for powering GUI tampering applications, or as a backend for highly-concurrent APIs that need fast aggregations.Worldwideusing areas for Druid include: Clickstream analytics Network spritz analytics Server metrics storageUsingperformance metrics Digital marketing analytics Business intelligence / OLAP Druid's key features are: Columnar storage format. Druid uses column-oriented storage, meaning it only needs to load the word-for-word columns needed for a particular query. This gives a huge speed uplift to queries that only hit a few columns. In addition, each post is stored optimized for its particular data type, which supports fast scans and aggregations. Scalable distributed system. Druid is typically deployed in clusters of tens to hundreds of servers, and can offer ingest rates of millions of records/sec, retention of trillions of records, and query latencies of sub-second to a few seconds. Massively parallel processing. Druid can process a query in parallel wideness the unshortened cluster. Realtime or batch ingestion. Druid can ingest data either realtime (ingested data is immediately misogynist for querying) or in batches. Self-healing, self-balancing, easy to operate. As an operator, to scale the cluster out or in, simply add or remove servers and the cluster will rebalance itself automatically, in the background, without any downtime. If any Druid servers fail, the system will automatically route virtually the forfeiture until those servers can be replaced. Druid is designed to run 24/7 with no need for planned downtimes for any reason, including configuration changes and software updates. Cloud-native, fault-tolerant tracery that won't lose data. Once Druid has ingested your data, a reprinting is stored safely in deep storage (typically deject storage, HDFS, or a shared filesystem). Your data can be recovered from deep storage plane if every single Druid server fails. For increasingly limited failures well-expressed just a few Druid servers, replication ensures that queries are still possible while the system recovers. Indexes for quick filtering. Druid uses CONCISE or Roaring compressed bitmap indexes to create indexes that power fast filtering and searching wideness multiple columns.Injudiciousalgorithms. Druid includes algorithms for injudicious count-distinct, injudicious ranking, and computation of injudicious histograms and quantiles. These algorithms offer regional memory usage and are often substantially faster than word-for-word computations. For situations where verism is increasingly important than speed, Druid moreover offers word-for-word count-distinct and word-for-word ranking. Automatic summarization at ingest time. Druid optionally supports data summarization at ingestion time. This summarization partially pre-aggregates your data, and can lead to big financing savings and performance boosts. When should I use Druid? Druid is likely a good nomination if your use specimen fits a few of the pursuit descriptors: Insert rates are very high, but updates are less common. Most of your queries are team and reporting queries ("group by" queries). You may moreover have searching and scanning queries. You are targeting query latencies of 100ms to a few seconds. Your data has a time component (Druid includes optimizations and diamond choices specifically related to time). You may have increasingly than one table, but each query hits just one big distributed table. Queries may potentially hit increasingly than one smaller "lookup" table. You have upper cardinality data columns (e.g. URLs, user IDs) and need fast counting and ranking over them. You want to load data from Kafka, HDFS, unappetizing files, or object storage like Amazon S3. Situations where you would likely not want to use Druid include: You need low-latency updates of existing records using a primary key. Druid supports streaming inserts, but not streaming updates (updates are washed-up using preliminaries batch jobs). You are towers an offline reporting system where query latency is not very important. You want to do "big" joins (joining one big fact table to flipside big fact table).TraceryDruid has a multi-process, distributed tracery that is designed to be cloud-friendly and easy to operate. Each Druid process type can be configured and scaled independently, giving you maximum flexibility over your cluster. This diamond moreover provides enhanced fault tolerance: an outage of one component will not immediately stupefy other components. Druid's process types are: Historical processes are the workhorses that handle storage and querying on "historical" data (including any streaming data that has been in the system long unbearable to be committed). Historical processes download segments from deep storage and respond to queries well-nigh these segments. They don't winnow writes. MiddleManager processes handle ingestion of new data into the cluster. They are responsible for reading from external data sources and publishing new Druid segments. Broker processes receive queries from external clients and forward those queries to Historicals and MiddleManagers. When Brokers receive results from those subqueries, they merge those results and return them to the caller. End users typically query Brokers rather than querying Historicals or MiddleManagers directly. Coordinator processes watch over the Historical processes. They are responsible for assigning segments to specific servers, and for ensuring segments are well-balanced wideness Historicals. Overlord processes watch over the MiddleManager processes and are the controllers of data ingestion into Druid. They are responsible for assigning ingestion tasks to MiddleManagers and for coordinating segment publishing. Router processes are optional processes that provide a unified API gateway in front of Druid Brokers, Overlords, and Coordinators. They are optional since you can moreover simply contact the Druid Brokers, Overlords, and Coordinators directly. Druid processes can be deployed individually (one per physical server, virtual server, or container) or can be colocated on shared servers. One worldwide colocation plan is a three-type plan: "Data" servers run Historical and MiddleManager processes. "Query" servers run Broker and (optionally) Router processes. "Master" servers run Coordinator and Overlord processes. They may run ZooKeeper as well. In wing to these process types, Druid moreover has three external dependencies. These are intended to be worldly-wise to leverage existing infrastructure, where present. Deep storage, shared file storage wieldy by every Druid server. This is typically going to be a distributed object store like S3 or HDFS, or a network mounted filesystem. Druid uses this to store any data that has been ingested into the system. Metadata store, shared metadata storage. This is typically going to be a traditional RDBMS like PostgreSQL or MySQL. ZooKeeper is used for internal service discovery, coordination, and leader election. The idea overdue this tracery is to make a Druid cluster simple to operate in production at scale. For example, the separation of deep storage and the metadata store from the rest of the cluster ways that Druid processes are radically fault tolerant: plane if every single Druid server fails, you can still relaunch your cluster from data stored in deep storage and the metadata store. The pursuit diagram shows how queries and data spritz through this architecture: Datasources and segments Druid data is stored in "datasources", which are similar to tables in a traditional RDBMS. Each datasource is partitioned by time and, optionally, remoter partitioned by other attributes. Each time range is tabbed a "chunk" (for example, a single day, if your datasource is partitioned by day). Within a chunk, data is partitioned into one or increasingly "segments". Each segment is a single file, typically comprising up to a few million rows of data. Since segments are organized into time chunks, it's sometimes helpful to think of segments as living on a timeline like the following: A datasource may have anywhere from just a few segments, up to hundreds of thousands and plane millions of segments. Each segment starts life off stuff created on a MiddleManager, and at that point, is mutable and uncommitted. The segment towers process includes the pursuit steps, designed to produce a data file that is meaty and supports fast queries: Conversion to columnar format Indexing with bitmap indexesPinchusing various algorithms Dictionary encoding with id storage minimization for String columns Bitmap pinch for bitmap indexes Type-aware pinch for all columns Periodically, segments are single-minded and published. At this point, they are written to deep storage, wilt immutable, and move from MiddleManagers to the Historical processes (seeTraceryabove for details). An entry well-nigh the segment is moreover written to the metadata store. This entry is a self-describing bit of metadata well-nigh the segment, including things like the schema of the segment, its size, and its location on deep storage. These entries are what the Coordinator uses to know what data should be misogynist on the cluster. Query processing Queries first enter the Broker, where the Broker will identify which segments have data that may pertain to that query. The list of segments is unchangingly pruned by time, and may moreover be pruned by other nature depending on how your datasource is partitioned. The Broker will then identify which Historicals and MiddleManagers are serving those segments and send a rewritten subquery to each of those processes. The Historical/MiddleManager processes will take in the queries, process them and return results. The Broker receives results and merges them together to get the final answer, which it returns to the original caller. Broker pruning is an important way that Druid limits the value of data that must be scanned for each query, but it is not the only way. For filters at a increasingly granular level than what the Broker can use for pruning, indexing structures inside each segment indulge Druid to icon out which (if any) rows match the filter set surpassing looking at any row of data. Once Druid knows which rows match a particular query, it only accesses the specific columns it needs for that query. Within those columns, Druid can skip from row to row, lamister reading data that doesn't match the query filter. So Druid uses three variegated techniques to maximize query performance: Pruning which segments are accessed for each query. Within each segment, using indexes to identify which rows must be accessed. Within each segment, only reading the specific rows and columns that are relevant to a particular query. External Dependencies Deep storage Druid uses deep storage only as a replacement of your data and as a way to transfer data in the preliminaries between Druid processes. To respond to queries, Historical processes do not read from deep storage, but instead read pre-fetched segments from their local disks surpassing any queries are served. This ways that Druid never needs to wangle deep storage during a query, helping it offer the weightier query latencies possible. It moreover ways that you must have unbearable disk space both in deep storage and wideness your Historical processes for the data you plan to load. For increasingly details, please see Deep storage dependency. Metadata storage The metadata storage holds various system metadata such as segment availability information and task information. For increasingly details, please see Metadata storage dependency Zookeeper Druid uses ZooKeeper (ZK) for management of current cluster state. For increasingly details, please see Zookeeper dependency. Community ·  Download ·  Powered by Druid ·  FAQ ·  License  ·   ·  Except where otherwise noted, licensed under CC BY-SA 4.0