Tuning — OpenTSDB 2.4 documentation
As with any database there are many tuning parameters for OpenTSDB that can be used to improve write and read performance. Some of these options are specific to certain backends, others are global.
翻译:
与任何数据库一样，OpenTSDB有许多调优参数可用于提高写和读性能。其中一些选项是特定于某些后端的，另一些则是全局的。
As with any server process, tuning the TSD’s memory footprint is important for a successful install. There are a number of caches in OpenTSDB that can be tuned.
翻译:
与任何服务器进程一样，调整TSD的内存占用对于成功安装非常重要。OpenTSDB中有许多缓存可以进行调优
OpenTSDB saves space in storage by converting strings to binary UIDs. However for writing and querying, these UIDs have to be cached to improve performance (otherwise every operation would amplify queries against storage). In early versions of OpenTSDB, the cache would maintain an unbounded map of strings to UIDs and UIDs to strings regardless of modes of operation. In 2.4 you can choose how much data to cache and optionally use an LRU. The pertinent settings include:
‘tsd.uid.use_mode=true’ - When this is set to true, the?tsd.mode?value is examined to determine if either or both of the forward (string to UID) and reverse (UID to string) maps are populated. When empty or set to?rw, both maps are populated. When set to?ro, only the reverse map is populated (as query results need caching). When in?w?or write-only mode, only the forward map is populated as metrics need to find their UIDs when writing.
tsd.uid.lru.enable=true?- Switch to the LRU version of the cache that will expire entries that haven’t been read in a while.
tsd.uid.lru.id.size=<integer>?- For TSDs focused on reads, set this size larger than?tsd.uid.lru.name.size.
tsd.uid.lru.name.size=<integer>?- For TSDs focused on writes, set this size larger than the?tsd.uid.lru.id.size.
翻译:
OpenTSDB通过将字符串转换为二进制UID来节省存储空间。然而，对于写入和查询，必须缓存这些UID以提高性能（否则，每个操作都会放大对存储的查询）。在早期版本的OpenTSDB中，无论操作模式如何，缓存都会维护字符串到UID和UID到字符串的无边界映射。在2.4中，您可以选择缓存多少数据，也可以选择使用LRU。相关设置包括：
“tsd.uid.use_mode=true”-如果设置为true，将检查tsd.mode值，以确定是否填充正向（字符串到uid）和反向（uid到字符串）映射中的一个或两个。当为空或设置为rw时，将填充两个映射。当设置为ro时，只填充反向映射（因为查询结果需要缓存）。当处于w或仅写模式时，由于写入时度量需要找到其UID，因此仅填充前向映射。
tsd.uid.lru.enable=true-切换到缓存的lru版本，该版本将使一段时间内未读取的条目过期。
tsd.uid.lru.id.size=＜integer＞-对于专注于读取的tsd，请将此大小设置为大于tsd.uid.lou.name.size。
tsd.uid.lru.name.size=＜integer＞-对于专注于写入的tsd，请将此大小设置为大于tsd.uid.loi.id.size。
These are parameters to look at for using OpenTSDB with Apache HBase.
HBase is an LSM store meaning data is written to blocks in memory, then flushed in blocks to disk, then periodically those blocks on disk are merged into fewer blocks to reduce file count and redundancies. The process of reading and merging blocks from disk can consume a fair amount of CPU and memory so if a system is heavily loaded with time series write traffic, background compactions can begin to impact write performance. HBase offers various compaction strategies including Date Tiered Compaction that looks at the the edit timestamps of columns to figure out if stale file that haven’t been modified should be ignored and arranges data so that time ranged queries are much more efficient.
OpenTSDB can leverage this compaction strategy (as of 2.4) to improve HBase performance, particularly for queries. To setup Date Tiered Compaction in HBase, see?HBase Book. Parameters that must be set in the OpenTSDB config include:
tsd.storage.use_otsdb_timestamp=true?- By default the edit timestamps of every data point is?now. This changes the timestamp to be that of the actual data point. Note that rollups do not use this strategy yet.
tsd.storage.get_date_tiered_compaction_start=<Unix Epoch MS timestamp>?- A timestamp in milliseconds when the date tiered compactor was enabled on a table. If you are creating a brand new table for OpenTSDB you can leave this at the default of?0.
HBase是一种LSM存储，意味着数据被写入内存中的块，然后在块中刷新到磁盘，然后定期将磁盘上的这些块合并为更少的块，以减少文件数量和冗余。从磁盘读取和合并块的过程可能会消耗相当多的CPU和内存，因此，如果系统负载了大量时间序列写入流量，则后台压缩可能会开始影响写入性能。HBase提供了各种压缩策略，包括日期分层压缩，它查看列的编辑时间戳，以确定是否应该忽略尚未修改的陈旧文件，并排列数据，从而使时间范围的查询更加高效。
OpenTSDB可以利用这种压缩策略（从2.4开始）来提高HBase的性能，特别是对于查询。要在HBase中设置日期分层压缩，请参阅HBase Book。必须在OpenTSDB配置中设置的参数包括：
HBase has the ability to split the queues that handle RPCs for writes (mutations) and reads. This is a huge help for OpenTSDB as massive queries will avoid impacting writes and vice-versa. See the?HBase Book?for various configuration options. Note that different HBase versions have different names for these properties.
Possible starting values are 50% or 60%. E.g.?hbase.ipc.server.callqueue.read.share=0.60?or?hbase.ipc.server.callqueue.read.ratio=0.60?depending on HBase version.
Also, tuning the call queue size and threads is important. With a large queue, the region server can possibly OOM (if there are a large number of writes backing up) and RPCs will be more likely to time out on the client side if they sit in the queue too long. The queue size is a factor of the number of handlers. Reducing the call queue size also helps to cause clients to throttle, particularly the AsyncHBase client. For HBase 1.3 a good setting may be?hbase.ipc.server.max.callqueue.length=100?and?hbase.ipc.server.read.threadpool.size=2. If you need to increase the threads, reduce the queue length as well.
翻译:
HBase能够拆分处理写（突变）和读的RPC的队列。这对OpenTSDB来说是一个巨大的帮助，因为大量查询将避免影响写入，反之亦然。有关各种配置选项，请参阅HBase Book。请注意，不同的HBase版本对这些属性有不同的名称。
可能的起始值为50%或60%。例如，hbase.ipc.server.callqueue.read.share=0.60或hbase.iipc.server.callequeue.read.tratio=0.60，具体取决于hbase版本。
此外，调整调用队列大小和线程也很重要。对于大队列，区域服务器可能会OOM（如果有大量写入备份），如果RPC在队列中停留的时间过长，则更有可能在客户端超时。队列大小是处理程序数量的一个因素。减少调用队列大小也有助于导致客户端节流，尤其是AsyncHBase客户端。对于HBase 1.3，一个好的设置可能是HBase.ipc.server.max.callqueue.length=100和HBase.iipc.server.read.threadpool.size=2。如果需要增加线程，也可以减少队列长度。
Tuning the HBase cache is also important for queries as you want to avoid reading data off disk as much as possible (particularly if that disk is S3). Try using the offheap cache via?hbase.bucketcache.combinedcache.enabled=true?and?hbase.bucketcache.ioengine=offheap. Give the offheap cache a good amount of RAM, e.g.?hbase.bucketcache.size=4000?for 4GB of RAM. Since the most recent data is usually queried when reading time series, it’s a good idea to populate the block cache on writes and use most of that space for the latest data. Try the following settings:
hbase.rs.cacheblocksonwrite=true hbase.rs.evictblocksonclose=false hfile.block.bloom.cacheonwrite=true hfile.block.index.cacheonwrite=true hbase.block.data.cachecompressed=true hbase.bucketcache.blockcache.single.percentage=.99 hbase.bucketcache.blockcache.multi.percentage=0 hbase.bucketcache.blockcache.memory.percentage=.01 hfile.block.cache.size=.054 #ignored but needs a value.
This will allocate the majority of the black cache for writes and cache it in memory.
For the on-heap cache, you can try an allocation of:
hbase.lru.blockcache.single.percentage=.50 hbase.lru.blockcache.multi.percentage=.49 hbase.lru.blockcache.memory.percentage=.01
翻译:
调整HBase缓存对于查询也很重要，因为您希望尽可能避免从磁盘上读取数据（尤其是当磁盘是S3时）。尝试通过hbase.backetcache.cocombinedcache.enabled=true和hbase.blocketcache.ioengine=offheap使用堆外缓存。为堆外缓存提供充足的RAM，例如，对于4GB的RAM，hbase.bocketcache.size=4000。由于读取时间序列时通常会查询最新的数据，因此最好在写入时填充块缓存，并将大部分空间用于最新数据。请尝试以下设置：
Compaction is the process of merging multiple stores on disk for a region into fewer files to reduce space and query times. You can tune the number of threads and thresholds for compaction to avoid using too many resources when the focus should be on writes.
hbase.hstore.compaction.ratio=1.2 hbase.regionserver.thread.compaction.large=2 hbase.regionserver.thread.compaction.small=6 hbase.regionserver.thread.compaction.throttle=524288000
压缩是将一个区域的磁盘上的多个存储合并为更少的文件以减少空间和查询时间的过程。您可以调整线程数量和压缩阈值，以避免在应该将重点放在写入上时使用过多资源。
For OpenTSDB we’ve observed that 10G regions are a good size for a large cluster?hbase.hregion.max.filesize=10737418240.
翻译:
对于OpenTSDB，我们已经观察到10G区域对于大型集群hbase.hregion.max.filesize=1037418240来说是一个不错的大小。
Try flushing the mem store to disk (and cache) more often, particularly for heavy write loads. We’ve seen good behavior with 16MBs?hbase.hregion.memstore.flush.size=16777216. Also try reducing the memstore size limit via?hbase.regionserver.global.memstore.lowerLimit=.20?and?hbase.regionserver.global.memstore.upperLimit=.30.
翻译:?
请尝试更频繁地将内存存储刷新到磁盘（和缓存），尤其是在写负载很大的情况下。我们已经看到了16MB hbase.hregion.memstore.flash.size=16777216的良好性能。也可以尝试通过hbase.regiserver.global.membestore.lowerLimit=.20和hbase.reregionserver.global-memstore.upperLimit=.30来减少内存存储大小限制。