· 10 years ago · Sep 27, 2016, 03:04 AM
1# Scylla storage config YAML
2
3#######################################
4# This file is split to two sections:
5# 1. Supported parameters
6# 2. Unsupported parameters: reserved for future use or backwards
7# compatibility.
8# Scylla will only read and use the first segment
9#######################################
10
11### Supported Parameters
12
13# The name of the cluster. This is mainly used to prevent machines in
14# one logical cluster from joining another.
15cluster_name: 'Test Cluster'
16
17# This defines the number of tokens randomly assigned to this node on the ring
18# The more tokens, relative to other nodes, the larger the proportion of data
19# that this node will store. You probably want all nodes to have the same number
20# of tokens assuming they have equal hardware capability.
21#
22# If you already have a cluster with 1 token per node, and wish to migrate to
23# multiple tokens per node, see http://wiki.apache.org/cassandra/Operations
24num_tokens: 256
25
26# Directory where Scylla should store data on disk.
27# If not set, the default directory is $CASSANDRA_HOME/data/data.
28data_file_directories:
29 - /var/lib/scylla/data
30
31# commit log. when running on magnetic HDD, this should be a
32# separate spindle than the data directories.
33# If not set, the default directory is $CASSANDRA_HOME/data/commitlog.
34commitlog_directory: /var/lib/scylla/commitlog
35
36# commitlog_sync may be either "periodic" or "batch."
37#
38# When in batch mode, Scylla won't ack writes until the commit log
39# has been fsynced to disk. It will wait
40# commitlog_sync_batch_window_in_ms milliseconds between fsyncs.
41# This window should be kept short because the writer threads will
42# be unable to do extra work while waiting. (You may need to increase
43# concurrent_writes for the same reason.)
44#
45# commitlog_sync: batch
46# commitlog_sync_batch_window_in_ms: 2
47#
48# the other option is "periodic" where writes may be acked immediately
49# and the CommitLog is simply synced every commitlog_sync_period_in_ms
50# milliseconds.
51commitlog_sync: periodic
52commitlog_sync_period_in_ms: 10000
53
54# The size of the individual commitlog file segments. A commitlog
55# segment may be archived, deleted, or recycled once all the data
56# in it (potentially from each columnfamily in the system) has been
57# flushed to sstables.
58#
59# The default size is 32, which is almost always fine, but if you are
60# archiving commitlog segments (see commitlog_archiving.properties),
61# then you probably want a finer granularity of archiving; 8 or 16 MB
62# is reasonable.
63commitlog_segment_size_in_mb: 32
64
65# seed_provider class_name is saved for future use.
66# seeds address are mandatory!
67seed_provider:
68 # Addresses of hosts that are deemed contact points.
69 # Scylla nodes use this list of hosts to find each other and learn
70 # the topology of the ring. You must change this if you are running
71 # multiple nodes!
72 - class_name: org.apache.cassandra.locator.SimpleSeedProvider
73 parameters:
74 # seeds is actually a comma-delimited list of addresses.
75 # Ex: "<ip1>,<ip2>,<ip3>"
76 - seeds: "192.168.0.19, 192.168.0.20"
77
78# Address or interface to bind to and tell other Scylla nodes to connect to.
79# You _must_ change this if you want multiple nodes to be able to communicate!
80#
81# Setting listen_address to 0.0.0.0 is always wrong.
82listen_address: 192.168.0.20
83
84# Address to broadcast to other Scylla nodes
85# Leaving this blank will set it to the same value as listen_address
86# broadcast_address: 1.2.3.4
87
88# port for the CQL native transport to listen for clients on
89# For security reasons, you should not expose this port to the internet. Firewall it if needed.
90native_transport_port: 9042
91
92# Throttles all outbound streaming file transfers on this node to the
93# given total throughput in Mbps. This is necessary because Scylla does
94# mostly sequential IO when streaming data during bootstrap or repair, which
95# can lead to saturating the network connection and degrading rpc performance.
96# When unset, the default is 200 Mbps or 25 MB/s.
97# stream_throughput_outbound_megabits_per_sec: 200
98
99# How long the coordinator should wait for read operations to complete
100read_request_timeout_in_ms: 5000
101
102# How long the coordinator should wait for writes to complete
103write_request_timeout_in_ms: 2000
104
105# phi value that must be reached for a host to be marked down.
106# most users should never need to adjust this.
107# phi_convict_threshold: 8
108
109# IEndpointSnitch. The snitch has two functions:
110# - it teaches Scylla enough about your network topology to route
111# requests efficiently
112# - it allows Scylla to spread replicas around your cluster to avoid
113# correlated failures. It does this by grouping machines into
114# "datacenters" and "racks." Scylla will do its best not to have
115# more than one replica on the same "rack" (which may not actually
116# be a physical location)
117#
118# IF YOU CHANGE THE SNITCH AFTER DATA IS INSERTED INTO THE CLUSTER,
119# YOU MUST RUN A FULL REPAIR, SINCE THE SNITCH AFFECTS WHERE REPLICAS
120# ARE PLACED.
121#
122# Out of the box, Scylla provides
123# - SimpleSnitch:
124# Treats Strategy order as proximity. This can improve cache
125# locality when disabling read repair. Only appropriate for
126# single-datacenter deployments.
127# - GossipingPropertyFileSnitch
128# This should be your go-to snitch for production use. The rack
129# and datacenter for the local node are defined in
130# cassandra-rackdc.properties and propagated to other nodes via
131# gossip. If cassandra-topology.properties exists, it is used as a
132# fallback, allowing migration from the PropertyFileSnitch.
133# - PropertyFileSnitch:
134# Proximity is determined by rack and data center, which are
135# explicitly configured in cassandra-topology.properties.
136# - Ec2Snitch:
137# Appropriate for EC2 deployments in a single Region. Loads Region
138# and Availability Zone information from the EC2 API. The Region is
139# treated as the datacenter, and the Availability Zone as the rack.
140# Only private IPs are used, so this will not work across multiple
141# Regions.
142# - Ec2MultiRegionSnitch:
143# Uses public IPs as broadcast_address to allow cross-region
144# connectivity. (Thus, you should set seed addresses to the public
145# IP as well.) You will need to open the storage_port or
146# ssl_storage_port on the public IP firewall. (For intra-Region
147# traffic, Scylla will switch to the private IP after
148# establishing a connection.)
149# - RackInferringSnitch:
150# Proximity is determined by rack and data center, which are
151# assumed to correspond to the 3rd and 2nd octet of each node's IP
152# address, respectively. Unless this happens to match your
153# deployment conventions, this is best used as an example of
154# writing a custom Snitch class and is provided in that spirit.
155#
156# You can use a custom Snitch by setting this to the full class name
157# of the snitch, which will be assumed to be on your classpath.
158endpoint_snitch: SimpleSnitch
159
160# The address or interface to bind the Thrift RPC service and native transport
161# server to.
162#
163# Set rpc_address OR rpc_interface, not both. Interfaces must correspond
164# to a single address, IP aliasing is not supported.
165#
166# Leaving rpc_address blank has the same effect as on listen_address
167# (i.e. it will be based on the configured hostname of the node).
168#
169# Note that unlike listen_address, you can specify 0.0.0.0, but you must also
170# set broadcast_rpc_address to a value other than 0.0.0.0.
171#
172# For security reasons, you should not expose this port to the internet. Firewall it if needed.
173#
174# If you choose to specify the interface by name and the interface has an ipv4 and an ipv6 address
175# you can specify which should be chosen using rpc_interface_prefer_ipv6. If false the first ipv4
176# address will be used. If true the first ipv6 address will be used. Defaults to false preferring
177# ipv4. If there is only one address it will be selected regardless of ipv4/ipv6.
178rpc_address: 192.168.0.19
179# rpc_interface: eth1
180# rpc_interface_prefer_ipv6: false
181
182# port for Thrift to listen for clients on
183rpc_port: 9160
184
185# port for REST API server
186api_port: 10000
187
188# IP for the REST API server
189api_address: 127.0.0.1
190
191# Log WARN on any batch size exceeding this value. 5kb per batch by default.
192# Caution should be taken on increasing the size of this threshold as it can lead to node instability.
193batch_size_warn_threshold_in_kb: 5
194
195# Authentication backend, identifying users
196# Out of the box, Scylla provides org.apache.cassandra.auth.{AllowAllAuthenticator,
197# PasswordAuthenticator}.
198#
199# - AllowAllAuthenticator performs no checks - set it to disable authentication.
200# - PasswordAuthenticator relies on username/password pairs to authenticate
201# users. It keeps usernames and hashed passwords in system_auth.credentials table.
202# Please increase system_auth keyspace replication factor if you use this authenticator.
203# authenticator: AllowAllAuthenticator
204
205# Authorization backend, implementing IAuthorizer; used to limit access/provide permissions
206# Out of the box, Scylla provides org.apache.cassandra.auth.{AllowAllAuthorizer,
207# CassandraAuthorizer}.
208#
209# - AllowAllAuthorizer allows any action to any user - set it to disable authorization.
210# - CassandraAuthorizer stores permissions in system_auth.permissions table. Please
211# increase system_auth keyspace replication factor if you use this authorizer.
212# authorizer: AllowAllAuthorizer
213
214# initial_token allows you to specify tokens manually. While you can use # it with
215# vnodes (num_tokens > 1, above) -- in which case you should provide a
216# comma-separated list -- it's primarily used when adding nodes # to legacy clusters
217# that do not have vnodes enabled.
218# initial_token:
219
220###################################################
221## Not currently supported, reserved for future use
222###################################################
223
224# See http://wiki.apache.org/cassandra/HintedHandoff
225# May either be "true" or "false" to enable globally, or contain a list
226# of data centers to enable per-datacenter.
227# hinted_handoff_enabled: DC1,DC2
228# hinted_handoff_enabled: true
229
230# this defines the maximum amount of time a dead host will have hints
231# generated. After it has been dead this long, new hints for it will not be
232# created until it has been seen alive and gone down again.
233# max_hint_window_in_ms: 10800000 # 3 hours
234
235# Maximum throttle in KBs per second, per delivery thread. This will be
236# reduced proportionally to the number of nodes in the cluster. (If there
237# are two nodes in the cluster, each delivery thread will use the maximum
238# rate; if there are three, each will throttle to half of the maximum,
239# since we expect two nodes to be delivering hints simultaneously.)
240# hinted_handoff_throttle_in_kb: 1024
241# Number of threads with which to deliver hints;
242# Consider increasing this number when you have multi-dc deployments, since
243# cross-dc handoff tends to be slower
244# max_hints_delivery_threads: 2
245
246# Maximum throttle in KBs per second, total. This will be
247# reduced proportionally to the number of nodes in the cluster.
248# batchlog_replay_throttle_in_kb: 1024
249
250# Validity period for permissions cache (fetching permissions can be an
251# expensive operation depending on the authorizer, CassandraAuthorizer is
252# one example). Defaults to 2000, set to 0 to disable.
253# Will be disabled automatically for AllowAllAuthorizer.
254# permissions_validity_in_ms: 2000
255
256# Refresh interval for permissions cache (if enabled).
257# After this interval, cache entries become eligible for refresh. Upon next
258# access, an async reload is scheduled and the old value returned until it
259# completes. If permissions_validity_in_ms is non-zero, then this must be
260# also.
261# Defaults to the same value as permissions_validity_in_ms.
262# permissions_update_interval_in_ms: 1000
263
264# The partitioner is responsible for distributing groups of rows (by
265# partition key) across nodes in the cluster. You should leave this
266# alone for new clusters. The partitioner can NOT be changed without
267# reloading all data, so when upgrading you should set this to the
268# same partitioner you were already using.
269#
270# Besides Murmur3Partitioner, partitioners included for backwards
271# compatibility include RandomPartitioner, ByteOrderedPartitioner, and
272# OrderPreservingPartitioner.
273#
274partitioner: org.apache.cassandra.dht.Murmur3Partitioner
275
276
277# policy for data disk failures:
278# die: shut down gossip and Thrift and kill the JVM for any fs errors or
279# single-sstable errors, so the node can be replaced.
280# stop_paranoid: shut down gossip and Thrift even for single-sstable errors.
281# stop: shut down gossip and Thrift, leaving the node effectively dead, but
282# can still be inspected via JMX.
283# best_effort: stop using the failed disk and respond to requests based on
284# remaining available sstables. This means you WILL see obsolete
285# data at CL.ONE!
286# ignore: ignore fatal errors and let requests fail, as in pre-1.2 Scylla
287# disk_failure_policy: stop
288
289# policy for commit disk failures:
290# die: shut down gossip and Thrift and kill the JVM, so the node can be replaced.
291# stop: shut down gossip and Thrift, leaving the node effectively dead, but
292# can still be inspected via JMX.
293# stop_commit: shutdown the commit log, letting writes collect but
294# continuing to service reads, as in pre-2.0.5 Scylla
295# ignore: ignore fatal errors and let the batches fail
296# commit_failure_policy: stop
297
298# Maximum size of the key cache in memory.
299#
300# Each key cache hit saves 1 seek and each row cache hit saves 2 seeks at the
301# minimum, sometimes more. The key cache is fairly tiny for the amount of
302# time it saves, so it's worthwhile to use it at large numbers.
303# The row cache saves even more time, but must contain the entire row,
304# so it is extremely space-intensive. It's best to only use the
305# row cache if you have hot rows or static rows.
306#
307# NOTE: if you reduce the size, you may not get you hottest keys loaded on startup.
308#
309# Default value is empty to make it "auto" (min(5% of Heap (in MB), 100MB)). Set to 0 to disable key cache.
310# key_cache_size_in_mb:
311
312# Duration in seconds after which Scylla should
313# save the key cache. Caches are saved to saved_caches_directory as
314# specified in this configuration file.
315#
316# Saved caches greatly improve cold-start speeds, and is relatively cheap in
317# terms of I/O for the key cache. Row cache saving is much more expensive and
318# has limited use.
319#
320# Default is 14400 or 4 hours.
321# key_cache_save_period: 14400
322
323# Number of keys from the key cache to save
324# Disabled by default, meaning all keys are going to be saved
325# key_cache_keys_to_save: 100
326
327# Maximum size of the row cache in memory.
328# NOTE: if you reduce the size, you may not get you hottest keys loaded on startup.
329#
330# Default value is 0, to disable row caching.
331# row_cache_size_in_mb: 0
332
333# Duration in seconds after which Scylla should
334# save the row cache. Caches are saved to saved_caches_directory as specified
335# in this configuration file.
336#
337# Saved caches greatly improve cold-start speeds, and is relatively cheap in
338# terms of I/O for the key cache. Row cache saving is much more expensive and
339# has limited use.
340#
341# Default is 0 to disable saving the row cache.
342# row_cache_save_period: 0
343
344# Number of keys from the row cache to save
345# Disabled by default, meaning all keys are going to be saved
346# row_cache_keys_to_save: 100
347
348# Maximum size of the counter cache in memory.
349#
350# Counter cache helps to reduce counter locks' contention for hot counter cells.
351# In case of RF = 1 a counter cache hit will cause Scylla to skip the read before
352# write entirely. With RF > 1 a counter cache hit will still help to reduce the duration
353# of the lock hold, helping with hot counter cell updates, but will not allow skipping
354# the read entirely. Only the local (clock, count) tuple of a counter cell is kept
355# in memory, not the whole counter, so it's relatively cheap.
356#
357# NOTE: if you reduce the size, you may not get you hottest keys loaded on startup.
358#
359# Default value is empty to make it "auto" (min(2.5% of Heap (in MB), 50MB)). Set to 0 to disable counter cache.
360# NOTE: if you perform counter deletes and rely on low gcgs, you should disable the counter cache.
361# counter_cache_size_in_mb:
362
363# Duration in seconds after which Scylla should
364# save the counter cache (keys only). Caches are saved to saved_caches_directory as
365# specified in this configuration file.
366#
367# Default is 7200 or 2 hours.
368# counter_cache_save_period: 7200
369
370# Number of keys from the counter cache to save
371# Disabled by default, meaning all keys are going to be saved
372# counter_cache_keys_to_save: 100
373
374# The off-heap memory allocator. Affects storage engine metadata as
375# well as caches. Experiments show that JEMAlloc saves some memory
376# than the native GCC allocator (i.e., JEMalloc is more
377# fragmentation-resistant).
378#
379# Supported values are: NativeAllocator, JEMallocAllocator
380#
381# If you intend to use JEMallocAllocator you have to install JEMalloc as library and
382# modify cassandra-env.sh as directed in the file.
383#
384# Defaults to NativeAllocator
385# memory_allocator: NativeAllocator
386
387# saved caches
388# If not set, the default directory is $CASSANDRA_HOME/data/saved_caches.
389# saved_caches_directory: /var/lib/scylla/saved_caches
390
391
392
393# For workloads with more data than can fit in memory, Scylla's
394# bottleneck will be reads that need to fetch data from
395# disk. "concurrent_reads" should be set to (16 * number_of_drives) in
396# order to allow the operations to enqueue low enough in the stack
397# that the OS and drives can reorder them. Same applies to
398# "concurrent_counter_writes", since counter writes read the current
399# values before incrementing and writing them back.
400#
401# On the other hand, since writes are almost never IO bound, the ideal
402# number of "concurrent_writes" is dependent on the number of cores in
403# your system; (8 * number_of_cores) is a good rule of thumb.
404# concurrent_reads: 32
405# concurrent_writes: 32
406# concurrent_counter_writes: 32
407
408# Total memory to use for sstable-reading buffers. Defaults to
409# the smaller of 1/4 of heap or 512MB.
410# file_cache_size_in_mb: 512
411
412# Total permitted memory to use for memtables. Scylla will stop
413# accepting writes when the limit is exceeded until a flush completes,
414# and will trigger a flush based on memtable_cleanup_threshold
415# If omitted, Scylla will set both to 1/4 the size of the heap.
416# memtable_heap_space_in_mb: 2048
417# memtable_offheap_space_in_mb: 2048
418
419# Ratio of occupied non-flushing memtable size to total permitted size
420# that will trigger a flush of the largest memtable. Lager mct will
421# mean larger flushes and hence less compaction, but also less concurrent
422# flush activity which can make it difficult to keep your disks fed
423# under heavy write load.
424#
425# memtable_cleanup_threshold defaults to 1 / (memtable_flush_writers + 1)
426# memtable_cleanup_threshold: 0.11
427
428# Specify the way Scylla allocates and manages memtable memory.
429# Options are:
430# heap_buffers: on heap nio buffers
431# offheap_buffers: off heap (direct) nio buffers
432# offheap_objects: native memory, eliminating nio buffer heap overhead
433# memtable_allocation_type: heap_buffers
434
435# Total space to use for commitlogs.
436#
437# If space gets above this value (it will round up to the next nearest
438# segment multiple), Scylla will flush every dirty CF in the oldest
439# segment and remove it. So a small total commitlog space will tend
440# to cause more flush activity on less-active columnfamilies.
441#
442# A value of -1 (default) will automatically equate it to the total amount of memory
443# available for Scylla.
444commitlog_total_space_in_mb: -1
445
446# This sets the amount of memtable flush writer threads. These will
447# be blocked by disk io, and each one will hold a memtable in memory
448# while blocked.
449#
450# memtable_flush_writers defaults to the smaller of (number of disks,
451# number of cores), with a minimum of 2 and a maximum of 8.
452#
453# If your data directories are backed by SSD, you should increase this
454# to the number of cores.
455#memtable_flush_writers: 8
456
457# A fixed memory pool size in MB for for SSTable index summaries. If left
458# empty, this will default to 5% of the heap size. If the memory usage of
459# all index summaries exceeds this limit, SSTables with low read rates will
460# shrink their index summaries in order to meet this limit. However, this
461# is a best-effort process. In extreme conditions Scylla may need to use
462# more than this amount of memory.
463# index_summary_capacity_in_mb:
464
465# How frequently index summaries should be resampled. This is done
466# periodically to redistribute memory from the fixed-size pool to sstables
467# proportional their recent read rates. Setting to -1 will disable this
468# process, leaving existing index summaries at their current sampling level.
469# index_summary_resize_interval_in_minutes: 60
470
471# Whether to, when doing sequential writing, fsync() at intervals in
472# order to force the operating system to flush the dirty
473# buffers. Enable this to avoid sudden dirty buffer flushing from
474# impacting read latencies. Almost always a good idea on SSDs; not
475# necessarily on platters.
476# trickle_fsync: false
477# trickle_fsync_interval_in_kb: 10240
478
479# TCP port, for commands and data
480# For security reasons, you should not expose this port to the internet. Firewall it if needed.
481# storage_port: 7000
482
483# SSL port, for encrypted communication. Unused unless enabled in
484# encryption_options
485# For security reasons, you should not expose this port to the internet. Firewall it if needed.
486# ssl_storage_port: 7001
487
488# listen_interface: eth0
489# listen_interface_prefer_ipv6: false
490
491# Internode authentication backend, implementing IInternodeAuthenticator;
492# used to allow/disallow connections from peer nodes.
493# internode_authenticator: org.apache.cassandra.auth.AllowAllInternodeAuthenticator
494
495# Whether to start the native transport server.
496# Please note that the address on which the native transport is bound is the
497# same as the rpc_address. The port however is different and specified below.
498# start_native_transport: true
499
500# The maximum threads for handling requests when the native transport is used.
501# This is similar to rpc_max_threads though the default differs slightly (and
502# there is no native_transport_min_threads, idle threads will always be stopped
503# after 30 seconds).
504# native_transport_max_threads: 128
505#
506# The maximum size of allowed frame. Frame (requests) larger than this will
507# be rejected as invalid. The default is 256MB.
508# native_transport_max_frame_size_in_mb: 256
509
510# The maximum number of concurrent client connections.
511# The default is -1, which means unlimited.
512# native_transport_max_concurrent_connections: -1
513
514# The maximum number of concurrent client connections per source ip.
515# The default is -1, which means unlimited.
516# native_transport_max_concurrent_connections_per_ip: -1
517
518# Whether to start the thrift rpc server.
519# start_rpc: true
520
521
522# RPC address to broadcast to drivers and other Scylla nodes. This cannot
523# be set to 0.0.0.0. If left blank, this will be set to the value of
524# rpc_address. If rpc_address is set to 0.0.0.0, broadcast_rpc_address must
525# be set.
526# broadcast_rpc_address: 1.2.3.4
527
528# enable or disable keepalive on rpc/native connections
529# rpc_keepalive: true
530
531# Scylla provides two out-of-the-box options for the RPC Server:
532#
533# sync -> One thread per thrift connection. For a very large number of clients, memory
534# will be your limiting factor. On a 64 bit JVM, 180KB is the minimum stack size
535# per thread, and that will correspond to your use of virtual memory (but physical memory
536# may be limited depending on use of stack space).
537#
538# hsha -> Stands for "half synchronous, half asynchronous." All thrift clients are handled
539# asynchronously using a small number of threads that does not vary with the amount
540# of thrift clients (and thus scales well to many clients). The rpc requests are still
541# synchronous (one thread per active request). If hsha is selected then it is essential
542# that rpc_max_threads is changed from the default value of unlimited.
543#
544# The default is sync because on Windows hsha is about 30% slower. On Linux,
545# sync/hsha performance is about the same, with hsha of course using less memory.
546#
547# Alternatively, can provide your own RPC server by providing the fully-qualified class name
548# of an o.a.c.t.TServerFactory that can create an instance of it.
549# rpc_server_type: sync
550
551# Uncomment rpc_min|max_thread to set request pool size limits.
552#
553# Regardless of your choice of RPC server (see above), the number of maximum requests in the
554# RPC thread pool dictates how many concurrent requests are possible (but if you are using the sync
555# RPC server, it also dictates the number of clients that can be connected at all).
556#
557# The default is unlimited and thus provides no protection against clients overwhelming the server. You are
558# encouraged to set a maximum that makes sense for you in production, but do keep in mind that
559# rpc_max_threads represents the maximum number of client requests this server may execute concurrently.
560#
561# rpc_min_threads: 16
562# rpc_max_threads: 2048
563
564# uncomment to set socket buffer sizes on rpc connections
565# rpc_send_buff_size_in_bytes:
566# rpc_recv_buff_size_in_bytes:
567
568# Uncomment to set socket buffer size for internode communication
569# Note that when setting this, the buffer size is limited by net.core.wmem_max
570# and when not setting it it is defined by net.ipv4.tcp_wmem
571# See:
572# /proc/sys/net/core/wmem_max
573# /proc/sys/net/core/rmem_max
574# /proc/sys/net/ipv4/tcp_wmem
575# /proc/sys/net/ipv4/tcp_wmem
576# and: man tcp
577# internode_send_buff_size_in_bytes:
578# internode_recv_buff_size_in_bytes:
579
580# Frame size for thrift (maximum message length).
581# thrift_framed_transport_size_in_mb: 15
582
583# Set to true to have Scylla create a hard link to each sstable
584# flushed or streamed locally in a backups/ subdirectory of the
585# keyspace data. Removing these links is the operator's
586# responsibility.
587# incremental_backups: false
588
589# Whether or not to take a snapshot before each compaction. Be
590# careful using this option, since Scylla won't clean up the
591# snapshots for you. Mostly useful if you're paranoid when there
592# is a data format change.
593# snapshot_before_compaction: false
594
595# Whether or not a snapshot is taken of the data before keyspace truncation
596# or dropping of column families. The STRONGLY advised default of true
597# should be used to provide data safety. If you set this flag to false, you will
598# lose data on truncation or drop.
599# auto_snapshot: true
600
601# When executing a scan, within or across a partition, we need to keep the
602# tombstones seen in memory so we can return them to the coordinator, which
603# will use them to make sure other replicas also know about the deleted rows.
604# With workloads that generate a lot of tombstones, this can cause performance
605# problems and even exaust the server heap.
606# (http://www.datastax.com/dev/blog/cassandra-anti-patterns-queues-and-queue-like-datasets)
607# Adjust the thresholds here if you understand the dangers and want to
608# scan more tombstones anyway. These thresholds may also be adjusted at runtime
609# using the StorageService mbean.
610# tombstone_warn_threshold: 1000
611# tombstone_failure_threshold: 100000
612
613# Granularity of the collation index of rows within a partition.
614# Increase if your rows are large, or if you have a very large
615# number of rows per partition. The competing goals are these:
616# 1) a smaller granularity means more index entries are generated
617# and looking up rows withing the partition by collation column
618# is faster
619# 2) but, Scylla will keep the collation index in memory for hot
620# rows (as part of the key cache), so a larger granularity means
621# you can cache more hot rows
622# column_index_size_in_kb: 64
623
624
625# Number of simultaneous compactions to allow, NOT including
626# validation "compactions" for anti-entropy repair. Simultaneous
627# compactions can help preserve read performance in a mixed read/write
628# workload, by mitigating the tendency of small sstables to accumulate
629# during a single long running compactions. The default is usually
630# fine and if you experience problems with compaction running too
631# slowly or too fast, you should look at
632# compaction_throughput_mb_per_sec first.
633#
634# concurrent_compactors defaults to the smaller of (number of disks,
635# number of cores), with a minimum of 2 and a maximum of 8.
636#
637# If your data directories are backed by SSD, you should increase this
638# to the number of cores.
639#concurrent_compactors: 1
640
641# Throttles compaction to the given total throughput across the entire
642# system. The faster you insert data, the faster you need to compact in
643# order to keep the sstable count down, but in general, setting this to
644# 16 to 32 times the rate you are inserting data is more than sufficient.
645# Setting this to 0 disables throttling. Note that this account for all types
646# of compaction, including validation compaction.
647# compaction_throughput_mb_per_sec: 16
648
649# Log a warning when compacting partitions larger than this value
650# compaction_large_partition_warning_threshold_mb: 100
651
652# When compacting, the replacement sstable(s) can be opened before they
653# are completely written, and used in place of the prior sstables for
654# any range that has been written. This helps to smoothly transfer reads
655# between the sstables, reducing page cache churn and keeping hot rows hot
656# sstable_preemptive_open_interval_in_mb: 50
657
658# Throttles all streaming file transfer between the datacenters,
659# this setting allows users to throttle inter dc stream throughput in addition
660# to throttling all network stream traffic as configured with
661# stream_throughput_outbound_megabits_per_sec
662# inter_dc_stream_throughput_outbound_megabits_per_sec:
663
664# How long the coordinator should wait for seq or index scans to complete
665# range_request_timeout_in_ms: 10000
666# How long the coordinator should wait for writes to complete
667# counter_write_request_timeout_in_ms: 5000
668# How long a coordinator should continue to retry a CAS operation
669# that contends with other proposals for the same row
670# cas_contention_timeout_in_ms: 1000
671# How long the coordinator should wait for truncates to complete
672# (This can be much longer, because unless auto_snapshot is disabled
673# we need to flush first so we can snapshot before removing the data.)
674# truncate_request_timeout_in_ms: 60000
675# The default timeout for other, miscellaneous operations
676# request_timeout_in_ms: 10000
677
678# Enable operation timeout information exchange between nodes to accurately
679# measure request timeouts. If disabled, replicas will assume that requests
680# were forwarded to them instantly by the coordinator, which means that
681# under overload conditions we will waste that much extra time processing
682# already-timed-out requests.
683#
684# Warning: before enabling this property make sure to ntp is installed
685# and the times are synchronized between the nodes.
686# cross_node_timeout: false
687
688# Enable socket timeout for streaming operation.
689# When a timeout occurs during streaming, streaming is retried from the start
690# of the current file. This _can_ involve re-streaming an important amount of
691# data, so you should avoid setting the value too low.
692# Default value is 0, which never timeout streams.
693# streaming_socket_timeout_in_ms: 0
694
695# controls how often to perform the more expensive part of host score
696# calculation
697# dynamic_snitch_update_interval_in_ms: 100
698
699# controls how often to reset all host scores, allowing a bad host to
700# possibly recover
701# dynamic_snitch_reset_interval_in_ms: 600000
702
703# if set greater than zero and read_repair_chance is < 1.0, this will allow
704# 'pinning' of replicas to hosts in order to increase cache capacity.
705# The badness threshold will control how much worse the pinned host has to be
706# before the dynamic snitch will prefer other replicas over it. This is
707# expressed as a double which represents a percentage. Thus, a value of
708# 0.2 means Scylla would continue to prefer the static snitch values
709# until the pinned host was 20% worse than the fastest.
710# dynamic_snitch_badness_threshold: 0.1
711
712# request_scheduler -- Set this to a class that implements
713# RequestScheduler, which will schedule incoming client requests
714# according to the specific policy. This is useful for multi-tenancy
715# with a single Scylla cluster.
716# NOTE: This is specifically for requests from the client and does
717# not affect inter node communication.
718# org.apache.cassandra.scheduler.NoScheduler - No scheduling takes place
719# org.apache.cassandra.scheduler.RoundRobinScheduler - Round robin of
720# client requests to a node with a separate queue for each
721# request_scheduler_id. The scheduler is further customized by
722# request_scheduler_options as described below.
723# request_scheduler: org.apache.cassandra.scheduler.NoScheduler
724
725# Scheduler Options vary based on the type of scheduler
726# NoScheduler - Has no options
727# RoundRobin
728# - throttle_limit -- The throttle_limit is the number of in-flight
729# requests per client. Requests beyond
730# that limit are queued up until
731# running requests can complete.
732# The value of 80 here is twice the number of
733# concurrent_reads + concurrent_writes.
734# - default_weight -- default_weight is optional and allows for
735# overriding the default which is 1.
736# - weights -- Weights are optional and will default to 1 or the
737# overridden default_weight. The weight translates into how
738# many requests are handled during each turn of the
739# RoundRobin, based on the scheduler id.
740#
741# request_scheduler_options:
742# throttle_limit: 80
743# default_weight: 5
744# weights:
745# Keyspace1: 1
746# Keyspace2: 5
747
748# request_scheduler_id -- An identifier based on which to perform
749# the request scheduling. Currently the only valid option is keyspace.
750# request_scheduler_id: keyspace
751
752# Enable or disable inter-node encryption.
753# You must also generate keys and provide the appropriate key and trust store locations and passwords.
754# No custom encryption options are currently enabled. The available options are:
755#
756# The available internode options are : all, none, dc, rack
757# If set to dc scylla will encrypt the traffic between the DCs
758# If set to rack scylla will encrypt the traffic between the racks
759#
760# server_encryption_options:
761# internode_encryption: none
762# certificate: conf/scylla.crt
763# keyfile: conf/scylla.key
764# truststore: <none, use system trust>
765
766# enable or disable client/server encryption.
767# client_encryption_options:
768# enabled: false
769# certificate: conf/scylla.crt
770# keyfile: conf/scylla.key
771
772 # require_client_auth: false
773 # Set trustore and truststore_password if require_client_auth is true
774 # truststore: conf/.truststore
775 # truststore_password: cassandra
776 # More advanced defaults below:
777 # protocol: TLS
778 # algorithm: SunX509
779 # store_type: JKS
780 # cipher_suites: [TLS_RSA_WITH_AES_128_CBC_SHA,TLS_RSA_WITH_AES_256_CBC_SHA,TLS_DHE_RSA_WITH_AES_128_CBC_SHA,TLS_DHE_RSA_WITH_AES_256_CBC_SHA,TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA,TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA]
781
782# internode_compression controls whether traffic between nodes is
783# compressed.
784# can be: all - all traffic is compressed
785# dc - traffic between different datacenters is compressed
786# none - nothing is compressed.
787# internode_compression: none
788
789# Enable or disable tcp_nodelay for inter-dc communication.
790# Disabling it will result in larger (but fewer) network packets being sent,
791# reducing overhead from the TCP protocol itself, at the cost of increasing
792# latency if you block for cross-datacenter responses.
793# inter_dc_tcp_nodelay: false
794
795# Relaxation of environment checks.
796#
797# Scylla places certain requirements on its environment. If these requirements are
798# not met, performance and reliability can be degraded.
799#
800# These requirements include:
801# - A filesystem with good support for aysnchronous I/O (AIO). Currently,
802# this means XFS.
803#
804# false: strict environment checks are in place; do not start if they are not met.
805# true: relaxed environment checks; performance and reliability may degraade.
806#
807# developer_mode: false
808
809
810# Idle-time background processing
811#
812# Scylla can perform certain jobs in the background while the system is otherwise idle,
813# freeing processor resources when there is other work to be done.
814#
815# defragment_memory_on_idle: true
816#
817# prometheus port
818# By default, Scylla opens prometheus API port on port 9180
819# setting the port to 0 will disable the prometheus API.
820# prometheus_port: 9180
821#
822# prometheus address
823# By default, Scylla binds all interfaces to the prometheus API
824# It is possible to restrict the listening address to a specific one
825# prometheus_address: 0.0.0.0