content large_stringlengths 3 20.5k | url large_stringlengths 53 192 ⌀ | branch large_stringclasses 4
values | source large_stringclasses 51
values | embeddings listlengths 384 384 | score float64 -0.21 0.65 |
|---|---|---|---|---|---|
time. To deal with that the replica uses its logical clock to report that a key does not exist \*\*only for read operations\*\* that don't violate the consistency of the data set (as new commands from the master will arrive). In this way replicas avoid reporting logically expired keys that are still existing. In practi... | https://github.com/redis/redis-doc/blob/master/docs/management/replication.md | master | redis | [
-0.10570939630270004,
-0.026839112862944603,
0.00006415533425752074,
0.022527359426021576,
0.056584492325782776,
-0.07958705723285675,
-0.07688482850790024,
0.02187296375632286,
0.10277891159057617,
0.03400746360421181,
0.05355951562523842,
0.11607750505208969,
-0.0026827778201550245,
-0.0... | 0.064343 |
continue accepting writes for some time, so using the same replication ID in the promoted replica would violate the rule that a replication ID and offset pair identifies only a single data set. Moreover, replicas - when powered off gently and restarted - are able to store in the `RDB` file the information needed to res... | https://github.com/redis/redis-doc/blob/master/docs/management/replication.md | master | redis | [
-0.02622784674167633,
-0.07120747864246368,
-0.017242377623915672,
-0.020377641543745995,
0.010916564613580704,
0.01864829659461975,
-0.03710808604955673,
-0.08571087568998337,
0.02258250117301941,
0.07850286364555359,
-0.014811510220170021,
0.15052561461925507,
0.048973944038152695,
-0.04... | -0.020316 |
## Redis setup tips ### Linux \* Deploy Redis using the Linux operating system. Redis is also tested on OS X, and from time to time on FreeBSD and OpenBSD systems. However, Linux is where most of the stress testing is performed, and where most production deployments are run. \* Set the Linux kernel overcommit memory se... | https://github.com/redis/redis-doc/blob/master/docs/management/admin.md | master | redis | [
0.03805091604590416,
-0.013404464349150658,
-0.08517080545425415,
0.013870288617908955,
0.07548245042562485,
-0.12222534418106079,
-0.021004680544137955,
0.048895999789237976,
-0.023728691041469574,
0.02743043750524521,
0.012448926456272602,
0.015357320196926594,
-0.0018602843629196286,
-0... | 0.115781 |
about how to secure Redis. ## Running Redis on EC2 \* Use HVM based instances, not PV based instances. \* Do not use old instance families. For example, use m3.medium with HVM instead of m1.medium with PV. \* The use of Redis persistence with EC2 EBS volumes needs to be handled with care because sometimes EBS volumes h... | https://github.com/redis/redis-doc/blob/master/docs/management/admin.md | master | redis | [
-0.017078334465622902,
-0.006312356796115637,
-0.05118498206138611,
-0.05198332667350769,
0.0014728271635249257,
-0.012688564136624336,
-0.054636355489492416,
-0.005260765086859465,
-0.00954605732113123,
0.001026646699756384,
-0.028474798426032066,
0.03248976916074753,
0.07090101391077042,
... | 0.019813 |
This page tries to help you with what to do if you have issues with Redis. Part of the Redis project is helping people that are experiencing problems because we don't like to leave people alone with their issues. \* If you have \*\*latency problems\*\* with Redis, that in some way appears to be idle for some time, read... | https://github.com/redis/redis-doc/blob/master/docs/management/troubleshooting.md | master | redis | [
0.017335105687379837,
-0.048038989305496216,
-0.05743124336004257,
0.02497659996151924,
-0.021090544760227203,
-0.11084925383329391,
-0.00037656695349141955,
0.029510946944355965,
-0.004934667143970728,
0.016517499461770058,
-0.008969167247414589,
0.030684204772114754,
0.012126196175813675,
... | 0.138835 |
Redis Sentinel provides high availability for Redis when not using [Redis Cluster](/docs/manual/scaling). Redis Sentinel also provides other collateral tasks such as monitoring, notifications and acts as a configuration provider for clients. This is the full list of Sentinel capabilities at a macroscopic level (i.e. th... | https://github.com/redis/redis-doc/blob/master/docs/management/sentinel.md | master | redis | [
-0.00508908461779356,
-0.10282447189092636,
-0.00780158955603838,
0.07058768719434738,
0.05213196948170662,
-0.06776586174964905,
0.024689912796020508,
-0.003829787252470851,
0.03904516249895096,
0.012674772180616856,
-0.057434093207120895,
0.03861283138394356,
0.047905124723911285,
-0.031... | 0.216598 |
path is not writable. Sentinels by default run \*\*listening for connections to TCP port 26379\*\*, so for Sentinels to work, port 26379 of your servers \*\*must be open\*\* to receive connections from the IP addresses of the other Sentinel instances. Otherwise Sentinels can't talk and can't agree about what to do, so ... | https://github.com/redis/redis-doc/blob/master/docs/management/sentinel.md | master | redis | [
0.01654811017215252,
-0.11943759024143219,
-0.012349594384431839,
0.04534748196601868,
-0.017801348119974136,
-0.048904888331890106,
-0.026016948744654655,
0.013674384914338589,
0.01277786772698164,
0.028925713151693344,
-0.06863536685705185,
0.02882838249206543,
0.025718877092003822,
-0.0... | 0.137276 |
not reachable, in order to really mark the master as failing, and eventually start a failover procedure if possible. \* However \*\*the quorum is only used to detect the failure\*\*. In order to actually perform a failover, one of the Sentinels need to be elected leader for the failover and be authorized to proceed. Th... | https://github.com/redis/redis-doc/blob/master/docs/management/sentinel.md | master | redis | [
-0.011064676567912102,
-0.09548000991344452,
0.05991694703698158,
0.01683819107711315,
0.0025288534816354513,
-0.0016868436941877007,
-0.05858886241912842,
0.009217998012900352,
-0.01735035516321659,
0.041528623551130295,
-0.048928774893283844,
-0.030759047716856003,
0.051654838025569916,
... | 0.134486 |
Also note that: \* Masters are called M1, M2, M3, ..., Mn. \* Replicas are called R1, R2, R3, ..., Rn (R stands for \*replica\*). \* Sentinels are called S1, S2, S3, ..., Sn. \* Clients are called C1, C2, C3, ..., Cn. \* When an instance changes role because of Sentinel actions, we put it inside square brackets, so [M1... | https://github.com/redis/redis-doc/blob/master/docs/management/sentinel.md | master | redis | [
-0.05591438710689545,
-0.06199095770716667,
0.06576979905366898,
0.019405841827392578,
-0.023085104301571846,
0.02056356705725193,
0.0016623169649392366,
0.00013379483425524086,
-0.020202796906232834,
-0.006020460743457079,
-0.049662746489048004,
-0.05180945619940758,
0.08781315386295319,
... | 0.183524 |
so the replica R2 is promoted to master. However clients, like C1, that are in the same partition as the old master, may continue to write data to the old master. This data will be lost forever since when the partition will heal, the master will be reconfigured as a replica of the new master, discarding its data set. T... | https://github.com/redis/redis-doc/blob/master/docs/management/sentinel.md | master | redis | [
-0.05542869120836258,
-0.07068219780921936,
0.0000770205951994285,
0.04355710744857788,
0.048722364008426666,
-0.034979674965143204,
-0.04833446815609932,
-0.007628561928868294,
0.04237987846136093,
0.004662834573537111,
-0.007684726268053055,
0.10584244877099991,
0.08207660168409348,
-0.0... | 0.05603 |
master would never be available during replica failures. So this is a valid setup but the setup in the Example 2 has advantages such as the HA system of Redis running in the same boxes as Redis itself which may be simpler to manage, and the ability to put a bound on the amount of time a master in the minority partition... | https://github.com/redis/redis-doc/blob/master/docs/management/sentinel.md | master | redis | [
-0.04491302743554115,
-0.05947723239660263,
-0.009814083576202393,
0.04406629130244255,
-0.03824429586529732,
-0.024426352232694626,
-0.06112903729081154,
0.02907312661409378,
-0.011524444445967674,
0.054356373846530914,
-0.04742696136236191,
-0.005788817536085844,
0.10876079648733139,
-0.... | 0.089741 |
you can use the following two Sentinel configuration directives in order to force Sentinel to announce a specific set of IP and port: sentinel announce-ip sentinel announce-port Note that Docker has the ability to run in \*host networking mode\* (check the `--net=host` option for more information). This should create n... | https://github.com/redis/redis-doc/blob/master/docs/management/sentinel.md | master | redis | [
0.002858725842088461,
-0.050820350646972656,
0.0029786245431751013,
0.018299650400877,
-0.017828000709414482,
-0.04560833424329758,
-0.03306346759200096,
-0.06277751177549362,
0.01680913008749485,
0.06068495288491249,
-0.06444720923900604,
-0.025719981640577316,
0.004450871143490076,
-0.00... | 0.106703 |
amount of time. Once you start the three Sentinels, you'll see a few messages they log, like: +monitor master mymaster 127.0.0.1 6379 quorum 2 This is a Sentinel event, and you can receive this kind of events via Pub/Sub if you `SUBSCRIBE` to the event name as specified later in [\_Pub/Sub Messages\_ section](#pubsub-m... | https://github.com/redis/redis-doc/blob/master/docs/management/sentinel.md | master | redis | [
0.051179975271224976,
-0.12780551612377167,
-0.022735120728611946,
0.05423879250884056,
0.053677164018154144,
-0.07845745235681534,
-0.021405857056379318,
-0.03797505795955658,
0.03214070945978165,
0.022128557786345482,
-0.07809492945671082,
-0.019642721861600876,
0.028462806716561317,
-0.... | 0.118212 |
So far so good... At this point you may jump to create your Sentinel deployment or can read more to understand all the Sentinel commands and internals. ## Sentinel API Sentinel provides an API in order to inspect its state, check the health of monitored masters and replicas, subscribe in order to receive specific notif... | https://github.com/redis/redis-doc/blob/master/docs/management/sentinel.md | master | redis | [
0.008403084240853786,
-0.10563309490680695,
-0.03935984522104263,
0.04928354173898697,
0.049708977341651917,
-0.06856502592563629,
0.015436844900250435,
-0.01415012963116169,
0.0036462002899497747,
0.03697850555181503,
-0.10004667937755585,
-0.033056072890758514,
0.010635990649461746,
-0.0... | 0.20624 |
of the Sentinel instance. \* \*\*SENTINEL PENDING-SCRIPTS\*\* This command returns information about pending scripts. \* \*\*SENTINEL REMOVE\*\* Stop Sentinel's monitoring. Refer to the [\_Reconfiguring Sentinel at Runtime\_ section](#reconfiguring-sentinel-at-runtime) for more information. \* \*\*SENTINEL REPLICAS ``\... | https://github.com/redis/redis-doc/blob/master/docs/management/sentinel.md | master | redis | [
-0.013478495180606842,
-0.1027231365442276,
0.014863025397062302,
0.07365920394659042,
0.11655434966087341,
-0.03712446242570877,
-0.010037295520305634,
-0.013440102338790894,
-0.02914651855826378,
0.057161808013916016,
-0.01568359136581421,
-0.038208361715078354,
-0.015672532841563225,
-0... | 0.213948 |
command of Redis, and is used in order to change configuration parameters of a specific master. Multiple option / value pairs can be specified (or none at all). All the configuration parameters that can be configured via `sentinel.conf` are also configurable using the SET command. The following is an example of `SENTIN... | https://github.com/redis/redis-doc/blob/master/docs/management/sentinel.md | master | redis | [
0.014644878916442394,
-0.026520445942878723,
-0.0784311518073082,
0.05402650311589241,
-0.08426492661237717,
0.005845887586474419,
0.001972717698663473,
0.015854395925998688,
-0.026906553655862808,
0.009067350067198277,
-0.03756048530340195,
0.023364000022411346,
0.008104757405817509,
-0.0... | 0.1262 |
master). One after the other, waiting at least 30 seconds between instances. 3. Check that all the Sentinels agree about the number of Sentinels currently active, by inspecting the output of `SENTINEL MASTER mastername` of every Sentinel. ### Removing the old master or unreachable replicas Sentinels never forget about ... | https://github.com/redis/redis-doc/blob/master/docs/management/sentinel.md | master | redis | [
-0.015303983353078365,
-0.1238648071885109,
0.056636013090610504,
0.07189472019672394,
0.0735686868429184,
-0.038985732942819595,
-0.05896436423063278,
-0.029199307784438133,
0.012716402299702168,
0.01766398176550865,
-0.024376031011343002,
0.011566383764147758,
0.017224624752998352,
-0.05... | 0.099655 |
is now in Objectively Down state. \* \*\*-odown\*\* `` -- The specified instance is no longer in Objectively Down state. \* \*\*+new-epoch\*\* `` -- The current epoch was updated. \* \*\*+try-failover\*\* `` -- New failover in progress, waiting to be elected by the majority. \* \*\*+elected-leader\*\* `` -- Won the ele... | https://github.com/redis/redis-doc/blob/master/docs/management/sentinel.md | master | redis | [
-0.08190207928419113,
-0.0024760267697274685,
0.058194924145936966,
-0.006555548403412104,
-0.03816197067499161,
-0.009642302989959717,
-0.02820730023086071,
-0.05269339308142662,
-0.11819908767938614,
0.07507535815238953,
0.005574143026024103,
-0.06385491788387299,
0.06629889458417892,
-0... | 0.120256 |
sentinel auth-pass Where `` and `` are the username and password for accessing the group's instances. These credentials should be provisioned on all of the group's Redis instances with the minimal control permissions. For example: 127.0.0.1:6379> ACL SETUSER sentinel-user ON >somepassword allchannels +multi +slaveof +p... | https://github.com/redis/redis-doc/blob/master/docs/management/sentinel.md | master | redis | [
-0.025412673130631447,
-0.06031021103262901,
-0.0854908749461174,
0.04736017435789108,
-0.014376995153725147,
-0.0322730615735054,
0.0003414570528548211,
-0.021510303020477295,
0.03190866857767105,
0.007820445112884045,
-0.04610539972782135,
-0.00033701187931001186,
0.06845833361148834,
-0... | 0.120902 |
\*\*all\*\* your Sentinel instances as follows: requirepass "your\_password\_here" When configured this way, Sentinels will do two things: 1. A password will be required from clients in order to send commands to Sentinels. This is obvious since this is how such configuration directive works in Redis in general. 2. More... | https://github.com/redis/redis-doc/blob/master/docs/management/sentinel.md | master | redis | [
-0.009867251850664616,
-0.08884882181882858,
-0.07029099017381668,
0.02457374893128872,
-0.004978482145816088,
-0.028430387377738953,
0.05024755001068115,
-0.015735575929284096,
0.028805391862988472,
0.005449961870908737,
-0.05735732614994049,
-0.006967372260987759,
0.07734227925539017,
0.... | 0.113004 |
but no failover can be triggered without reaching the ODOWN state. The ODOWN condition \*\*only applies to masters\*\*. For other kind of instances Sentinel doesn't require to act, so the ODOWN state is never reached for replicas and other sentinels, but only SDOWN is. However SDOWN has also semantic implications. For ... | https://github.com/redis/redis-doc/blob/master/docs/management/sentinel.md | master | redis | [
-0.009062771685421467,
-0.09733639657497406,
0.04094330966472626,
0.08491846919059753,
0.049890268594026566,
-0.006919878534972668,
0.02588556706905365,
-0.009737632237374783,
-0.0075541902333498,
-0.010423519648611546,
-0.05900121107697487,
-0.01807982660830021,
0.026649072766304016,
-0.0... | 0.136374 |
be selected. The replica selection process evaluates the following information about replicas: 1. Disconnection time from the master. 2. Replica priority. 3. Replication offset processed. 4. Run ID. A replica that is found to be disconnected from the master for more than ten times the configured master timeout (down-af... | https://github.com/redis/redis-doc/blob/master/docs/management/sentinel.md | master | redis | [
-0.013272356241941452,
-0.07034130394458771,
0.03473624214529991,
0.069268137216568,
0.048868414014577866,
-0.041160766035318375,
-0.01352805644273758,
0.009173759259283543,
0.007396749686449766,
0.03495850786566734,
-0.030377648770809174,
0.030731577426195145,
0.02130999229848385,
-0.0585... | 0.104407 |
state. \* Once the failover is triggered, the Sentinel trying to failover is required to ask for authorization to a majority of Sentinels (or more than the majority if the quorum is set to a number greater than the majority). The difference may seem subtle but is actually quite simple to understand and use. For example... | https://github.com/redis/redis-doc/blob/master/docs/management/sentinel.md | master | redis | [
0.004925278015434742,
-0.05732840299606323,
0.08961298316717148,
0.03851398080587387,
0.00043973352876491845,
-0.000551417819224298,
-0.02622458152472973,
0.0439513698220253,
0.009201628156006336,
0.03232796490192413,
-0.09140946716070175,
-0.024160701781511307,
0.06212617829442024,
-0.016... | 0.146185 |
point, even if the reconfiguration of the replicas is in progress, the failover is considered to be successful, and all the Sentinels are required to start reporting the new configuration. The way a new configuration is propagated is the reason why we need that every Sentinel failover is authorized with a different ver... | https://github.com/redis/redis-doc/blob/master/docs/management/sentinel.md | master | redis | [
0.013270863331854343,
-0.09481886029243469,
0.0401248000562191,
0.02101440355181694,
0.0591590590775013,
-0.04282427951693535,
-0.02306370623409748,
-0.027119923382997513,
0.027519404888153076,
-0.0007685685995966196,
-0.04105490446090698,
0.05295713618397713,
0.049762506037950516,
-0.0613... | 0.108308 |
could be handy that Client B is still able to write to the old master, even if its data will be lost. \* If you are using Redis as a store, this is not good and you need to configure the system in order to partially prevent this problem. Since Redis is asynchronously replicated, there is no way to totally prevent data ... | https://github.com/redis/redis-doc/blob/master/docs/management/sentinel.md | master | redis | [
-0.06075255945324898,
-0.059418536722660065,
0.004526928532868624,
0.03303515911102295,
0.011812726967036724,
-0.015144620090723038,
-0.019858725368976593,
-0.014895564876496792,
0.05640653893351555,
0.013142130337655544,
-0.02654126286506653,
0.06614470481872559,
0.1103183701634407,
-0.06... | -0.000376 |
that more or less 100 milliseconds will elapse between two calls to the timer interrupt. What a Sentinel does is to register the previous time the timer interrupt was called, and compare it with the current call: if the time difference is negative or unexpectedly big (2 seconds or more) the TILT mode is entered (or if ... | https://github.com/redis/redis-doc/blob/master/docs/management/sentinel.md | master | redis | [
-0.013237474486231804,
-0.09724252671003342,
-0.0027047356124967337,
0.09935658425092697,
0.05473286285996437,
-0.03768838196992874,
0.00514734024181962,
0.024973101913928986,
0.06521693617105484,
0.013727609999477863,
0.017511142417788506,
-0.0042520128190517426,
-0.029676910489797592,
-0... | 0.159743 |
Redis is able to start without a configuration file using a built-in default configuration, however this setup is only recommended for testing and development purposes. The proper way to configure Redis is by providing a Redis configuration file, usually called `redis.conf`. The `redis.conf` file contains a number of d... | https://github.com/redis/redis-doc/blob/master/docs/management/config.md | master | redis | [
-0.05040813609957695,
-0.04949400946497917,
-0.10447674244642258,
0.00535792950540781,
-0.04438082501292229,
-0.043714284896850586,
0.006555465050041676,
0.02969120256602764,
-0.017111152410507202,
-0.030371708795428276,
-0.017012478783726692,
-0.009721151553094387,
0.10911327600479126,
-0... | 0.06968 |
as an example): maxmemory 2mb maxmemory-policy allkeys-lru In this configuration there is no need for the application to set a time to live for keys using the `EXPIRE` command (or equivalent) since all the keys will be evicted using an approximated LRU algorithm as long as we hit the 2 megabyte memory limit. Basically,... | https://github.com/redis/redis-doc/blob/master/docs/management/config.md | master | redis | [
-0.01908491924405098,
-0.05130266025662422,
-0.06461382657289505,
-0.004595996346324682,
-0.009833695366978645,
-0.10285785049200058,
-0.010935473255813122,
0.06289588660001755,
-0.012130656279623508,
0.024585621431469917,
0.0447424054145813,
0.10194411873817444,
0.02457539178431034,
-0.05... | 0.127566 |
Persistence refers to the writing of data to durable storage, such as a solid-state disk (SSD). Redis provides a range of persistence options. These include: \* \*\*RDB\*\* (Redis Database): RDB persistence performs point-in-time snapshots of your dataset at specified intervals. \* \*\*AOF\*\* (Append Only File): AOF p... | https://github.com/redis/redis-doc/blob/master/docs/management/persistence.md | master | redis | [
-0.026268821209669113,
-0.03714948892593384,
-0.13177193701267242,
0.04007207229733467,
-0.02009243704378605,
0.011566642671823502,
-0.0006294981576502323,
-0.011890474706888199,
0.04437762498855591,
0.009575779549777508,
0.010616892017424107,
0.10255138576030731,
0.03965500742197037,
-0.0... | 0.124762 |
you can only lose one second worth of writes. \* The AOF log is an append-only log, so there are no seeks, nor corruption problems if there is a power outage. Even if the log ends with a half-written command for some reason (disk full or other reasons) the redis-check-aof tool is able to fix it easily. \* Redis is able... | https://github.com/redis/redis-doc/blob/master/docs/management/persistence.md | master | redis | [
-0.026006802916526794,
-0.03562110662460327,
-0.04802185669541359,
0.0415194109082222,
0.04287159442901611,
-0.14532065391540527,
-0.028410566970705986,
-0.013222446665167809,
0.045448631048202515,
0.08593522012233734,
-0.0004984384286217391,
0.12062779814004898,
-0.00976688601076603,
-0.1... | 0.099817 |
works Whenever Redis needs to dump the dataset to disk, this is what happens: \* Redis [forks](http://linux.die.net/man/2/fork). We now have a child and a parent process. \* The child starts to write the dataset to a temporary RDB file. \* When the child is done writing the new RDB file, it replaces the old one. This m... | https://github.com/redis/redis-doc/blob/master/docs/management/persistence.md | master | redis | [
-0.04535692557692528,
-0.03695344552397728,
-0.04178910329937935,
-0.0077859098091721535,
0.07490044087171555,
-0.08263066411018372,
-0.01950065791606903,
0.049427881836891174,
0.018144559115171432,
0.06960712373256683,
0.027054758742451668,
0.09850171208381653,
0.012386481277644634,
-0.08... | 0.050691 |
rewrite, Redis introduces an AOF rewrite limiting mechanism to ensure that failed AOF rewrites are retried at a slower and slower rate. ### How durable is the append only file? You can configure how many times Redis will [`fsync`](http://linux.die.net/man/2/fsync) data on disk. There are three options: \* `appendfsync ... | https://github.com/redis/redis-doc/blob/master/docs/management/persistence.md | master | redis | [
-0.014192631468176842,
-0.05600365251302719,
-0.04689597710967064,
0.060380179435014725,
0.03240739181637764,
-0.17412827908992767,
-0.06490413844585419,
0.023423396050930023,
0.05163438245654106,
0.07198701053857803,
-0.009567445144057274,
0.08426792919635773,
-0.017162440344691277,
-0.10... | 0.103755 |
thing to do is to run the `redis-check-aof` utility, initially without the `--fix` option, then understand the problem, jump to the given offset in the file, and see if it is possible to manually repair the file: The AOF uses the same format of the Redis protocol and is quite simple to fix manually. Otherwise it is pos... | https://github.com/redis/redis-doc/blob/master/docs/management/persistence.md | master | redis | [
-0.06871099025011063,
-0.02123037539422512,
0.011335649527609348,
-0.028122929856181145,
0.04832563176751137,
-0.15864941477775574,
-0.003760841442272067,
0.003389270743355155,
0.01803559623658657,
0.08509005606174469,
0.02109266258776188,
0.07144910842180252,
-0.02062125876545906,
-0.0793... | 0.037242 |
loss of your data. Next time you restart the server: \* Before restarting the server, wait for AOF rewrite to finish persisting the data. You can do that by watching `INFO persistence`, waiting for `aof\_rewrite\_in\_progress` and `aof\_rewrite\_scheduled` to be `0`, and validating that `aof\_last\_bgrewrite\_status` i... | https://github.com/redis/redis-doc/blob/master/docs/management/persistence.md | master | redis | [
0.02303253673017025,
-0.09099069237709045,
-0.04970495030283928,
0.00048639794113114476,
-0.02452365681529045,
-0.06231139227747917,
-0.02546599693596363,
-0.00771087221801281,
0.0457211509346962,
0.08184179663658142,
-0.013571641407907009,
0.04320867732167244,
0.019166231155395508,
-0.075... | 0.012493 |
all you need to do is copy/tar the files in this directory to achieve a backup. However, if this is done during a [rewrite](#log-rewriting), you might end up with an invalid backup. To work around this you must disable AOF rewrites during the backup: 1. Turn off automatic rewrites with `CONFIG SET` `auto-aof-rewrite-pe... | https://github.com/redis/redis-doc/blob/master/docs/management/persistence.md | master | redis | [
-0.024636657908558846,
-0.024229777976870537,
0.01359512284398079,
-0.009378047659993172,
0.04117593914270401,
-0.06708372384309769,
-0.04032246023416519,
-0.005876598414033651,
0.01171881053596735,
0.08862552046775818,
0.023061677813529968,
0.03882790356874466,
-0.02109210193157196,
-0.05... | -0.056525 |
At least, make absolutely sure that after the transfer is completed you are able to verify the file size (that should match the one of the file you copied) and possibly the SHA1 digest, if you are using a VPS. You also need some kind of independent alert system if the transfer of fresh backups is not working for some r... | https://github.com/redis/redis-doc/blob/master/docs/management/persistence.md | master | redis | [
-0.018092362210154533,
-0.03893586993217468,
0.020574213936924934,
-0.06333129853010178,
0.09040848910808563,
-0.08059395849704742,
-0.04860258102416992,
-0.057680923491716385,
0.03006238304078579,
-0.007757821120321751,
0.048142578452825546,
-0.008145729079842567,
0.0338069386780262,
-0.0... | -0.056549 |
Redis scales horizontally with a deployment topology called Redis Cluster. This topic will teach you how to set up, test, and operate Redis Cluster in production. You will learn about the availability and consistency characteristics of Redis Cluster from the end user's point of view. If you plan to run a production Red... | https://github.com/redis/redis-doc/blob/master/docs/management/scaling.md | master | redis | [
0.00893899891525507,
-0.07188446819782257,
-0.04274929687380791,
0.018197467550635338,
-0.020913006737828255,
-0.07991746813058853,
-0.0338410884141922,
0.02358138933777809,
-0.04001723602414131,
-0.004408087581396103,
-0.01574981026351452,
0.016130393370985985,
0.05502571910619736,
-0.031... | 0.143249 |
and to compute the hash slot for a given key, we simply take the CRC16 of the key modulo 16384. Every node in a Redis Cluster is responsible for a subset of the hash slots, so, for example, you may have a cluster with 3 nodes, where: \* Node A contains hash slots from 0 to 5500. \* Node B contains hash slots from 5501 ... | https://github.com/redis/redis-doc/blob/master/docs/management/scaling.md | master | redis | [
0.011518135666847229,
-0.007014083210378885,
-0.08334773778915405,
-0.0006504403427243233,
-0.0010888103861361742,
-0.07189338654279709,
-0.026923155412077904,
-0.029489006847143173,
0.029425591230392456,
0.024040276184678078,
0.029973139986395836,
0.03872251138091087,
0.0687176063656807,
... | 0.118207 |
following happens: \* Your client writes to the master B. \* The master B replies OK to your client. \* The master B propagates the write to its replicas B1, B2 and B3. As you can see, B does not wait for an acknowledgement from B1, B2, B3 before replying to the client, since this would be a prohibitive latency penalty... | https://github.com/redis/redis-doc/blob/master/docs/management/scaling.md | master | redis | [
-0.012510817497968674,
-0.07654902338981628,
-0.013328630477190018,
0.04765569791197777,
-0.005841184873133898,
-0.044843729585409164,
-0.03311464563012123,
-0.023230260238051414,
0.07451347261667252,
0.031132681295275688,
-0.04869953915476799,
0.09756337106227875,
0.11451797187328339,
-0.... | 0.078446 |
## Redis Cluster configuration parameters We are about to create an example cluster deployment. Before we continue, let's introduce the configuration parameters that Redis Cluster introduces in the `redis.conf` file. \* \*\*cluster-enabled ``\*\*: If yes, enables Redis Cluster support in a specific Redis instance. Othe... | https://github.com/redis/redis-doc/blob/master/docs/management/scaling.md | master | redis | [
-0.005058981478214264,
-0.0250448789447546,
-0.06220295652747154,
0.08382658660411835,
0.0641281008720398,
-0.017600663006305695,
0.00723333191126585,
-0.012596477754414082,
-0.006592470686882734,
-0.006430542562156916,
0.008783607743680477,
0.057776615023612976,
0.05003809928894043,
-0.08... | 0.164415 |
changes in the cluster. This option can be set to yes to allow reads from a node during the fail state, which is useful for applications that want to prioritize read availability but still want to prevent inconsistent writes. It can also be used for when using Redis Cluster with only one or two shards, as it allows the... | https://github.com/redis/redis-doc/blob/master/docs/management/scaling.md | master | redis | [
0.004968269262462854,
-0.07250837981700897,
-0.010480138473212719,
0.061505407094955444,
0.002524367766454816,
-0.05038146302103996,
-0.040043603628873825,
0.024370821192860603,
0.0007511575822718441,
0.016076989471912384,
-0.05244207754731178,
0.037763021886348724,
0.07112780958414078,
-0... | 0.118197 |
127.0.0.1:7000 127.0.0.1:7001 \ 127.0.0.1:7002 127.0.0.1:7003 127.0.0.1:7004 127.0.0.1:7005 \ --cluster-replicas 1 The command used here is \*\*create\*\*, since we want to create a new cluster. The option `--cluster-replicas 1` means that we want a replica for every master created. The other arguments are the list of ... | https://github.com/redis/redis-doc/blob/master/docs/management/scaling.md | master | redis | [
0.0029859091155231,
-0.06876183301210403,
-0.05662044882774353,
0.012005507946014404,
-0.032665103673934937,
-0.04607637599110603,
-0.012739812955260277,
-0.030327625572681427,
0.004748154431581497,
-0.015607481822371483,
-0.01909252069890499,
-0.05589509382843971,
0.09609350562095642,
-0.... | 0.124604 |
at the same time try to make nodes failing, or start a resharding, to see how Redis Cluster behaves under real world conditions. It is not very helpful to see what happens while nobody is writing to the cluster. This section explains some basic usage of [redis-rb-cluster](https://github.com/antirez/redis-rb-cluster) sh... | https://github.com/redis/redis-doc/blob/master/docs/management/scaling.md | master | redis | [
-0.021853094920516014,
-0.03802219405770302,
-0.08068274706602097,
0.08743464201688766,
0.06582150608301163,
-0.05307117849588394,
-0.032063886523246765,
-0.03078790381550789,
-0.016806069761514664,
0.030564801767468452,
-0.031202463433146477,
0.04634694755077362,
0.041641540825366974,
-0.... | 0.111725 |
fact that this is a busy loop without real parallelism of course, so you'll get the usually 10k ops/second in the best of the conditions). Normally writes are slowed down in order for the example application to be easier to follow by humans. Starting the application produces the following output: ``` ruby ./example.rb ... | https://github.com/redis/redis-doc/blob/master/docs/management/scaling.md | master | redis | [
-0.006668249145150185,
-0.08346865326166153,
-0.10448949784040451,
0.0884690135717392,
0.023279927670955658,
-0.08661819994449615,
-0.046138931065797806,
0.0356975682079792,
-0.054904449731111526,
0.017223969101905823,
-0.029367689043283463,
0.07040345668792725,
0.029286060482263565,
-0.08... | 0.112376 |
the parameters in an interactive way. This is possible using a command line like the following: redis-cli --cluster reshard : --cluster-from --cluster-to --cluster-slots --cluster-yes This allows to build some automatism if you are likely to reshard often, however currently there is no way for `redis-cli` to automatica... | https://github.com/redis/redis-doc/blob/master/docs/management/scaling.md | master | redis | [
0.01863222010433674,
-0.0611729770898819,
-0.09653838723897934,
0.05841529741883278,
-0.021970026195049286,
-0.05888441950082779,
0.04156653583049774,
-0.0119472062215209,
-0.009206175804138184,
-0.016871344298124313,
-0.005518864840269089,
-0.03156936541199684,
0.08264194428920746,
-0.064... | 0.153023 |
program reports 114 lost writes (`INCR` commands that are not remembered by the cluster). This program is much more interesting as a test case, so we'll use it to test the Redis Cluster failover. #### Test the failover To trigger the failover, the simplest thing we can do (that is also the semantically simplest failure... | https://github.com/redis/redis-doc/blob/master/docs/management/scaling.md | master | redis | [
0.0157025083899498,
-0.062441349029541016,
-0.013738328590989113,
0.06134828180074692,
0.05392728000879288,
-0.04955471679568291,
-0.035633791238069534,
0.03078249655663967,
-0.031738877296447754,
0.029172636568546295,
-0.008871158584952354,
-0.0014911189209669828,
0.07881700992584229,
-0.... | 0.1265 |
\* flags: master, replica, myself, fail, ... \* if it is a replica, the Node ID of the master \* Time of the last pending PING still waiting for a reply. \* Time of the last PONG received. \* Configuration epoch for this node (see the Cluster specification). \* Status of the link to this node. \* Slots served... #### M... | https://github.com/redis/redis-doc/blob/master/docs/management/scaling.md | master | redis | [
-0.035962361842393875,
-0.018856311216950417,
-0.013000092469155788,
0.030026020482182503,
0.04922162741422653,
-0.07014614343643188,
0.03143289312720299,
0.0031294208019971848,
-0.021284082904458046,
0.006150117143988609,
-0.015409900806844234,
0.042946819216012955,
0.049512650817632675,
... | 0.146823 |
new tab in your terminal application. \* Enter the `cluster-test` directory. \* Create a directory named `7006`. \* Create a redis.conf file inside, similar to the one used for the other nodes but using 7006 as port number. \* Finally start the server with `../redis-server ./redis.conf` At this point the server should ... | https://github.com/redis/redis-doc/blob/master/docs/management/scaling.md | master | redis | [
0.008886884897947311,
-0.08978790789842606,
-0.11324114352464676,
0.0364999882876873,
-0.01945330947637558,
-0.04553304240107536,
-0.0011749311815947294,
-0.022573331370949745,
-0.0323294997215271,
0.016034703701734543,
0.0017806042451411486,
-0.04845412075519562,
0.06343386322259903,
-0.0... | 0.106839 |
node was added as a replica but you want to move it as a replica of a different master. For example in order to add a replica for the node 127.0.0.1:7005 that is currently serving hash slots in the range 11423-16383, that has a Node ID 3c3a0c74aae0b56170ccb03a76b60cfe7dc1912e, all I need to do is to connect with the ne... | https://github.com/redis/redis-doc/blob/master/docs/management/scaling.md | master | redis | [
-0.01302539836615324,
-0.058920975774526596,
-0.07986045628786087,
-0.0033220057375729084,
-0.0032414663583040237,
-0.042154550552368164,
-0.0074203466065227985,
-0.02114631049335003,
0.016587674617767334,
0.018954338505864143,
0.003853902919217944,
0.0016342045273631811,
0.0717175304889679,... | 0.068513 |
same time, simply because there is no other instance to have a copy of the hash slots the master was serving. However while net-splits are likely to isolate a number of nodes at the same time, many other kind of failures, like hardware or software failures local to a single node, are a very notable class of failures th... | https://github.com/redis/redis-doc/blob/master/docs/management/scaling.md | master | redis | [
-0.016683924943208694,
-0.07424747943878174,
0.08635293692350388,
-0.014720343053340912,
0.08639340102672577,
-0.01662748120725155,
-0.08684229850769043,
0.06541427969932556,
0.07161673903465271,
0.04272409528493881,
-0.009592247195541859,
0.0385371558368206,
0.0470513217151165,
-0.0517408... | 0.069501 |
library or Redis proxy. In both cases it is possible to migrate to Redis Cluster easily, however what is the most important detail is if multiple-keys operations are used by the application, and how. There are three different cases: 1. Multiple keys operations, or transactions, or Lua scripts involving multiple keys, a... | https://github.com/redis/redis-doc/blob/master/docs/management/scaling.md | master | redis | [
-0.03632980212569237,
-0.06624741852283478,
-0.08159492164850235,
-0.031127437949180603,
-0.03926736116409302,
-0.09414703398942947,
0.02689056657254696,
0.007383143063634634,
0.09053044766187668,
-0.005941166076809168,
0.02722601778805256,
0.0445609912276268,
0.06952597945928574,
-0.07755... | 0.120648 |
2.8 instance as source instance the operation may be slow since 2.8 does not implement migrate connection caching, so you may want to restart your source instance with a Redis 3.x version before to perform such operation. {{% alert title="Note" color="info" %}} Starting with Redis 5, if not for backward compatibility, ... | https://github.com/redis/redis-doc/blob/master/docs/management/scaling.md | master | redis | [
-0.002928853500634432,
0.021053878590464592,
-0.03425344079732895,
0.03868745639920235,
0.03762965276837349,
-0.04690628871321678,
0.03342876955866814,
-0.04604623094201088,
0.03903302922844887,
-0.014448157511651516,
-0.022947300225496292,
0.01602991297841072,
0.06268077343702316,
-0.0425... | 0.085663 |
Redis is developed with an emphasis on stability. We do our best with every release to make sure you'll experience a stable product with no crashes. However, if you ever need to debug the Redis process itself, read on. When Redis crashes, it produces a detailed report of what happened. However, sometimes looking at the... | https://github.com/redis/redis-doc/blob/master/docs/management/debugging.md | master | redis | [
-0.03158900886774063,
-0.06452319025993347,
-0.0345316156744957,
0.008037964813411236,
0.036771129816770554,
-0.0654892697930336,
0.0021107150241732597,
0.06391917169094086,
-0.05502258613705635,
0.05256589502096176,
-0.08213034272193909,
0.028025304898619652,
-0.01280164159834385,
-0.0458... | 0.105717 |
info | grep process\_id process\_id:58414 In the above example the process ID is \*\*58414\*\*. Login into your Redis server. (Optional but recommended) Start \*\*screen\*\* or \*\*tmux\*\* or any other program that will make sure that your GDB session will not be closed if your ssh connection times out. You can learn ... | https://github.com/redis/redis-doc/blob/master/docs/management/debugging.md | master | redis | [
0.002788831014186144,
-0.08966488391160965,
-0.1186734139919281,
-0.06363508105278015,
0.012222272343933582,
-0.028966978192329407,
0.044027797877788544,
-0.021185999736189842,
0.0655241310596466,
-0.009745816700160503,
-0.012888931669294834,
0.0286230631172657,
-0.008013934828341007,
-0.0... | 0.04229 |
contain all the data that was inside the Redis instance at the time of the crash; Redis developers will make sure not to share the content with anyone else, and will delete the file as soon as it is no longer used for debugging purposes, but you are warned that by sending the core file you are sending your data. ## Wha... | https://github.com/redis/redis-doc/blob/master/docs/management/debugging.md | master | redis | [
0.032696910202503204,
-0.07127460837364197,
-0.0412885807454586,
-0.01734909601509571,
0.06244344636797905,
-0.04108109325170517,
0.014821220189332962,
0.07180603593587875,
-0.07654979825019836,
0.039920125156641006,
-0.012520764023065567,
-0.002641182392835617,
0.022681210190057755,
-0.07... | 0.051658 |
The Redis ACL, short for Access Control List, is the feature that allows certain connections to be limited in terms of the commands that can be executed and the keys that can be accessed. The way it works is that, after connecting, a client is required to provide a username and a valid password to authenticate. If auth... | https://github.com/redis/redis-doc/blob/master/docs/management/security/acl.md | master | redis | [
-0.08206125348806381,
-0.07331458479166031,
-0.13168257474899292,
0.0372595340013504,
-0.05225690081715584,
-0.01044051256030798,
0.051512621343135834,
-0.00867076963186264,
0.06962918490171432,
-0.03171400725841522,
0.006189072970300913,
0.07157952338457108,
0.06409141421318054,
-0.002691... | 0.089444 |
defaults-configured Redis instance is: > ACL LIST 1) "user default on nopass ~\* &\* +@all" The command above reports the list of users in the same format that is used in the Redis configuration files, by translating the current ACLs set for the users back into their description. The first two words in each line are "u... | https://github.com/redis/redis-doc/blob/master/docs/management/security/acl.md | master | redis | [
-0.04574798792600632,
-0.0630381852388382,
-0.13076689839363098,
0.017911206930875778,
-0.03760673105716705,
-0.01622871868312359,
0.07343311607837677,
-0.023896025493741035,
0.04508492723107338,
-0.01506085880100727,
0.009929167106747627,
0.02787170186638832,
0.074332594871521,
-0.0024448... | 0.090537 |
`%R~`: (Available in Redis 7.0 and later) Add the specified read key pattern. This behaves similar to the regular key pattern but only grants permission to read from keys that match the given pattern. See [key permissions](#key-permissions) for more information. \* `%W~`: (Available in Redis 7.0 and later) Add the spec... | https://github.com/redis/redis-doc/blob/master/docs/management/security/acl.md | master | redis | [
-0.03623725101351738,
-0.027267811819911003,
-0.08343257755041122,
0.01267014630138874,
-0.03879769891500473,
-0.020788582041859627,
0.06464845687150955,
-0.0261596217751503,
0.03594008460640907,
0.012536115013062954,
-0.009731577709317207,
0.03192674368619919,
0.07436791807413101,
0.02345... | 0.043134 |
as that user.\* Configure selectors for the user: \* `()`: (Available in Redis 7.0 and later) Create a new selector to match rules against. Selectors are evaluated after the user permissions, and are evaluated according to the order they are defined. If a command matches either the user permissions or any selector, it ... | https://github.com/redis/redis-doc/blob/master/docs/management/security/acl.md | master | redis | [
-0.041695207357406616,
-0.03305346518754959,
-0.1117653176188469,
0.030648184940218925,
-0.06002170965075493,
-0.03329736739397049,
0.11695142090320587,
-0.06966456770896912,
-0.009526838548481464,
-0.02273392863571644,
0.013762340880930424,
0.01456967368721962,
0.06197543069720268,
0.0210... | 0.057791 |
NOPERM this user has no permissions to access one of the keys used as arguments > GET cached:1234 (nil) > SET cached:1234 zap (error) NOPERM this user has no permissions to run the 'set' command Things are working as expected. In order to inspect the configuration of the user alice (remember that user names are case se... | https://github.com/redis/redis-doc/blob/master/docs/management/security/acl.md | master | redis | [
0.0023136308882385492,
0.05210036411881447,
-0.1594035029411316,
-0.03130709379911423,
-0.09576855599880219,
-0.05127129331231117,
0.15272879600524902,
-0.030278563499450684,
-0.0029224357567727566,
-0.00903234165161848,
0.06379014253616333,
-0.031002158299088478,
0.0675654336810112,
-0.06... | 0.079436 |
command table. Modules may expose dangerous things and in the case of an ACL that is just additive, that is, in the form of `+@all -...` You should be absolutely sure that you'll never include what you did not mean to. The following is a list of command categories and their meanings: \* \*\*admin\*\* - Administrative c... | https://github.com/redis/redis-doc/blob/master/docs/management/security/acl.md | master | redis | [
-0.04766251519322395,
0.010171470232307911,
-0.09362371265888214,
0.0215839222073555,
-0.02351536601781845,
-0.04125365987420082,
0.04751383513212204,
0.0026437833439558744,
-0.04047536849975586,
0.03389161452651024,
0.09606283158063889,
-0.0679907500743866,
0.08130848407745361,
-0.0436084... | 0.101012 |
commands except DEBUG. In order to allow/block specific DEBUG subcommands, see the next section. ## Allow the first-arg of a blocked command \*\*Note: This feature is deprecated since Redis 7.0 and may be removed in the future.\*\* Sometimes the ability to exclude or include a command or a subcommand as a whole is not ... | https://github.com/redis/redis-doc/blob/master/docs/management/security/acl.md | master | redis | [
-0.06877024471759796,
0.005499407649040222,
-0.06512954831123352,
0.0665353462100029,
-0.003560529323294759,
-0.06349289417266846,
0.0928862914443016,
-0.018961558118462563,
-0.012991195544600487,
0.03459927812218666,
0.02576480433344841,
-0.08643506467342377,
0.041935812681913376,
-0.0287... | 0.016923 |
`+@all ~app1:\* (+@read ~app2:\*)`. This user has full access on `app1:\*` and readonly access on `app2:\*`. However, some commands support reading data from one key, doing some transformation, and storing it into another key. One such command is the `COPY` command, which copies the data from the source key into the de... | https://github.com/redis/redis-doc/blob/master/docs/management/security/acl.md | master | redis | [
-0.0801282748579979,
-0.0073227290995419025,
-0.07556919008493423,
-0.009334173984825611,
-0.0652286559343338,
-0.08451153337955475,
0.07431469112634659,
-0.0025708347093313932,
-0.01866333931684494,
0.0032172289211302996,
0.02713041566312313,
-0.05553549900650978,
0.09063880145549774,
0.0... | 0.013279 |
able to access the hashed password itself, by having full access to the Redis commands of a given server, or corrupting the system itself, you already have access to what the password is protecting: the Redis instance stability and the data it contains. For this reason, slowing down the password authentication, in orde... | https://github.com/redis/redis-doc/blob/master/docs/management/security/acl.md | master | redis | [
-0.05372361093759537,
-0.009161069989204407,
-0.15018324553966522,
-0.03212807700037956,
-0.03820464760065079,
-0.00046379672130569816,
0.011916639283299446,
0.014605097472667694,
0.00747534167021513,
-0.0012032614322379231,
-0.04817202314734459,
0.0760272815823555,
0.07670751959085464,
-0... | 0.009078 |
Pub/Sub, so the ACL rule would be the following (note: `AUTH` is not needed since it is always allowed): ACL SETUSER sentinel-user on >somepassword allchannels +multi +slaveof +ping +exec +subscribe +config|rewrite +role +publish +info +client|setname +client|kill +script|kill Redis replicas require the following comma... | https://github.com/redis/redis-doc/blob/master/docs/management/security/acl.md | master | redis | [
-0.06149233132600784,
-0.036566201597452164,
-0.1262132078409195,
-0.0071417405270040035,
-0.03261103108525276,
-0.01601443625986576,
0.01234686840325594,
-0.009703225456178188,
0.004372132010757923,
0.05828571319580078,
-0.050656795501708984,
-0.009014597162604332,
0.09655848145484924,
-0... | 0.060882 |
SSL/TLS is supported by Redis starting with version 6 as an optional feature that needs to be enabled at compile time. ## Getting Started ### Building To build with TLS support you'll need OpenSSL development libraries (e.g. `libssl-dev` on Debian/Ubuntu). Build Redis with the following command: ```sh make BUILD\_TLS=y... | https://github.com/redis/redis-doc/blob/master/docs/management/security/encryption.md | master | redis | [
-0.05177433788776398,
0.0065810708329081535,
-0.10496105253696442,
0.02113611437380314,
-0.04093208163976669,
-0.07976844906806946,
-0.04010918736457825,
0.002885035704821348,
0.03960636630654335,
-0.032045282423496246,
-0.0037303417921066284,
-0.07412280142307281,
0.06769073009490967,
0.0... | 0.01789 |
instance (for more information refer to this [discussion](https://github.com/redis/redis/issues/7595)). ### Limitations I/O threading is currently not supported with TLS. | https://github.com/redis/redis-doc/blob/master/docs/management/security/encryption.md | master | redis | [
-0.08977141976356506,
-0.0538630373775959,
-0.05055641755461693,
0.003983269911259413,
-0.03169380873441696,
-0.107783243060112,
-0.006778882350772619,
-0.04298558831214905,
0.06966615468263626,
-0.0005392199964262545,
-0.022066310048103333,
0.0096870893612504,
0.03394654393196106,
-0.0148... | 0.059125 |
This document provides an introduction to the topic of security from the point of view of Redis. It covers the access control provided by Redis, code security concerns, attacks that can be triggered from the outside by selecting malicious inputs, and other similar topics. You can learn more about access control, data p... | https://github.com/redis/redis-doc/blob/master/docs/management/security/_index.md | master | redis | [
-0.09146689623594284,
-0.014173556119203568,
-0.1112416610121727,
-0.003137943334877491,
-0.021672368049621582,
-0.07603855431079865,
0.10210814327001572,
0.034139715135097504,
0.028989331796765327,
-0.037509985268116,
-0.0335594080388546,
0.07843370735645294,
0.10200520604848862,
-0.08932... | 0.14013 |
6, is via Access Control Lists, allowing named users to be created and assigned fine-grained permissions. Read more about Access Control Lists [here](/docs/management/security/acl/). The legacy authentication method is enabled by editing the \*\*redis.conf\*\* file, and providing a database password using the `requirep... | https://github.com/redis/redis-doc/blob/master/docs/management/security/_index.md | master | redis | [
-0.05997956916689873,
-0.0378454327583313,
-0.14445695281028748,
0.014515051618218422,
-0.050094738602638245,
0.0014539865078404546,
0.05757343769073486,
0.014340017922222614,
0.032093293964862823,
-0.02939058095216751,
-0.03332410007715225,
0.07529950141906738,
0.09055176377296448,
-0.064... | 0.11685 |
the algorithm is not randomized, so it is possible to trigger a quadratic worst-case behavior by carefully selecting the right set of inputs. ## String escaping and NoSQL injection The Redis protocol has no concept of string escaping, so injection is impossible under normal circumstances using a normal client library. ... | https://github.com/redis/redis-doc/blob/master/docs/management/security/_index.md | master | redis | [
-0.06232402101159096,
-0.004653833340853453,
-0.10348823666572571,
0.03430981561541557,
-0.03181504085659981,
-0.08900460600852966,
0.010183014906942844,
0.04328244924545288,
0.029346855357289314,
-0.012592139653861523,
0.0032285491470247507,
0.052610017359256744,
0.08564238995313644,
-0.0... | 0.062098 |
## Filling the performance checklist Redis is developed with a great emphasis on performance. We do our best with every release to make sure you'll experience a very stable and fast product. Nevertheless, if you're finding room to improve the efficiency of Redis or are pursuing a performance regression investigation yo... | https://github.com/redis/redis-doc/blob/master/docs/management/optimization/cpu-profiling.md | master | redis | [
0.02391098253428936,
-0.049371615052223206,
-0.10474368929862976,
0.01097539160400629,
0.026313351467251778,
-0.10895761102437973,
0.04315240681171417,
0.04156871512532234,
-0.05091355741024017,
-0.04433676227927208,
-0.09927605092525482,
0.036269258707761765,
-0.02270907536149025,
-0.0429... | 0.109014 |
Brendan Greg’s [FlameGraph repo](https://github.com/brendangregg/FlameGraph). We assume beforehand you have: - Installed the perf tool on your system. Most Linux distributions will likely package this as a package related to the kernel. More information about the perf tool can be found at perf [wiki](https://perf.wiki.... | https://github.com/redis/redis-doc/blob/master/docs/management/optimization/cpu-profiling.md | master | redis | [
-0.059898894280195236,
-0.03381255269050598,
-0.11413922905921936,
0.016268286854028702,
0.08584237098693848,
-0.0997299998998642,
0.005046010948717594,
0.005530118942260742,
-0.025270383805036545,
-0.033139973878860474,
-0.028519244864583015,
-0.0648883730173111,
-0.04671580716967583,
-0.... | 0.141512 |
information using Flame Graphs ## Call counts analysis with bcc/BPF A function may consume significant CPU cycles either because its code is slow or because it's frequently called. To answer at what rate functions are being called, you can rely upon call counts analysis using BCC's `funccount` tool: $ /usr/share/bcc/to... | https://github.com/redis/redis-doc/blob/master/docs/management/optimization/cpu-profiling.md | master | redis | [
-0.026287691667675972,
-0.06517947465181351,
-0.07943487167358398,
0.07423491030931473,
-0.02807227149605751,
-0.12257760018110275,
0.05772438645362854,
-0.013872343115508556,
0.0790320485830307,
-0.0066156876273453236,
-0.06541704386472702,
0.00920389499515295,
-0.04659593850374222,
-0.08... | 0.120593 |
Redis is often used for demanding use cases, where it serves a large number of queries per second per instance, but also has strict latency requirements for the average response time and the worst-case latency. While Redis is an in-memory system, it deals with the operating system in different ways, for example, in the... | https://github.com/redis/redis-doc/blob/master/docs/management/optimization/latency-monitor.md | master | redis | [
-0.02869180403649807,
-0.06216854974627495,
-0.07972653210163116,
0.042981479316949844,
0.015198208391666412,
-0.11145898699760437,
0.03686601296067238,
-0.008698002435266972,
0.13114599883556366,
-0.0012144066859036684,
-0.008640145882964134,
0.031265247613191605,
0.004159992095082998,
-0... | 0.231107 |
the `write(2)` system call when there is a pending fsync. \* `aof-write-active-child`: the `write(2)` system call when there are active child processes. \* `aof-write-alone`: the `write(2)` system call when no pending fsync and no active child process. \* `aof-fstat`: the `fstat(2)` system call. \* `aof-rename`: the `r... | https://github.com/redis/redis-doc/blob/master/docs/management/optimization/latency-monitor.md | master | redis | [
-0.05628569796681404,
-0.030636576935648918,
-0.059081487357616425,
0.017726771533489227,
0.024892767891287804,
-0.14691662788391113,
0.009077473543584347,
0.034434281289577484,
0.10390486568212509,
0.0737195536494255,
0.05544918775558472,
0.05255233123898506,
-0.05928761139512062,
-0.0712... | 0.163645 |
This document will help you understand what the problem could be if you are experiencing latency problems with Redis. In this context \*latency\* is the maximum delay between the time a client issues a command and the time the reply to the command is received by the client. Usually Redis processing time is extremely lo... | https://github.com/redis/redis-doc/blob/master/docs/management/optimization/latency.md | master | redis | [
0.05827804282307625,
-0.03914603218436241,
-0.028490319848060608,
-0.011785028502345085,
0.008379833772778511,
-0.10537414252758026,
-0.058299269527196884,
0.008142661303281784,
0.06281331926584244,
0.013287175446748734,
-0.007156516425311565,
-0.03260345757007599,
-0.0023841504007577896,
... | 0.026025 |
and latency spikes. Latency baseline ---------------- There is a kind of latency that is inherently part of the environment where you run Redis, that is the latency provided by your operating system kernel and, if you are using virtualization, by the hypervisor you are using. While this latency can't be removed it is i... | https://github.com/redis/redis-doc/blob/master/docs/management/optimization/latency.md | master | redis | [
0.05100422725081444,
-0.0452270545065403,
-0.07409898936748505,
0.012404990382492542,
0.039189014583826065,
-0.1223493441939354,
0.001315436908043921,
0.0009037286508828402,
0.07864692807197571,
-0.043656472116708755,
0.009175078943371773,
-0.001065082848072052,
-0.013688226230442524,
-0.0... | 0.126725 |
caches, NUMA placement, etc ...). System induced latencies are significantly higher on a virtualized environment than on a physical machine. The consequence is even if Redis processes most commands in sub microsecond range, a client performing many roundtrips to the server will have to pay for these network and system ... | https://github.com/redis/redis-doc/blob/master/docs/management/optimization/latency.md | master | redis | [
0.021713271737098694,
-0.005050034262239933,
-0.07277349382638931,
0.014154979027807713,
-0.0927853062748909,
-0.09242931753396988,
-0.003204302629455924,
0.08184420317411423,
0.038181889802217484,
0.03865009546279907,
-0.027136778458952904,
0.0008362490334548056,
-0.028048094362020493,
-0... | 0.167904 |
like `SORT`, `LREM`, `SUNION` and others. For instance taking the intersection of two big sets can take a considerable amount of time. The algorithmic complexity of all commands is documented. A good practice is to systematically check it when using commands you are not familiar with. If you have latency concerns you s... | https://github.com/redis/redis-doc/blob/master/docs/management/optimization/latency.md | master | redis | [
0.03069913573563099,
-0.04356984794139862,
-0.07624350488185883,
0.02576379105448723,
-0.00003470064984867349,
-0.15713773667812347,
0.009040112607181072,
-0.015051130205392838,
0.03233687952160835,
0.031245149672031403,
-0.018384281545877457,
-0.014535253867506981,
0.0014838839415460825,
... | 0.151898 |
physical machine (Xeon @ 2.27Ghz)\*\* 6.9GB RSS forked into 62 milliseconds (9 milliseconds per GB). \* \*\*Linux VM on 6sync (KVM)\*\* 360 MB RSS forked in 8.2 milliseconds (23.3 milliseconds per GB). \* \*\*Linux VM on EC2, old instance types (Xen)\*\* 6.1GB RSS forked in 1460 milliseconds (239.3 milliseconds per GB)... | https://github.com/redis/redis-doc/blob/master/docs/management/optimization/latency.md | master | redis | [
0.08797893673181534,
-0.035334013402462006,
0.01496419869363308,
0.01526562962681055,
0.09033256024122238,
-0.08784604072570801,
-0.08326857537031174,
0.014482180587947369,
0.030377309769392014,
-0.026128636673092842,
0.013758007436990738,
-0.03278291970491409,
-0.01026985328644514,
-0.085... | 0.018572 |
to do is to checking the amount of Redis memory that is swapped on disk. In order to do so you need to obtain the Redis instance pid: $ redis-cli info | grep process\_id process\_id:5454 Now enter the /proc file system directory for this process: $ cd /proc/5454 Here you'll find a file called \*\*smaps\*\* that describ... | https://github.com/redis/redis-doc/blob/master/docs/management/optimization/latency.md | master | redis | [
-0.010201651602983475,
-0.028435591608285904,
-0.13553272187709808,
0.005975063424557447,
-0.025668395683169365,
-0.03978439047932625,
0.0430147722363472,
0.047242458909749985,
0.04387682303786278,
0.036801524460315704,
0.0013414372224360704,
0.061896003782749176,
0.03231177479028702,
-0.0... | 0.108558 |
is swapped so this is not going to create any problem at all. If instead a non trivial amount of the process memory is swapped on disk your latency problems are likely related to swapping. If this is the case with your Redis instance you can further verify it using the \*\*vmstat\*\* command: $ vmstat 1 procs ---------... | https://github.com/redis/redis-doc/blob/master/docs/management/optimization/latency.md | master | redis | [
0.0503888800740242,
-0.05759220942854881,
-0.11924335360527039,
0.036908820271492004,
-0.026511289179325104,
-0.1367635279893875,
0.028192972764372826,
0.050611045211553574,
0.006508192978799343,
-0.0009884765604510903,
0.0035990530159324408,
0.02156415767967701,
0.015994619578123093,
-0.0... | 0.075762 |
three different ways using the \*\*appendfsync\*\* configuration option (this setting can be modified at runtime using the \*\*CONFIG SET\*\* command). \* When appendfsync is set to the value of \*\*no\*\* Redis performs no fsync. In this configuration the only source of latency can be write(2). When this happens usual... | https://github.com/redis/redis-doc/blob/master/docs/management/optimization/latency.md | master | redis | [
0.0011770285200327635,
-0.05116705968976021,
-0.06522319465875626,
0.06774962693452835,
0.045683108270168304,
-0.13511556386947632,
-0.012348809279501438,
0.0023950105533003807,
0.10080352425575256,
0.03364057093858719,
0.0048752655275166035,
0.04469980672001839,
-0.01253882609307766,
-0.0... | 0.111909 |
is started every 100 milliseconds (10 times per second), and will do the following: + Sample `ACTIVE\_EXPIRE\_CYCLE\_LOOKUPS\_PER\_LOOP` keys, evicting all the keys already expired. + If the more than 25% of the keys were found expired, repeat. Given that `ACTIVE\_EXPIRE\_CYCLE\_LOOKUPS\_PER\_LOOP` is set to 20 by defa... | https://github.com/redis/redis-doc/blob/master/docs/management/optimization/latency.md | master | redis | [
-0.06576254218816757,
-0.031120363622903824,
-0.04935427010059357,
0.05590873211622238,
-0.0024829308968037367,
-0.11780674755573273,
0.032243721187114716,
-0.013985252939164639,
0.03764048591256142,
0.001410782104358077,
0.029561178758740425,
0.1080537810921669,
0.0488823838531971,
-0.126... | 0.084035 |
greater. The minimum configurable period is 200 milliseconds. When you are done with the software watchdog you can turn it off setting the `watchdog-period` parameter to 0. \*\*Important:\*\* remember to do this because keeping the instance with the watchdog turned on for a longer time than needed is generally not a go... | https://github.com/redis/redis-doc/blob/master/docs/management/optimization/latency.md | master | redis | [
0.006782262586057186,
-0.0421922393143177,
-0.05510624870657921,
-0.0022841321770101786,
0.04287963733077049,
0.03483262658119202,
-0.02435404434800148,
-0.010281148366630077,
0.0431051179766655,
-0.05072968080639839,
0.030204983428120613,
-0.015259576961398125,
0.01084358710795641,
-0.008... | 0.068857 |
## Special encoding of small aggregate data types Since Redis 2.2 many data types are optimized to use less space up to a certain size. Hashes, Lists, Sets composed of just integers, and Sorted Sets, when smaller than a given number of elements, and up to a maximum element size, are encoded in a very memory-efficient w... | https://github.com/redis/redis-doc/blob/master/docs/management/optimization/memory-optimization.md | master | redis | [
0.015041328966617584,
-0.0016275588423013687,
-0.08555196225643158,
0.03233930096030235,
-0.014876454137265682,
-0.07778850942850113,
0.005275425501167774,
0.03743646293878555,
0.019230958074331284,
0.012200091034173965,
-0.05585097521543503,
0.07156628370285034,
0.04951564595103264,
-0.03... | 0.081208 |
this is about. Basically it is possible to model a plain key-value store using Redis where values can just be just strings, which is not just more memory efficient than Redis plain keys but also much more memory efficient than memcached. Let's start with some facts: a few keys use a lot more memory than a single key co... | https://github.com/redis/redis-doc/blob/master/docs/management/optimization/memory-optimization.md | master | redis | [
-0.016457075253129005,
0.02906261757016182,
-0.07252363115549088,
0.010044634342193604,
-0.01391651201993227,
-0.10722732543945312,
-0.002768590347841382,
0.07263089716434479,
0.12694045901298523,
0.022395888343453407,
-0.012333478778600693,
0.10473458468914032,
0.04484964534640312,
-0.111... | 0.071863 |
schema every hash will have more or less 100 fields regardless of the number of objects we cached. This is because our objects will always end with a number and not a random string. In some way, the final number can be considered as a form of implicit pre-sharding. What about small numbers? Like object:2? We handle thi... | https://github.com/redis/redis-doc/blob/master/docs/management/optimization/memory-optimization.md | master | redis | [
0.06539331376552582,
0.03614451363682747,
-0.07742398977279663,
0.0044694277457892895,
-0.045860808342695236,
-0.05143364891409874,
0.008069374598562717,
0.008531785570085049,
0.045752596110105515,
0.021022282540798187,
-0.04094112664461136,
0.10778609663248062,
0.023306353017687798,
-0.07... | 0.035979 |
of data, the Resident Set Size (also known as the RSS, which is the number of memory pages consumed by the process) will probably still be around 5GB, even if Redis will claim that the user memory is around 3GB. This happens because the underlying allocator can't easily release the memory. For example, often most of th... | https://github.com/redis/redis-doc/blob/master/docs/management/optimization/memory-optimization.md | master | redis | [
-0.012581750750541687,
-0.05762961134314537,
-0.07785677164793015,
0.035809922963380814,
0.03515045344829559,
-0.01893058978021145,
0.045749321579933167,
0.042140599340200424,
-0.0017224992625415325,
0.07251480221748352,
0.056900009512901306,
0.06776249408721924,
0.03384796902537346,
-0.06... | 0.122428 |
Redis includes the `redis-benchmark` utility that simulates running commands done by N clients while at the same time sending M total queries. The utility provides a default set of tests, or you can supply a custom set of tests. The following options are supported: Usage: redis-benchmark [-h ] [-p ] [-c ] [-n [-k ] -h ... | https://github.com/redis/redis-doc/blob/master/docs/management/optimization/benchmarks/index.md | master | redis | [
-0.0164323803037405,
-0.07326903194189072,
-0.11230071634054184,
0.09683854132890701,
-0.08927213400602341,
-0.13331373035907745,
-0.01275893859565258,
0.002461867406964302,
-0.00470005813986063,
0.03211214393377304,
-0.052715010941028595,
0.003426606534048915,
0.05508347228169441,
-0.0848... | 0.114505 |
read each command from every client. Also RTT is paid as well. Redis supports [pipelining](/topics/pipelining), so it is possible to send multiple commands at once, a feature often exploited by real world applications. Redis pipelining is able to dramatically improve the number of operations per second a server is able... | https://github.com/redis/redis-doc/blob/master/docs/management/optimization/benchmarks/index.md | master | redis | [
-0.037688955664634705,
-0.027097424492239952,
-0.0676177442073822,
0.04145728051662445,
-0.02497059665620327,
-0.11329109966754913,
-0.025920070707798004,
0.08188793808221817,
0.05188450589776039,
0.014352760277688503,
-0.07657693326473236,
0.029083728790283203,
-0.0144280344247818,
-0.015... | 0.129001 |
behavior since a lot of Redis based applications actively use pipelining to improve performance. However you should use a pipeline size that is more or less the average pipeline length you'll be able to use in your application in order to get realistic numbers. The benchmark should apply the same operations, and work i... | https://github.com/redis/redis-doc/blob/master/docs/management/optimization/benchmarks/index.md | master | redis | [
-0.01748136430978775,
-0.026491744443774223,
-0.06954362988471985,
0.02039884403347969,
-0.08713790029287338,
-0.13797372579574585,
-0.05573960393667221,
0.08095566183328629,
0.040688250213861465,
-0.04265645518898964,
-0.07183397561311722,
0.042497433722019196,
-0.000915228680241853,
-0.0... | 0.065227 |
of the serious performance issues you may incur in virtualized environments are due to over-provisioning, non-local disks with high latency, or old hypervisor software that have slow `fork` syscall implementation. + When the server and client benchmark programs run on the same box, both the TCP/IP loopback and unix dom... | https://github.com/redis/redis-doc/blob/master/docs/management/optimization/benchmarks/index.md | master | redis | [
0.024088812991976738,
-0.01649969257414341,
-0.04347718507051468,
-0.011389323510229588,
-0.038513846695423126,
-0.09579432755708694,
-0.048979438841342926,
0.041826166212558746,
0.05428966507315636,
0.004722456447780132,
-0.05409282073378563,
0.05975699424743652,
-0.012089837342500687,
-0... | 0.047246 |
it is not possible, then the system must be monitored to check the benchmark is not impacted by some external activity. + Some configurations (desktops and laptops for sure, some servers as well) have a variable CPU core frequency mechanism. The policy controlling this mechanism can be set at the OS level. Some CPU mod... | https://github.com/redis/redis-doc/blob/master/docs/management/optimization/benchmarks/index.md | master | redis | [
0.05353425815701485,
-0.04343681409955025,
-0.13412901759147644,
0.035148799419403076,
-0.027967918664216995,
-0.08461734652519226,
-0.044266194105148315,
0.016607247292995453,
-0.01910616084933281,
0.02801624871790409,
-0.054586004465818405,
0.023320110514760017,
0.04838602989912033,
-0.0... | 0.073395 |
\* Redis is source-available software, available under the terms of the RSALv2 and SSPLv1 licenses. Most of the Redis source code was written and is copyrighted by Salvatore Sanfilippo and Pieter Noordhuis. A list of other contributors can be found in the git history. The Redis trademark and logo are owned by Redis Ltd... | https://github.com/redis/redis-doc/blob/master/docs/about/license.md | master | redis | [
-0.07641635090112686,
-0.11186637729406357,
-0.12548936903476715,
-0.011453744024038315,
-0.01614934392273426,
-0.04552173614501953,
-0.04405491426587105,
0.029709527269005775,
0.08013106137514114,
-0.07584989070892334,
-0.034457460045814514,
0.0800493136048317,
0.020293572917580605,
-0.03... | 0.218949 |
is not licensed, and your licenses will automatically terminate. If the licensor provides you with a notice of your violation, and you cease all violations of this license no later than 30 days after you receive that notice, your licenses will be reinstated retroactively. However, if you violate these terms after such ... | https://github.com/redis/redis-doc/blob/master/docs/about/license.md | master | redis | [
-0.09776102751493454,
-0.0018868254264816642,
0.0341997854411602,
-0.07628294080495834,
0.03901771456003189,
0.028078939765691757,
0.05439592897891998,
-0.07123644649982452,
0.03692205250263214,
-0.0030307548586279154,
0.05226748809218407,
0.07876342535018921,
0.003990605007857084,
-0.0526... | 0.142118 |
Redis is system software and a type of system software that holds user data, so it is among the most critical pieces of a software stack. For this reason, Redis' release cycle is such that it ensures highly-stable releases, even at the cost of slower cycles. New releases are published in the [Redis GitHub repository](h... | https://github.com/redis/redis-doc/blob/master/docs/about/releases.md | master | redis | [
-0.03562484309077263,
-0.08590780943632126,
-0.04790696129202843,
0.0017328397370874882,
0.05996817350387573,
-0.0993872657418251,
-0.02954472042620182,
0.035480815917253494,
0.03549429774284363,
0.02226368337869644,
-0.024958645924925804,
0.0950363427400589,
0.018613265827298164,
-0.09946... | 0.171617 |
is planned for release once a year. Generally, every major release is followed by a minor version after six months. Patches are released as needed to fix high-urgency issues, or once a stable version accumulates enough fixes to justify it. For contacting the core team on sensitive matters and security issues, please em... | https://github.com/redis/redis-doc/blob/master/docs/about/releases.md | master | redis | [
-0.022807899862527847,
-0.057672929018735886,
-0.011967398226261139,
-0.02754763700067997,
0.028805742040276527,
-0.06039419397711754,
-0.07577094435691833,
0.020939284935593605,
-0.012777733616530895,
0.0010537647176533937,
-0.00017874367767944932,
0.09516642987728119,
-0.006672240328043699... | 0.100482 |
A list of well known companies using Redis: \* [Twitter](https://www.infoq.com/presentations/Real-Time-Delivery-Twitter) \* [GitHub](https://github.com/blog/530-how-we-made-github-fast) \* [Snapchat](https://twitter.com/robustcloud/status/448503100056535040) \* [Craigslist](https://blog.zawodny.com/2011/02/26/redis-sha... | https://github.com/redis/redis-doc/blob/master/docs/about/users.md | master | redis | [
-0.11019675433635712,
-0.10498720407485962,
-0.05866529792547226,
0.007397256325930357,
0.03252458572387695,
-0.10207215696573257,
0.02967131696641445,
-0.04855713993310928,
0.006343083456158638,
-0.028096212074160576,
0.02496926486492157,
0.06462240219116211,
0.06991396099328995,
-0.00915... | 0.162344 |
Redis is an open source (BSD licensed), in-memory \_\_data structure store\_\_ used as a database, cache, message broker, and streaming engine. > Future releases of Redis will be dual-licensed under a source-available license. You can choose between the [Redis Source Available License 2.0 (RSALv2)](/docs/about/license)... | https://github.com/redis/redis-doc/blob/master/docs/about/_index.md | master | redis | [
-0.02478569932281971,
-0.04816431552171707,
-0.11625070124864578,
-0.011849666945636272,
-0.013608381152153015,
-0.07368291169404984,
0.0002817763015627861,
0.017734207212924957,
0.014841080643236637,
-0.001615958521142602,
-0.03274523466825485,
0.08009808510541916,
0.04260377958416939,
-0... | 0.147605 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.