പതിപ്പ് 5.0-ൽ റെഡ്ഡിസിൽ അവതരിപ്പിച്ച പുതിയ അമൂർത്ത ഡാറ്റാ തരമാണ് റെഡിസ് സ്ട്രീം
ആശയപരമായി, നിങ്ങൾക്ക് എൻട്രികൾ ചേർക്കാൻ കഴിയുന്ന ഒരു ലിസ്റ്റാണ് റെഡിസ് സ്ട്രീം. ഓരോ എൻട്രിക്കും ഒരു അദ്വിതീയ ഐഡന്റിഫയർ ഉണ്ട്. ഡിഫോൾട്ടായി, ഐഡി സ്വയമേവ ജനറേറ്റ് ചെയ്യപ്പെടുകയും ഒരു ടൈംസ്റ്റാമ്പ് ഉൾക്കൊള്ളുകയും ചെയ്യുന്നു. അതിനാൽ, യുണിക്സ് "ടെയിൽ -എഫ്" കമാൻഡ് ഒരു ലോഗ് ഫയൽ വായിക്കുകയും പുതിയ ഡാറ്റയ്ക്കായി കാത്തിരിക്കുമ്പോൾ ഫ്രീസുചെയ്യുകയും ചെയ്യുന്നതുപോലെ, നിങ്ങൾക്ക് കാലക്രമേണ റെക്കോർഡുകളുടെ ശ്രേണികൾ അന്വേഷിക്കാനോ സ്ട്രീമിൽ എത്തുമ്പോൾ പുതിയ ഡാറ്റ സ്വീകരിക്കാനോ കഴിയും. ഒന്നിലധികം ക്ലയന്റുകൾക്ക് ഒരേ സമയം ഒരു ത്രെഡ് കേൾക്കാൻ കഴിയുമെന്നത് ശ്രദ്ധിക്കുക, പല "ടെയിൽ -എഫ്" പ്രക്രിയകൾക്കും പരസ്പരം വൈരുദ്ധ്യമില്ലാതെ ഒരേസമയം ഒരു ഫയൽ വായിക്കാൻ കഴിയും.

പുതിയ ഡാറ്റാ തരത്തിന്റെ എല്ലാ നേട്ടങ്ങളും മനസിലാക്കാൻ, Redis സ്ട്രീമിന്റെ പ്രവർത്തനക്ഷമത ഭാഗികമായി ആവർത്തിക്കുന്ന ദീർഘകാലമായി നിലനിൽക്കുന്ന Redis ഘടനകൾ നമുക്ക് പെട്ടെന്ന് നോക്കാം.

Redis PUB/SUB

Redis Pub/Sub എന്നത് നിങ്ങളുടെ കീ-വാല്യൂ സ്റ്റോറിൽ ഇതിനകം നിർമ്മിച്ച ഒരു ലളിതമായ സന്ദേശമയയ്‌ക്കൽ സംവിധാനമാണ്. എന്നിരുന്നാലും, ലാളിത്യം ഒരു ചെലവിൽ വരുന്നു:

• ചില കാരണങ്ങളാൽ പ്രസാധകൻ പരാജയപ്പെടുകയാണെങ്കിൽ, അയാൾക്ക് അവന്റെ എല്ലാ വരിക്കാരെയും നഷ്ടപ്പെടും
• പ്രസാധകന് അതിന്റെ എല്ലാ വരിക്കാരുടെയും കൃത്യമായ വിലാസം അറിയേണ്ടതുണ്ട്
• ഡാറ്റ പ്രോസസ്സ് ചെയ്യുന്നതിനേക്കാൾ വേഗത്തിൽ പ്രസിദ്ധീകരിക്കുകയാണെങ്കിൽ, ഒരു പ്രസാധകൻ അതിന്റെ വരിക്കാരെ വർക്ക് ഉപയോഗിച്ച് ഓവർലോഡ് ചെയ്തേക്കാം
• എത്ര സബ്‌സ്‌ക്രൈബർമാർക്ക് ഡെലിവർ ചെയ്‌തു എന്നതും എത്ര വേഗത്തിൽ ഈ സന്ദേശം പ്രോസസ്സ് ചെയ്യാൻ അവർക്ക് കഴിഞ്ഞു എന്നതും പരിഗണിക്കാതെ, പ്രസിദ്ധീകരണത്തിന് ശേഷം ഉടൻ തന്നെ പ്രസാധകന്റെ ബഫറിൽ നിന്ന് സന്ദേശം ഇല്ലാതാക്കപ്പെടും.
• എല്ലാ വരിക്കാർക്കും ഒരേ സമയം സന്ദേശം ലഭിക്കും. ഒരേ സന്ദേശം പ്രോസസ്സ് ചെയ്യുന്ന ക്രമത്തിൽ സബ്‌സ്‌ക്രൈബർമാർ തന്നെ എങ്ങനെയെങ്കിലും പരസ്പരം സമ്മതിക്കണം.
• ഒരു സബ്‌സ്‌ക്രൈബർ ഒരു സന്ദേശം വിജയകരമായി പ്രോസസ്സ് ചെയ്തുവെന്ന് സ്ഥിരീകരിക്കാൻ ബിൽറ്റ്-ഇൻ മെക്കാനിസമൊന്നുമില്ല. ഒരു വരിക്കാരന് ഒരു സന്ദേശം ലഭിക്കുകയും പ്രോസസ്സിംഗ് സമയത്ത് ക്രാഷ് ചെയ്യുകയും ചെയ്താൽ, പ്രസാധകൻ അതിനെക്കുറിച്ച് അറിയുകയില്ല.

റെഡിസ് ലിസ്റ്റ്

റീഡ് കമാൻഡുകൾ തടയുന്നതിനെ പിന്തുണയ്ക്കുന്ന ഒരു ഡാറ്റാ ഘടനയാണ് റെഡിസ് ലിസ്റ്റ്. നിങ്ങൾക്ക് പട്ടികയുടെ തുടക്കത്തിലോ അവസാനത്തിലോ സന്ദേശങ്ങൾ ചേർക്കാനും വായിക്കാനും കഴിയും. ഈ ഘടനയെ അടിസ്ഥാനമാക്കി, നിങ്ങളുടെ വിതരണം ചെയ്ത സിസ്റ്റത്തിനായി നിങ്ങൾക്ക് ഒരു നല്ല സ്റ്റാക്ക് അല്ലെങ്കിൽ ക്യൂ ഉണ്ടാക്കാം, മിക്ക കേസുകളിലും ഇത് മതിയാകും. Redis Pub/Sub-ൽ നിന്നുള്ള പ്രധാന വ്യത്യാസങ്ങൾ:

• ഒരു ഉപഭോക്താവിന് സന്ദേശം കൈമാറുന്നു. ആദ്യം റീഡ്-ബ്ലോക്ക് ചെയ്ത ക്ലയന്റിന് ആദ്യം ഡാറ്റ ലഭിക്കും.
• ഓരോ സന്ദേശത്തിനും ക്ലിന്റ് തന്നെ വായന പ്രവർത്തനം ആരംഭിക്കണം. ലിസ്റ്റിന് ക്ലയന്റുകളെക്കുറിച്ച് ഒന്നും അറിയില്ല.
• സന്ദേശങ്ങൾ ആരെങ്കിലും വായിക്കുകയോ അല്ലെങ്കിൽ വ്യക്തമായി ഇല്ലാതാക്കുകയോ ചെയ്യുന്നതുവരെ സൂക്ഷിക്കുന്നു. ഡിസ്കിലേക്ക് ഡാറ്റ ഫ്ലഷ് ചെയ്യുന്നതിന് നിങ്ങൾ Redis സെർവർ കോൺഫിഗർ ചെയ്യുകയാണെങ്കിൽ, സിസ്റ്റത്തിന്റെ വിശ്വാസ്യത ഗണ്യമായി വർദ്ധിക്കുന്നു.

സ്ട്രീമിലേക്കുള്ള ആമുഖം

ഒരു സ്ട്രീമിലേക്ക് ഒരു എൻട്രി ചേർക്കുന്നു

ടീം XADD സ്ട്രീമിലേക്ക് ഒരു പുതിയ എൻട്രി ചേർക്കുന്നു. ഒരു റെക്കോർഡ് ഒരു സ്ട്രിംഗ് മാത്രമല്ല, അതിൽ ഒന്നോ അതിലധികമോ കീ-മൂല്യം ജോഡികൾ അടങ്ങിയിരിക്കുന്നു. അങ്ങനെ, ഓരോ എൻട്രിയും ഇതിനകം ഘടനാപരമായതും ഒരു CSV ഫയലിന്റെ ഘടനയോട് സാമ്യമുള്ളതുമാണ്.

> XADD mystream * sensor-id 1234 temperature 19.8
1518951480106-0

മുകളിലുള്ള ഉദാഹരണത്തിൽ, "മൈസ്ട്രീം" എന്ന പേരിൽ (കീ) രണ്ട് ഫീൽഡുകൾ ഞങ്ങൾ സ്ട്രീമിലേക്ക് ചേർക്കുന്നു: യഥാക്രമം "1234", "19.8" എന്നീ മൂല്യങ്ങളുള്ള "സെൻസർ-ഐഡി", "താപനില". രണ്ടാമത്തെ ആർഗ്യുമെന്റ് എന്ന നിലയിൽ, എൻട്രിയിലേക്ക് അസൈൻ ചെയ്യപ്പെടുന്ന ഒരു ഐഡന്റിഫയർ കമാൻഡ് എടുക്കുന്നു - ഈ ഐഡന്റിഫയർ സ്ട്രീമിലെ ഓരോ എൻട്രിയും അദ്വിതീയമായി തിരിച്ചറിയുന്നു. എന്നിരുന്നാലും, ഈ സാഹചര്യത്തിൽ ഞങ്ങൾ പാസ്സായി * കാരണം ഞങ്ങൾക്കായി Redis ഒരു പുതിയ ഐഡി ജനറേറ്റ് ചെയ്യണമെന്ന് ഞങ്ങൾ ആഗ്രഹിക്കുന്നു. ഓരോ പുതിയ ഐഡിയും വർദ്ധിക്കും. അതിനാൽ, ഓരോ പുതിയ എൻട്രിയിലും മുമ്പത്തെ എൻട്രികളുമായി ബന്ധപ്പെട്ട് ഉയർന്ന ഐഡന്റിഫയർ ഉണ്ടായിരിക്കും.

ഐഡന്റിഫയർ ഫോർമാറ്റ്

കമാൻഡ് വഴി എൻട്രി ഐഡി തിരികെ നൽകി XADD, രണ്ട് ഭാഗങ്ങൾ ഉൾക്കൊള്ളുന്നു:

{millisecondsTime}-{sequenceNumber}

മില്ലിസെക്കൻഡ് സമയം — Unix സമയം മില്ലിസെക്കൻഡിൽ (റെഡിസ് സെർവർ സമയം). എന്നിരുന്നാലും, നിലവിലെ സമയം മുമ്പത്തെ റെക്കോർഡിംഗിന്റെ സമയത്തിന് തുല്യമോ കുറവോ ആണെങ്കിൽ, മുമ്പത്തെ റെക്കോർഡിംഗിന്റെ ടൈംസ്റ്റാമ്പ് ഉപയോഗിക്കുന്നു. അതിനാൽ, സെർവർ സമയം കൃത്യസമയത്ത് പോയാൽ, പുതിയ ഐഡന്റിഫയർ ഇപ്പോഴും ഇൻക്രിമെന്റ് പ്രോപ്പർട്ടി നിലനിർത്തും.

ക്രമസംഖ്യ ഒരേ മില്ലിസെക്കൻഡിൽ സൃഷ്ടിച്ച റെക്കോർഡുകൾക്കായി ഉപയോഗിക്കുന്നു. ക്രമസംഖ്യ മുമ്പത്തെ എൻട്രിയുമായി താരതമ്യപ്പെടുത്തുമ്പോൾ 1 വർദ്ധിപ്പിക്കും. എന്തുകൊണ്ടെന്നാല് ക്രമസംഖ്യ 64 ബിറ്റുകൾ വലുപ്പമുള്ളതാണ്, പിന്നെ പ്രായോഗികമായി ഒരു മില്ലിസെക്കൻഡിനുള്ളിൽ സൃഷ്ടിക്കാൻ കഴിയുന്ന റെക്കോർഡുകളുടെ എണ്ണത്തിൽ നിങ്ങൾ ഒരു പരിധിയിലേക്ക് കടക്കരുത്.

അത്തരം ഐഡന്റിഫയറുകളുടെ ഫോർമാറ്റ് ഒറ്റനോട്ടത്തിൽ വിചിത്രമായി തോന്നിയേക്കാം. സമയം ഐഡന്റിഫയറിന്റെ ഭാഗമാകുന്നത് എന്തുകൊണ്ടാണെന്ന് അവിശ്വാസിയായ ഒരു വായനക്കാരൻ ചിന്തിച്ചേക്കാം. കാരണം, റെഡിസ് സ്ട്രീമുകൾ ഐഡി പ്രകാരം ശ്രേണി അന്വേഷണങ്ങളെ പിന്തുണയ്ക്കുന്നു. റെക്കോർഡ് സൃഷ്‌ടിച്ച സമയവുമായി ഐഡന്റിഫയർ ബന്ധപ്പെട്ടിരിക്കുന്നതിനാൽ, ഇത് സമയ ശ്രേണികൾ അന്വേഷിക്കുന്നത് സാധ്യമാക്കുന്നു. ഞങ്ങൾ കമാൻഡ് നോക്കുമ്പോൾ ഒരു പ്രത്യേക ഉദാഹരണം നോക്കാം XRANGE.

ചില കാരണങ്ങളാൽ ഉപയോക്താവിന് സ്വന്തം ഐഡന്റിഫയർ വ്യക്തമാക്കേണ്ടതുണ്ടെങ്കിൽ, ഉദാഹരണത്തിന്, ചില ബാഹ്യ സിസ്റ്റവുമായി ബന്ധപ്പെട്ടിരിക്കുന്നു, നമുക്ക് അത് കമാൻഡിലേക്ക് കൈമാറാം. XADD താഴെ കാണിച്ചിരിക്കുന്നതുപോലെ * എന്നതിന് പകരം:

> XADD somestream 0-1 field value
0-1
> XADD somestream 0-2 foo bar
0-2

ഈ സാഹചര്യത്തിൽ നിങ്ങൾ ഐഡി ഇൻക്രിമെന്റ് സ്വയം നിരീക്ഷിക്കേണ്ടതുണ്ടെന്ന കാര്യം ശ്രദ്ധിക്കുക. ഞങ്ങളുടെ ഉദാഹരണത്തിൽ, ഏറ്റവും കുറഞ്ഞ ഐഡന്റിഫയർ "0-1" ആണ്, അതിനാൽ "0-1" ന് തുല്യമോ അതിൽ കുറവോ ആയ മറ്റൊരു ഐഡന്റിഫയർ കമാൻഡ് സ്വീകരിക്കില്ല.

> XADD somestream 0-1 foo bar
(error) ERR The ID specified in XADD is equal or smaller than the target stream top item

ഓരോ സ്ട്രീമിനും റെക്കോർഡുകളുടെ എണ്ണം

കമാൻഡ് ഉപയോഗിച്ച് ഒരു സ്ട്രീമിലെ റെക്കോർഡുകളുടെ എണ്ണം നേടാനാകും XLEN. ഞങ്ങളുടെ ഉദാഹരണത്തിനായി, ഈ കമാൻഡ് ഇനിപ്പറയുന്ന മൂല്യം നൽകും:

> XLEN somestream
(integer) 2

ശ്രേണി അന്വേഷണങ്ങൾ - XRANGE, XREVRANGE

ശ്രേണി അനുസരിച്ച് ഡാറ്റ അഭ്യർത്ഥിക്കാൻ, ഞങ്ങൾ രണ്ട് ഐഡന്റിഫയറുകൾ വ്യക്തമാക്കേണ്ടതുണ്ട് - ശ്രേണിയുടെ തുടക്കവും അവസാനവും. തിരിച്ചയച്ച ശ്രേണിയിൽ അതിരുകൾ ഉൾപ്പെടെ എല്ലാ ഘടകങ്ങളും ഉൾപ്പെടും. സ്ട്രീമിലെ ഏറ്റവും ചെറിയ (ആദ്യ റെക്കോർഡ്), ഏറ്റവും വലിയ (അവസാന റെക്കോർഡ്) ഐഡന്റിഫയർ എന്നർത്ഥം വരുന്ന യഥാക്രമം “-”, “+” എന്നീ രണ്ട് പ്രത്യേക ഐഡന്റിഫയറുകളും ഉണ്ട്. ചുവടെയുള്ള ഉദാഹരണം എല്ലാ സ്ട്രീം എൻട്രികളും ലിസ്റ്റ് ചെയ്യും.

> XRANGE mystream - +
1) 1) 1518951480106-0
   2) 1) "sensor-id"
      2) "1234"
      3) "temperature"
      4) "19.8"
2) 1) 1518951482479-0
   2) 1) "sensor-id"
      2) "9999"
      3) "temperature"
      4) "18.2"

ഓരോ റിട്ടേൺ റെക്കോർഡും രണ്ട് ഘടകങ്ങളുടെ ഒരു ശ്രേണിയാണ്: ഒരു ഐഡന്റിഫയറും കീ-വാല്യൂ ജോഡികളുടെ പട്ടികയും. റെക്കോർഡ് ഐഡന്റിഫയറുകൾ സമയവുമായി ബന്ധപ്പെട്ടതാണെന്ന് ഞങ്ങൾ ഇതിനകം പറഞ്ഞു. അതിനാൽ, ഞങ്ങൾക്ക് ഒരു നിശ്ചിത സമയ പരിധി അഭ്യർത്ഥിക്കാം. എന്നിരുന്നാലും, ഞങ്ങൾക്ക് അഭ്യർത്ഥനയിൽ പൂർണ്ണ ഐഡന്റിഫയർ അല്ല, യുണിക്സ് സമയം മാത്രമേ വ്യക്തമാക്കാൻ കഴിയൂ, ഇതുമായി ബന്ധപ്പെട്ട ഭാഗം ഒഴിവാക്കി ക്രമസംഖ്യ. ഐഡന്റിഫയറിന്റെ ഒഴിവാക്കിയ ഭാഗം സ്വയമേവ ശ്രേണിയുടെ തുടക്കത്തിൽ പൂജ്യമായും ശ്രേണിയുടെ അവസാനത്തിൽ സാധ്യമായ പരമാവധി മൂല്യമായും സജ്ജീകരിക്കും. രണ്ട് മില്ലിസെക്കൻഡ് പരിധി നിങ്ങൾക്ക് എങ്ങനെ അഭ്യർത്ഥിക്കാം എന്നതിന്റെ ഒരു ഉദാഹരണം ചുവടെയുണ്ട്.

> XRANGE mystream 1518951480106 1518951480107
1) 1) 1518951480106-0
   2) 1) "sensor-id"
      2) "1234"
      3) "temperature"
      4) "19.8"

ഈ ശ്രേണിയിൽ ഞങ്ങൾക്ക് ഒരു എൻട്രി മാത്രമേയുള്ളൂ, എന്നിരുന്നാലും യഥാർത്ഥ ഡാറ്റ സെറ്റുകളിൽ നൽകിയ ഫലം വളരെ വലുതായിരിക്കും. ഇക്കാരണത്താൽ XRANGE COUNT ഓപ്ഷൻ പിന്തുണയ്ക്കുന്നു. അളവ് വ്യക്തമാക്കുന്നതിലൂടെ, നമുക്ക് ആദ്യത്തെ N റെക്കോർഡുകൾ ലഭിക്കും. അടുത്ത N രേഖകൾ (പാജിനേഷൻ) ലഭിക്കണമെങ്കിൽ, അവസാനം ലഭിച്ച ഐഡി ഉപയോഗിക്കാം, അത് വർദ്ധിപ്പിക്കുക ക്രമസംഖ്യ ഒന്നു കൊണ്ട് വീണ്ടും ചോദിക്കുക. ഇനിപ്പറയുന്ന ഉദാഹരണത്തിൽ ഇത് നോക്കാം. ഞങ്ങൾ 10 ഘടകങ്ങൾ ചേർക്കാൻ തുടങ്ങുന്നു XADD (മൈസ്ട്രീം ഇതിനകം 10 ഘടകങ്ങൾ കൊണ്ട് നിറഞ്ഞിരുന്നുവെന്ന് കരുതുക). ഓരോ കമാൻഡിനും 2 ഘടകങ്ങൾ ലഭിക്കുന്ന ആവർത്തനം ആരംഭിക്കുന്നതിന്, ഞങ്ങൾ പൂർണ്ണ ശ്രേണിയിൽ ആരംഭിക്കുന്നു, എന്നാൽ 2 ന് തുല്യമായ COUNT ഉപയോഗിച്ച്.

> XRANGE mystream - + COUNT 2
1) 1) 1519073278252-0
   2) 1) "foo"
      2) "value_1"
2) 1) 1519073279157-0
   2) 1) "foo"
      2) "value_2"

അടുത്ത രണ്ട് ഘടകങ്ങൾ ഉപയോഗിച്ച് ആവർത്തിക്കുന്നത് തുടരാൻ, ഞങ്ങൾക്ക് ലഭിച്ച അവസാന ഐഡി തിരഞ്ഞെടുക്കേണ്ടതുണ്ട്, അതായത് 1519073279157-0, കൂടാതെ ഇതിലേക്ക് 1 ചേർക്കുക ക്രമസംഖ്യ.
തത്ഫലമായുണ്ടാകുന്ന ഐഡി, ഈ സാഹചര്യത്തിൽ 1519073279157-1, അടുത്ത കോളിനുള്ള റേഞ്ച് ആർഗ്യുമെന്റിന്റെ പുതിയ തുടക്കമായി ഇപ്പോൾ ഉപയോഗിക്കാം XRANGE:

> XRANGE mystream 1519073279157-1 + COUNT 2
1) 1) 1519073280281-0
   2) 1) "foo"
      2) "value_3"
2) 1) 1519073281432-0
   2) 1) "foo"
      2) "value_4"

ഇത്യാദി. കാരണം സങ്കീർണ്ണത XRANGE തിരയാൻ O(log(N)) ആണ്, തുടർന്ന് M ഘടകങ്ങൾ നൽകുന്നതിന് O(M), തുടർന്ന് ഓരോ ആവർത്തന ഘട്ടവും വേഗതയുള്ളതാണ്. അങ്ങനെ, ഉപയോഗിക്കുന്നത് XRANGE സ്ട്രീമുകൾ കാര്യക്ഷമമായി ആവർത്തിക്കാം.

ടീം XREVRANGE തുല്യമാണ് XRANGE, എന്നാൽ ഘടകങ്ങൾ വിപരീത ക്രമത്തിൽ നൽകുന്നു:

> XREVRANGE mystream + - COUNT 1
1) 1) 1519073287312-0
   2) 1) "foo"
      2) "value_10"

കമാൻഡ് എന്നത് ദയവായി ശ്രദ്ധിക്കുക XREVRANGE ശ്രേണി ആർഗ്യുമെന്റുകൾ റിവേഴ്സ് ഓർഡറിൽ ആരംഭിക്കുകയും നിർത്തുകയും ചെയ്യുന്നു.

XREAD ഉപയോഗിച്ച് പുതിയ എൻട്രികൾ വായിക്കുന്നു

ഒരു സ്ട്രീമിലേക്ക് സബ്‌സ്‌ക്രൈബുചെയ്യുകയും പുതിയ സന്ദേശങ്ങൾ മാത്രം സ്വീകരിക്കുകയും ചെയ്യുക എന്നതാണ് പലപ്പോഴും ചുമതല. ഈ ആശയം Redis Pub/Sub അല്ലെങ്കിൽ Redis List ബ്ലോക്ക് ചെയ്യുന്നതുമായി സാമ്യമുള്ളതായി തോന്നിയേക്കാം, എന്നാൽ Redis സ്ട്രീം എങ്ങനെ ഉപയോഗിക്കണമെന്നതിൽ അടിസ്ഥാനപരമായ വ്യത്യാസങ്ങളുണ്ട്:

1. ഓരോ പുതിയ സന്ദേശവും ഡിഫോൾട്ടായി ഓരോ വരിക്കാരനും ഡെലിവർ ചെയ്യുന്നു. ഈ സ്വഭാവം തടയുന്ന Redis ലിസ്റ്റിൽ നിന്ന് വ്യത്യസ്തമാണ്, ഇവിടെ ഒരു പുതിയ സന്ദേശം ഒരു സബ്‌സ്‌ക്രൈബർ മാത്രമേ വായിക്കൂ.
2. Redis Pub/Sub-ൽ എല്ലാ സന്ദേശങ്ങളും മറക്കുകയും ഒരിക്കലും നിലനിൽക്കാതിരിക്കുകയും ചെയ്യുമ്പോൾ, സ്‌ട്രീമിൽ എല്ലാ സന്ദേശങ്ങളും അനിശ്ചിതമായി നിലനിർത്തും (ക്ലയന്റ് വ്യക്തമായി ഇല്ലാതാക്കാൻ കാരണമാകുന്നില്ലെങ്കിൽ).
3. ഒരു സ്ട്രീമിനുള്ളിൽ സന്ദേശങ്ങളിലേക്കുള്ള ആക്സസ് വേർതിരിച്ചറിയാൻ Redis സ്ട്രീം നിങ്ങളെ അനുവദിക്കുന്നു. ഒരു നിർദ്ദിഷ്ട വരിക്കാരന് അവരുടെ സ്വകാര്യ സന്ദേശ ചരിത്രം മാത്രമേ കാണാനാകൂ.

കമാൻഡ് ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഒരു ത്രെഡ് സബ്സ്ക്രൈബ് ചെയ്യാനും പുതിയ സന്ദേശങ്ങൾ സ്വീകരിക്കാനും കഴിയും XREAD. ഇത് കുറച്ചുകൂടി സങ്കീർണ്ണമാണ് XRANGE, അതിനാൽ ഞങ്ങൾ ആദ്യം ലളിതമായ ഉദാഹരണങ്ങളിൽ നിന്ന് ആരംഭിക്കും.

> XREAD COUNT 2 STREAMS mystream 0
1) 1) "mystream"
   2) 1) 1) 1519073278252-0
         2) 1) "foo"
            2) "value_1"
      2) 1) 1519073279157-0
         2) 1) "foo"
            2) "value_2"

മുകളിലെ ഉദാഹരണം ഒരു നോൺ-ബ്ലോക്കിംഗ് ഫോം കാണിക്കുന്നു XREAD. COUNT ഓപ്ഷൻ ഓപ്ഷണൽ ആണെന്ന് ശ്രദ്ധിക്കുക. വാസ്തവത്തിൽ, ആവശ്യമായ ഏക കമാൻഡ് ഓപ്‌ഷൻ STREAMS ഓപ്‌ഷനാണ്, അത് സ്ട്രീമുകളുടെ ഒരു ലിസ്റ്റ് അനുബന്ധ മാക്സിമം ഐഡന്റിഫയറിനൊപ്പം വ്യക്തമാക്കുന്നു. ഞങ്ങൾ "സ്ട്രീംസ് മൈസ്ട്രീം 0" എഴുതി - "0-0" എന്നതിനേക്കാൾ വലിയ ഐഡന്റിഫയർ ഉപയോഗിച്ച് മൈസ്ട്രീം സ്ട്രീമിന്റെ എല്ലാ റെക്കോർഡുകളും സ്വീകരിക്കാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നു. ഉദാഹരണത്തിൽ നിന്ന് നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, കമാൻഡ് ത്രെഡിന്റെ പേര് നൽകുന്നു, കാരണം നമുക്ക് ഒരേ സമയം ഒന്നിലധികം ത്രെഡുകൾ സബ്‌സ്‌ക്രൈബുചെയ്യാനാകും. നമുക്ക് എഴുതാം, ഉദാഹരണത്തിന്, "STREAMS mystream otherstream 0 0". STREAMS ഓപ്‌ഷനുശേഷം ഞങ്ങൾ ആദ്യം ആവശ്യമായ എല്ലാ സ്ട്രീമുകളുടെയും പേരുകളും അതിനുശേഷം മാത്രമേ ഐഡന്റിഫയറുകളുടെ ഒരു ലിസ്റ്റ് നൽകേണ്ടതുള്ളൂ എന്ന കാര്യം ശ്രദ്ധിക്കുക.

ഈ ലളിതമായ രൂപത്തിൽ കമാൻഡ് അപേക്ഷിച്ച് പ്രത്യേകമായി ഒന്നും ചെയ്യുന്നില്ല XRANGE. എന്നിരുന്നാലും, രസകരമായ കാര്യം നമുക്ക് എളുപ്പത്തിൽ തിരിയാൻ കഴിയും എന്നതാണ് XREAD ഒരു തടയൽ കമാൻഡിലേക്ക്, BLOCK ആർഗ്യുമെന്റ് വ്യക്തമാക്കുന്നു:

> XREAD BLOCK 0 STREAMS mystream $

മുകളിലുള്ള ഉദാഹരണത്തിൽ, 0 മില്ലിസെക്കൻഡ് സമയപരിധിയോടെ ഒരു പുതിയ BLOCK ഓപ്ഷൻ വ്യക്തമാക്കിയിരിക്കുന്നു (അനിശ്ചിതമായി കാത്തിരിക്കുക എന്നാണ് ഇതിനർത്ഥം). മാത്രമല്ല, സ്ട്രീം മൈസ്ട്രീമിനായുള്ള സാധാരണ ഐഡന്റിഫയർ കടന്നുപോകുന്നതിനുപകരം, ഒരു പ്രത്യേക ഐഡന്റിഫയർ $ പാസ്സാക്കി. ഈ പ്രത്യേക ഐഡന്റിഫയർ അർത്ഥമാക്കുന്നത് XREAD മൈസ്ട്രീമിലെ പരമാവധി ഐഡന്റിഫയർ ഐഡന്റിഫയറായി ഉപയോഗിക്കണം. അതിനാൽ ഞങ്ങൾ കേൾക്കാൻ തുടങ്ങിയ നിമിഷം മുതൽ പുതിയ സന്ദേശങ്ങൾ മാത്രമേ ലഭിക്കൂ. ചില വഴികളിൽ ഇത് Unix "tail -f" കമാൻഡിന് സമാനമാണ്.

BLOCK ഓപ്ഷൻ ഉപയോഗിക്കുമ്പോൾ നമ്മൾ പ്രത്യേക ഐഡന്റിഫയർ $ ഉപയോഗിക്കേണ്ടതില്ല എന്നത് ശ്രദ്ധിക്കുക. സ്ട്രീമിൽ നിലവിലുള്ള ഏത് ഐഡന്റിഫയറും നമുക്ക് ഉപയോഗിക്കാം. തടയാതെ ടീമിന് ഞങ്ങളുടെ അഭ്യർത്ഥന ഉടനടി സേവിക്കാൻ കഴിയുമെങ്കിൽ, അത് ചെയ്യും, അല്ലാത്തപക്ഷം അത് തടയും.

തടയുന്നു XREAD ഒരേസമയം ഒന്നിലധികം ത്രെഡുകൾ കേൾക്കാനും കഴിയും, നിങ്ങൾ അവയുടെ പേരുകൾ വ്യക്തമാക്കേണ്ടതുണ്ട്. ഈ സാഹചര്യത്തിൽ, ഡാറ്റ ലഭിച്ച ആദ്യ സ്ട്രീമിന്റെ റെക്കോർഡ് കമാൻഡ് തിരികെ നൽകും. തന്നിരിക്കുന്ന ത്രെഡിനായി ബ്ലോക്ക് ചെയ്‌ത ആദ്യ വരിക്കാരന് ആദ്യം ഡാറ്റ ലഭിക്കും.

ഉപഭോക്തൃ ഗ്രൂപ്പുകൾ

ചില ടാസ്ക്കുകളിൽ, ഒരു ത്രെഡിനുള്ളിലെ സന്ദേശങ്ങളിലേക്കുള്ള വരിക്കാരുടെ ആക്സസ് പരിമിതപ്പെടുത്താൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നു. ഇത് ഉപയോഗപ്രദമായേക്കാവുന്ന ഒരു ഉദാഹരണമാണ്, ഒരു ത്രെഡിൽ നിന്ന് വ്യത്യസ്ത സന്ദേശങ്ങൾ സ്വീകരിക്കുന്ന, സന്ദേശ പ്രോസസ്സിംഗ് സ്കെയിൽ ചെയ്യാൻ അനുവദിക്കുന്ന തൊഴിലാളികളുള്ള ഒരു സന്ദേശ ക്യൂ.

ഞങ്ങൾക്ക് C1, C2, C3 എന്നീ മൂന്ന് സബ്‌സ്‌ക്രൈബർമാരും 1, 2, 3, 4, 5, 6, 7 സന്ദേശങ്ങൾ ഉൾക്കൊള്ളുന്ന ഒരു ത്രെഡും ഉണ്ടെന്ന് ഞങ്ങൾ സങ്കൽപ്പിക്കുകയാണെങ്കിൽ, ചുവടെയുള്ള ഡയഗ്രാമിലെന്നപോലെ സന്ദേശങ്ങൾ നൽകും:

1 -> C1
2 -> C2
3 -> C3
4 -> C1
5 -> C2
6 -> C3
7 -> C1

ഈ പ്രഭാവം നേടാൻ, റെഡിസ് സ്ട്രീം കൺസ്യൂമർ ഗ്രൂപ്പ് എന്ന ആശയം ഉപയോഗിക്കുന്നു. ഈ ആശയം ഒരു കപട-വരിക്കാരന് സമാനമാണ്, അത് ഒരു സ്ട്രീമിൽ നിന്ന് ഡാറ്റ സ്വീകരിക്കുന്നു, എന്നാൽ യഥാർത്ഥത്തിൽ ഒരു ഗ്രൂപ്പിലെ ഒന്നിലധികം സബ്‌സ്‌ക്രൈബർമാർ ഇത് നൽകുന്നു, ചില ഗ്യാരണ്ടികൾ നൽകുന്നു:

1. ഓരോ സന്ദേശവും ഗ്രൂപ്പിലെ വ്യത്യസ്ത വരിക്കാർക്ക് കൈമാറുന്നു.
2. ഒരു ഗ്രൂപ്പിനുള്ളിൽ, വരിക്കാരെ അവരുടെ പേരിൽ തിരിച്ചറിയുന്നു, ഇത് ഒരു കേസ് സെൻസിറ്റീവ് സ്ട്രിംഗ് ആണ്. ഒരു വരിക്കാരൻ താൽകാലികമായി ഗ്രൂപ്പിൽ നിന്ന് പുറത്തായാൽ, അവന്റെ സ്വന്തം പേര് ഉപയോഗിച്ച് അവനെ ഗ്രൂപ്പിലേക്ക് പുനഃസ്ഥാപിക്കാൻ കഴിയും.
3. ഓരോ ഉപഭോക്തൃ ഗ്രൂപ്പും "ആദ്യം വായിക്കാത്ത സന്ദേശം" എന്ന ആശയം പിന്തുടരുന്നു. ഒരു സബ്‌സ്‌ക്രൈബർ പുതിയ സന്ദേശങ്ങൾ അഭ്യർത്ഥിക്കുമ്പോൾ, ഗ്രൂപ്പിലെ ഒരു സബ്‌സ്‌ക്രൈബർക്കും മുമ്പ് ഡെലിവർ ചെയ്തിട്ടില്ലാത്ത സന്ദേശങ്ങൾ മാത്രമേ അതിന് സ്വീകരിക്കാൻ കഴിയൂ.
4. സന്ദേശം സബ്‌സ്‌ക്രൈബർ വിജയകരമായി പ്രോസസ്സ് ചെയ്തുവെന്ന് വ്യക്തമായി സ്ഥിരീകരിക്കാൻ ഒരു കമാൻഡ് ഉണ്ട്. ഈ കമാൻഡ് വിളിക്കുന്നത് വരെ, അഭ്യർത്ഥിച്ച സന്ദേശം "തീർച്ചപ്പെടുത്താത്ത" നിലയിലായിരിക്കും.
5. ഉപഭോക്തൃ ഗ്രൂപ്പിനുള്ളിൽ, ഓരോ വരിക്കാരനും തനിക്ക് കൈമാറിയ സന്ദേശങ്ങളുടെ ചരിത്രം അഭ്യർത്ഥിക്കാൻ കഴിയും, എന്നാൽ ഇതുവരെ പ്രോസസ്സ് ചെയ്തിട്ടില്ല ("തീർച്ചപ്പെടുത്താത്ത" നിലയിൽ)

ഒരർത്ഥത്തിൽ, ഗ്രൂപ്പിന്റെ അവസ്ഥ ഇനിപ്പറയുന്ന രീതിയിൽ പ്രകടിപ്പിക്കാം:

+----------------------------------------+
| consumer_group_name: mygroup          
| consumer_group_stream: somekey        
| last_delivered_id: 1292309234234-92    
|                                                           
| consumers:                                          
|    "consumer-1" with pending messages  
|       1292309234234-4                          
|       1292309234232-8                          
|    "consumer-42" with pending messages 
|       ... (and so forth)                             
+----------------------------------------+

ഉപഭോക്തൃ ഗ്രൂപ്പിനായുള്ള പ്രധാന കമാൻഡുകളുമായി പരിചയപ്പെടാനുള്ള സമയമാണിത്, അതായത്:

• എക്സ്ഗ്രൂപ്പ് ഗ്രൂപ്പുകൾ സൃഷ്ടിക്കാനും നശിപ്പിക്കാനും നിയന്ത്രിക്കാനും ഉപയോഗിക്കുന്നു
• XREADGROUP ഗ്രൂപ്പിലൂടെ സ്ട്രീം വായിക്കാൻ ഉപയോഗിക്കുന്നു
• XACK - സന്ദേശം വിജയകരമായി പ്രോസസ്സ് ചെയ്തതായി അടയാളപ്പെടുത്താൻ ഈ കമാൻഡ് വരിക്കാരനെ അനുവദിക്കുന്നു

ഉപഭോക്തൃ ഗ്രൂപ്പിന്റെ രൂപീകരണം

mystream ഇതിനകം നിലവിലുണ്ടെന്ന് കരുതുക. അപ്പോൾ ഗ്രൂപ്പ് ക്രിയേഷൻ കമാൻഡ് ഇതുപോലെ കാണപ്പെടും:

> XGROUP CREATE mystream mygroup $
OK

ഒരു ഗ്രൂപ്പ് സൃഷ്‌ടിക്കുമ്പോൾ, ഗ്രൂപ്പിന് സന്ദേശങ്ങൾ ലഭിക്കുന്ന ഒരു ഐഡന്റിഫയർ ഞങ്ങൾ കൈമാറണം. എല്ലാ പുതിയ സന്ദേശങ്ങളും സ്വീകരിക്കാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നുവെങ്കിൽ, ഞങ്ങൾക്ക് പ്രത്യേക ഐഡന്റിഫയർ $ ഉപയോഗിക്കാം (മുകളിലുള്ള ഞങ്ങളുടെ ഉദാഹരണത്തിലെന്നപോലെ). ഒരു പ്രത്യേക ഐഡന്റിഫയറിന് പകരം നിങ്ങൾ 0 എന്ന് വ്യക്തമാക്കിയാൽ, ത്രെഡിലെ എല്ലാ സന്ദേശങ്ങളും ഗ്രൂപ്പിന് ലഭ്യമാകും.

ഇപ്പോൾ ഗ്രൂപ്പ് സൃഷ്ടിച്ചു, കമാൻഡ് ഉപയോഗിച്ച് നമുക്ക് ഉടൻ തന്നെ സന്ദേശങ്ങൾ വായിക്കാൻ തുടങ്ങാം XREADGROUP. ഈ കമാൻഡ് വളരെ സാമ്യമുള്ളതാണ് XREAD കൂടാതെ ഓപ്ഷണൽ BLOCK ഓപ്ഷനെ പിന്തുണയ്ക്കുന്നു. എന്നിരുന്നാലും, ആവശ്യമായ ഒരു GROUP ഓപ്ഷൻ ഉണ്ട്, അത് എല്ലായ്പ്പോഴും രണ്ട് ആർഗ്യുമെന്റുകൾ ഉപയോഗിച്ച് വ്യക്തമാക്കണം: ഗ്രൂപ്പിന്റെ പേരും വരിക്കാരുടെ പേരും. COUNT ഓപ്ഷനും പിന്തുണയ്ക്കുന്നു.

ത്രെഡ് വായിക്കുന്നതിന് മുമ്പ്, ചില സന്ദേശങ്ങൾ അവിടെ ഇടാം:

> XADD mystream * message apple
1526569495631-0
> XADD mystream * message orange
1526569498055-0
> XADD mystream * message strawberry
1526569506935-0
> XADD mystream * message apricot
1526569535168-0
> XADD mystream * message banana
1526569544280-0

ഇനി ഗ്രൂപ്പിലൂടെ ഈ സ്ട്രീം വായിക്കാൻ ശ്രമിക്കാം:

> XREADGROUP GROUP mygroup Alice COUNT 1 STREAMS mystream >
1) 1) "mystream"
   2) 1) 1) 1526569495631-0
         2) 1) "message"
            2) "apple"

മുകളിലുള്ള കമാൻഡ് ഇനിപ്പറയുന്ന രീതിയിൽ പദാനുപദമായി വായിക്കുന്നു:

"മൈഗ്രൂപ്പിലെ അംഗമായ, സബ്‌സ്‌ക്രൈബർ ആലീസ്, എന്റെ സ്ട്രീമിൽ നിന്ന് ഇതുവരെ ആർക്കും ഡെലിവർ ചെയ്തിട്ടില്ലാത്ത ഒരു സന്ദേശം വായിക്കാൻ ആഗ്രഹിക്കുന്നു."

ഓരോ തവണയും ഒരു സബ്‌സ്‌ക്രൈബർ ഒരു ഗ്രൂപ്പിൽ ഒരു ഓപ്പറേഷൻ നടത്തുമ്പോൾ, അത് ഗ്രൂപ്പിനുള്ളിൽ തന്നെ അദ്വിതീയമായി തിരിച്ചറിഞ്ഞുകൊണ്ട് അതിന്റെ പേര് നൽകണം. മുകളിലെ കമാൻഡിൽ വളരെ പ്രധാനപ്പെട്ട ഒരു വിശദാംശം കൂടിയുണ്ട് - പ്രത്യേക ഐഡന്റിഫയർ ">". ഈ പ്രത്യേക ഐഡന്റിഫയർ സന്ദേശങ്ങൾ ഫിൽട്ടർ ചെയ്യുന്നു, മുമ്പ് ഡെലിവർ ചെയ്തിട്ടില്ലാത്തവ മാത്രം അവശേഷിപ്പിക്കുന്നു.

കൂടാതെ, പ്രത്യേക സന്ദർഭങ്ങളിൽ, നിങ്ങൾക്ക് 0 അല്ലെങ്കിൽ മറ്റേതെങ്കിലും സാധുവായ ഐഡന്റിഫയർ പോലുള്ള ഒരു യഥാർത്ഥ ഐഡന്റിഫയർ വ്യക്തമാക്കാൻ കഴിയും. ഈ സാഹചര്യത്തിൽ കമാൻഡ് XREADGROUP നിർദ്ദിഷ്‌ട വരിക്കാരന് (ആലിസ്) ഡെലിവർ ചെയ്‌തതും എന്നാൽ കമാൻഡ് ഉപയോഗിച്ച് ഇതുവരെ അംഗീകരിച്ചിട്ടില്ലാത്തതുമായ "തീർച്ചപ്പെടുത്താത്ത" സ്റ്റാറ്റസുള്ള സന്ദേശങ്ങളുടെ ചരിത്രം നിങ്ങൾക്ക് തിരികെ നൽകും. XACK.

ഓപ്‌ഷൻ ഇല്ലാതെ തന്നെ ഐഡി 0 വ്യക്തമാക്കിക്കൊണ്ട് നമുക്ക് ഈ സ്വഭാവം പരിശോധിക്കാം COUNT. തീർച്ചപ്പെടുത്താത്ത ഒരൊറ്റ സന്ദേശം ഞങ്ങൾ കാണും, അതായത് ആപ്പിൾ സന്ദേശം:

> XREADGROUP GROUP mygroup Alice STREAMS mystream 0
1) 1) "mystream"
   2) 1) 1) 1526569495631-0
         2) 1) "message"
            2) "apple"

എന്നിരുന്നാലും, സന്ദേശം വിജയകരമായി പ്രോസസ്സ് ചെയ്തതായി ഞങ്ങൾ സ്ഥിരീകരിക്കുകയാണെങ്കിൽ, അത് മേലിൽ പ്രദർശിപ്പിക്കില്ല:

> XACK mystream mygroup 1526569495631-0
(integer) 1
> XREADGROUP GROUP mygroup Alice STREAMS mystream 0
1) 1) "mystream"
   2) (empty list or set)

ഇപ്പോൾ എന്തെങ്കിലും വായിക്കാനുള്ള ബോബിന്റെ ഊഴമാണ്:

> XREADGROUP GROUP mygroup Bob COUNT 2 STREAMS mystream >
1) 1) "mystream"
   2) 1) 1) 1526569498055-0
         2) 1) "message"
            2) "orange"
      2) 1) 1526569506935-0
         2) 1) "message"
            2) "strawberry"

മൈഗ്രൂപ്പിലെ അംഗമായ ബോബ് രണ്ട് സന്ദേശങ്ങളിൽ കൂടുതൽ ആവശ്യപ്പെടരുത്. ">" എന്ന പ്രത്യേക ഐഡന്റിഫയർ കാരണം കമാൻഡ് ഡെലിവർ ചെയ്യാത്ത സന്ദേശങ്ങൾ മാത്രമേ റിപ്പോർട്ട് ചെയ്യുന്നുള്ളൂ. നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, "ആപ്പിൾ" എന്ന സന്ദേശം ഇതിനകം ആലീസിന് കൈമാറിയതിനാൽ അത് പ്രദർശിപ്പിക്കില്ല, അതിനാൽ ബോബിന് "ഓറഞ്ചും" "സ്ട്രോബെറിയും" ലഭിക്കും.

ഇതുവഴി, ആലിസിനും ബോബിനും ഗ്രൂപ്പിലെ മറ്റേതെങ്കിലും വരിക്കാരനും ഒരേ സ്ട്രീമിൽ നിന്നുള്ള വ്യത്യസ്ത സന്ദേശങ്ങൾ വായിക്കാൻ കഴിയും. അവർക്ക് പ്രോസസ്സ് ചെയ്യാത്ത സന്ദേശങ്ങളുടെ ചരിത്രം വായിക്കാനോ സന്ദേശങ്ങൾ പ്രോസസ്സ് ചെയ്തതായി അടയാളപ്പെടുത്താനോ കഴിയും.

മനസ്സിൽ സൂക്ഷിക്കേണ്ട ചില കാര്യങ്ങളുണ്ട്:

• വരിക്കാരൻ സന്ദേശം ഒരു കമാൻഡായി കണക്കാക്കിയ ഉടൻ XREADGROUP, ഈ സന്ദേശം "തീർച്ചപ്പെടുത്താത്ത" അവസ്ഥയിലേക്ക് പോകുകയും ആ നിർദ്ദിഷ്ട വരിക്കാരന് അസൈൻ ചെയ്യുകയും ചെയ്യുന്നു. മറ്റ് ഗ്രൂപ്പ് വരിക്കാർക്ക് ഈ സന്ദേശം വായിക്കാൻ കഴിയില്ല.
• ആദ്യം പരാമർശിക്കുമ്പോൾ തന്നെ സബ്‌സ്‌ക്രൈബർമാരെ സ്വയമേവ സൃഷ്‌ടിക്കുന്നു, അവരെ വ്യക്തമായി സൃഷ്‌ടിക്കേണ്ട ആവശ്യമില്ല.
• സഹായത്തോടെ XREADGROUP നിങ്ങൾക്ക് ഒരേ സമയം ഒന്നിലധികം വ്യത്യസ്ത ത്രെഡുകളിൽ നിന്നുള്ള സന്ദേശങ്ങൾ വായിക്കാൻ കഴിയും, എന്നിരുന്നാലും ഇത് പ്രവർത്തിക്കുന്നതിന് നിങ്ങൾ ആദ്യം ഉപയോഗിക്കുന്ന ഓരോ ത്രെഡിനും ഒരേ പേരിൽ ഗ്രൂപ്പുകൾ സൃഷ്ടിക്കേണ്ടതുണ്ട്. എക്സ്ഗ്രൂപ്പ്

ഒരു പരാജയത്തിന് ശേഷം വീണ്ടെടുക്കൽ

വരിക്കാരന് പരാജയത്തിൽ നിന്ന് കരകയറാനും "തീർച്ചപ്പെടുത്താത്ത" സ്റ്റാറ്റസ് ഉപയോഗിച്ച് അവന്റെ സന്ദേശങ്ങളുടെ ലിസ്റ്റ് വീണ്ടും വായിക്കാനും കഴിയും. എന്നിരുന്നാലും, യഥാർത്ഥ ലോകത്ത്, വരിക്കാർ ആത്യന്തികമായി പരാജയപ്പെട്ടേക്കാം. ഒരു പരാജയത്തിൽ നിന്ന് കരകയറാൻ വരിക്കാരന് കഴിയുന്നില്ലെങ്കിൽ, വരിക്കാരന്റെ കുടുങ്ങിയ സന്ദേശങ്ങൾക്ക് എന്ത് സംഭവിക്കും?
അത്തരം സന്ദർഭങ്ങളിൽ മാത്രം ഉപയോഗിക്കുന്ന ഒരു ഫീച്ചർ കൺസ്യൂമർ ഗ്രൂപ്പ് വാഗ്ദാനം ചെയ്യുന്നു - നിങ്ങൾക്ക് സന്ദേശങ്ങളുടെ ഉടമയെ മാറ്റേണ്ടിവരുമ്പോൾ.

നിങ്ങൾ ആദ്യം ചെയ്യേണ്ടത് കമാൻഡ് വിളിക്കുക എന്നതാണ് ചെലവഴിക്കുന്നു, "തീർച്ചപ്പെടുത്താത്തത്" എന്ന സ്റ്റാറ്റസ് ഉള്ള ഗ്രൂപ്പിലെ എല്ലാ സന്ദേശങ്ങളും പ്രദർശിപ്പിക്കുന്നു. അതിന്റെ ഏറ്റവും ലളിതമായ രൂപത്തിൽ, കമാൻഡിനെ രണ്ട് ആർഗ്യുമെന്റുകളോടെ മാത്രമേ വിളിക്കൂ: ത്രെഡിന്റെ പേരും ഗ്രൂപ്പിന്റെ പേരും:

> XPENDING mystream mygroup
1) (integer) 2
2) 1526569498055-0
3) 1526569506935-0
4) 1) 1) "Bob"
      2) "2"

മുഴുവൻ ഗ്രൂപ്പിനും ഓരോ വരിക്കാർക്കും വേണ്ടിയുള്ള പ്രോസസ്സ് ചെയ്യാത്ത സന്ദേശങ്ങളുടെ എണ്ണം ടീം പ്രദർശിപ്പിച്ചു. ആലീസ് അഭ്യർത്ഥിച്ച ഒരേയൊരു സന്ദേശം സ്ഥിരീകരിച്ചതിനാൽ ഞങ്ങൾക്ക് രണ്ട് മികച്ച സന്ദേശങ്ങളുള്ള ബോബ് മാത്രമേ ഉള്ളൂ XACK.

കൂടുതൽ ആർഗ്യുമെന്റുകൾ ഉപയോഗിച്ച് ഞങ്ങൾക്ക് കൂടുതൽ വിവരങ്ങൾ അഭ്യർത്ഥിക്കാം:

XPENDING {key} {groupname} [{start-id} {end-id} {count} [{consumer-name}]]
{start-id} {end-id} - ഐഡന്റിഫയറുകളുടെ ശ്രേണി (നിങ്ങൾക്ക് “-”, “+” എന്നിവ ഉപയോഗിക്കാം)
{count} — ഡെലിവറി ശ്രമങ്ങളുടെ എണ്ണം
{consumer-name} - ഗ്രൂപ്പിന്റെ പേര്

> XPENDING mystream mygroup - + 10
1) 1) 1526569498055-0
   2) "Bob"
   3) (integer) 74170458
   4) (integer) 1
2) 1) 1526569506935-0
   2) "Bob"
   3) (integer) 74170458
   4) (integer) 1

ഇപ്പോൾ ഞങ്ങൾക്ക് ഓരോ സന്ദേശത്തിനും വിശദാംശങ്ങൾ ഉണ്ട്: ഐഡി, സബ്‌സ്‌ക്രൈബർ പേര്, മില്ലിസെക്കൻഡിലെ നിഷ്‌ക്രിയ സമയം, ഒടുവിൽ ഡെലിവറി ശ്രമങ്ങളുടെ എണ്ണം. ഞങ്ങൾക്ക് ബോബിൽ നിന്ന് രണ്ട് സന്ദേശങ്ങളുണ്ട്, അവ 74170458 മില്ലിസെക്കൻഡ്, ഏകദേശം 20 മണിക്കൂർ നിഷ്‌ക്രിയമാണ്.

കേവലം ഉപയോഗിച്ചുകൊണ്ട് സന്ദേശത്തിലെ ഉള്ളടക്കം എന്താണെന്ന് പരിശോധിക്കുന്നതിൽ നിന്ന് ആരും ഞങ്ങളെ തടയുന്നില്ലെന്ന് ദയവായി ശ്രദ്ധിക്കുക XRANGE.

> XRANGE mystream 1526569498055-0 1526569498055-0
1) 1) 1526569498055-0
   2) 1) "message"
      2) "orange"

ആർഗ്യുമെന്റുകളിൽ ഒരേ ഐഡന്റിഫയർ രണ്ടുതവണ ആവർത്തിക്കണം. ഇപ്പോൾ ഞങ്ങൾക്ക് കുറച്ച് ധാരണയുണ്ട്, 20 മണിക്കൂർ പ്രവർത്തനരഹിതമായതിന് ശേഷം, ബോബ് സുഖം പ്രാപിക്കില്ലെന്ന് ആലീസ് തീരുമാനിച്ചേക്കാം, ആ സന്ദേശങ്ങൾ അന്വേഷിക്കാനും ബോബിനായി അവ പ്രോസസ്സ് ചെയ്യുന്നത് പുനരാരംഭിക്കാനും സമയമായി. ഇതിനായി നമ്മൾ കമാൻഡ് ഉപയോഗിക്കുന്നു XCLAIM:

XCLAIM {key} {group} {consumer} {min-idle-time} {ID-1} {ID-2} ... {ID-N}

ഈ കമാൻഡ് ഉപയോഗിച്ച്, ഉടമയെ {consumer} ആയി മാറ്റുന്നതിലൂടെ ഇതുവരെ പ്രോസസ്സ് ചെയ്തിട്ടില്ലാത്ത ഒരു "വിദേശ" സന്ദേശം നമുക്ക് ലഭിക്കും. എന്നിരുന്നാലും, ഞങ്ങൾക്ക് ഏറ്റവും കുറഞ്ഞ നിഷ്‌ക്രിയ സമയവും {min-idle-time} നൽകാം. ഒരേ സന്ദേശങ്ങളുടെ ഉടമയെ ഒരേസമയം രണ്ട് ക്ലയന്റുകൾ മാറ്റാൻ ശ്രമിക്കുന്ന സാഹചര്യം ഒഴിവാക്കാൻ ഇത് സഹായിക്കുന്നു:

Client 1: XCLAIM mystream mygroup Alice 3600000 1526569498055-0
Clinet 2: XCLAIM mystream mygroup Lora 3600000 1526569498055-0

ആദ്യത്തെ ഉപഭോക്താവ് പ്രവർത്തനരഹിതമായ സമയം പുനഃസജ്ജമാക്കുകയും ഡെലിവറി കൗണ്ടർ വർദ്ധിപ്പിക്കുകയും ചെയ്യും. അതിനാൽ രണ്ടാമത്തെ ക്ലയന്റിന് ഇത് അഭ്യർത്ഥിക്കാൻ കഴിയില്ല.

> XCLAIM mystream mygroup Alice 3600000 1526569498055-0
1) 1) 1526569498055-0
   2) 1) "message"
      2) "orange"

ആലിസ് സന്ദേശം വിജയകരമായി ക്ലെയിം ചെയ്തു, അവർക്ക് ഇപ്പോൾ സന്ദേശം പ്രോസസ്സ് ചെയ്യാനും അത് അംഗീകരിക്കാനും കഴിയും.

മുകളിലെ ഉദാഹരണത്തിൽ നിന്ന്, ഒരു വിജയകരമായ അഭ്യർത്ഥന സന്ദേശത്തിന്റെ ഉള്ളടക്കം തന്നെ തിരികെ നൽകുന്നതായി നിങ്ങൾക്ക് കാണാൻ കഴിയും. എന്നിരുന്നാലും, ഇത് ആവശ്യമില്ല. സന്ദേശ ഐഡികൾ മാത്രം നൽകുന്നതിന് JUSTID ഓപ്ഷൻ ഉപയോഗിക്കാനാകും. നിങ്ങൾക്ക് സന്ദേശത്തിന്റെ വിശദാംശങ്ങളിൽ താൽപ്പര്യമില്ലെങ്കിൽ സിസ്റ്റം പ്രകടനം വർദ്ധിപ്പിക്കാൻ ആഗ്രഹിക്കുന്നുവെങ്കിൽ ഇത് ഉപയോഗപ്രദമാണ്.

ഡെലിവറി കൗണ്ടർ

ഔട്ട്പുട്ടിൽ നിങ്ങൾ കാണുന്ന കൗണ്ടർ ചെലവഴിക്കുന്നു ഓരോ സന്ദേശത്തിന്റെയും ഡെലിവറികളുടെ എണ്ണമാണ്. അത്തരമൊരു കൌണ്ടർ രണ്ട് തരത്തിൽ വർദ്ധിപ്പിക്കുന്നു: ഒരു സന്ദേശം വിജയകരമായി അഭ്യർത്ഥിക്കുമ്പോൾ XCLAIM അല്ലെങ്കിൽ ഒരു കോൾ ഉപയോഗിക്കുമ്പോൾ XREADGROUP.

ചില സന്ദേശങ്ങൾ ഒന്നിലധികം തവണ കൈമാറുന്നത് സാധാരണമാണ്. എല്ലാ സന്ദേശങ്ങളും ഒടുവിൽ പ്രോസസ്സ് ചെയ്യപ്പെടുന്നു എന്നതാണ് പ്രധാന കാര്യം. ഒരു സന്ദേശം പ്രോസസ്സ് ചെയ്യുമ്പോൾ ചിലപ്പോൾ പ്രശ്നങ്ങൾ ഉണ്ടാകാം, കാരണം സന്ദേശം തന്നെ കേടായതിനാൽ അല്ലെങ്കിൽ സന്ദേശ പ്രോസസ്സിംഗ് ഹാൻഡ്‌ലർ കോഡിൽ ഒരു പിശക് ഉണ്ടാക്കുന്നു. ഈ സാഹചര്യത്തിൽ, ആർക്കും ഈ സന്ദേശം പ്രോസസ്സ് ചെയ്യാൻ കഴിയില്ലെന്ന് മാറിയേക്കാം. ഞങ്ങൾക്ക് ഒരു ഡെലിവറി ശ്രമ കൗണ്ടർ ഉള്ളതിനാൽ, അത്തരം സാഹചര്യങ്ങൾ കണ്ടെത്താൻ ഞങ്ങൾക്ക് ഈ കൗണ്ടർ ഉപയോഗിക്കാം. അതിനാൽ, ഡെലിവറി എണ്ണം നിങ്ങൾ വ്യക്തമാക്കിയ ഉയർന്ന നമ്പറിൽ എത്തിക്കഴിഞ്ഞാൽ, അത്തരമൊരു സന്ദേശം മറ്റൊരു ത്രെഡിൽ ഇടുകയും സിസ്റ്റം അഡ്‌മിനിസ്‌ട്രേറ്റർക്ക് ഒരു അറിയിപ്പ് അയയ്ക്കുകയും ചെയ്യുന്നതാണ് ബുദ്ധി.

ത്രെഡ് സ്റ്റേറ്റ്

ടീം XINFO ഒരു ത്രെഡിനെയും അതിന്റെ ഗ്രൂപ്പുകളെയും കുറിച്ചുള്ള വിവിധ വിവരങ്ങൾ അഭ്യർത്ഥിക്കാൻ ഉപയോഗിക്കുന്നു. ഉദാഹരണത്തിന്, ഒരു അടിസ്ഥാന കമാൻഡ് ഇതുപോലെ കാണപ്പെടുന്നു:

> XINFO STREAM mystream
 1) length
 2) (integer) 13
 3) radix-tree-keys
 4) (integer) 1
 5) radix-tree-nodes
 6) (integer) 2
 7) groups
 8) (integer) 2
 9) first-entry
10) 1) 1524494395530-0
    2) 1) "a"
       2) "1"
       3) "b"
       4) "2"
11) last-entry
12) 1) 1526569544280-0
    2) 1) "message"
       2) "banana"

മുകളിലുള്ള കമാൻഡ് നിർദ്ദിഷ്ട സ്ട്രീമിനെക്കുറിച്ചുള്ള പൊതുവായ വിവരങ്ങൾ പ്രദർശിപ്പിക്കുന്നു. ഇപ്പോൾ കുറച്ചുകൂടി സങ്കീർണ്ണമായ ഒരു ഉദാഹരണം:

> XINFO GROUPS mystream
1) 1) name
   2) "mygroup"
   3) consumers
   4) (integer) 2
   5) pending
   6) (integer) 2
2) 1) name
   2) "some-other-group"
   3) consumers
   4) (integer) 1
   5) pending
   6) (integer) 0

മുകളിലുള്ള കമാൻഡ് നിർദ്ദിഷ്ട ത്രെഡിന്റെ എല്ലാ ഗ്രൂപ്പുകൾക്കുമുള്ള പൊതുവായ വിവരങ്ങൾ പ്രദർശിപ്പിക്കുന്നു

> XINFO CONSUMERS mystream mygroup
1) 1) name
   2) "Alice"
   3) pending
   4) (integer) 1
   5) idle
   6) (integer) 9104628
2) 1) name
   2) "Bob"
   3) pending
   4) (integer) 1
   5) idle
   6) (integer) 83841983

മുകളിലുള്ള കമാൻഡ് നിർദ്ദിഷ്ട സ്ട്രീമിലെയും ഗ്രൂപ്പിലെയും എല്ലാ വരിക്കാർക്കുമുള്ള വിവരങ്ങൾ പ്രദർശിപ്പിക്കുന്നു.
നിങ്ങൾ കമാൻഡ് വാക്യഘടന മറന്നാൽ, സഹായത്തിനായി കമാൻഡിനോട് തന്നെ ചോദിക്കുക:

> XINFO HELP
1) XINFO {subcommand} arg arg ... arg. Subcommands are:
2) CONSUMERS {key} {groupname}  -- Show consumer groups of group {groupname}.
3) GROUPS {key}                 -- Show the stream consumer groups.
4) STREAM {key}                 -- Show information about the stream.
5) HELP                         -- Print this help.

സ്ട്രീം വലുപ്പ പരിധി

പല ആപ്ലിക്കേഷനുകളും ശാശ്വതമായി ഒരു സ്ട്രീമിലേക്ക് ഡാറ്റ ശേഖരിക്കാൻ ആഗ്രഹിക്കുന്നില്ല. ഒരു ത്രെഡിന് പരമാവധി സന്ദേശങ്ങൾ അനുവദിക്കുന്നത് പലപ്പോഴും ഉപയോഗപ്രദമാണ്. മറ്റ് സന്ദർഭങ്ങളിൽ, നിർദ്ദിഷ്ട ത്രെഡ് വലുപ്പത്തിൽ എത്തുമ്പോൾ എല്ലാ സന്ദേശങ്ങളും ഒരു ത്രെഡിൽ നിന്ന് മറ്റൊരു സ്ഥിരമായ സ്റ്റോറിലേക്ക് നീക്കുന്നത് ഉപയോഗപ്രദമാണ്. കമാൻഡിലെ MAXLEN പാരാമീറ്റർ ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഒരു സ്ട്രീമിന്റെ വലുപ്പം പരിമിതപ്പെടുത്താം XADD:

> XADD mystream MAXLEN 2 * value 1
1526654998691-0
> XADD mystream MAXLEN 2 * value 2
1526654999635-0
> XADD mystream MAXLEN 2 * value 3
1526655000369-0
> XLEN mystream
(integer) 2
> XRANGE mystream - +
1) 1) 1526654999635-0
   2) 1) "value"
      2) "2"
2) 1) 1526655000369-0
   2) 1) "value"
      2) "3"

MAXLEN ഉപയോഗിക്കുമ്പോൾ, ഒരു നിശ്ചിത ദൈർഘ്യത്തിൽ എത്തുമ്പോൾ പഴയ റെക്കോർഡുകൾ സ്വയമേവ ഇല്ലാതാക്കപ്പെടും, അതിനാൽ സ്ട്രീമിന് സ്ഥിരമായ വലുപ്പമുണ്ട്. എന്നിരുന്നാലും, ഈ കേസിലെ അരിവാൾ Redis മെമ്മറിയിൽ ഏറ്റവും കാര്യക്ഷമമായ രീതിയിൽ സംഭവിക്കുന്നില്ല. നിങ്ങൾക്ക് ഇനിപ്പറയുന്ന രീതിയിൽ സാഹചര്യം മെച്ചപ്പെടുത്താൻ കഴിയും:

XADD mystream MAXLEN ~ 1000 * ... entry fields here ...

മുകളിലെ ഉദാഹരണത്തിലെ ~ വാദം അർത്ഥമാക്കുന്നത് സ്ട്രീം ദൈർഘ്യം ഒരു പ്രത്യേക മൂല്യത്തിലേക്ക് പരിമിതപ്പെടുത്തേണ്ടതില്ല എന്നാണ്. ഞങ്ങളുടെ ഉദാഹരണത്തിൽ, ഇത് 1000-നേക്കാൾ വലുതോ അതിന് തുല്യമോ ആയ ഏത് സംഖ്യയും ആകാം (ഉദാഹരണത്തിന്, 1000, 1010, അല്ലെങ്കിൽ 1030). ഞങ്ങളുടെ സ്ട്രീം കുറഞ്ഞത് 1000 റെക്കോർഡുകളെങ്കിലും സംഭരിക്കാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നുവെന്ന് ഞങ്ങൾ വ്യക്തമായി വ്യക്തമാക്കി. ഇത് റെഡിസിനുള്ളിൽ മെമ്മറി മാനേജ്‌മെന്റിനെ കൂടുതൽ കാര്യക്ഷമമാക്കുന്നു.

ഒരു പ്രത്യേക ടീമും ഉണ്ട് XTRIM, ഇത് ഒരേ കാര്യം ചെയ്യുന്നു:

> XTRIM mystream MAXLEN 10

> XTRIM mystream MAXLEN ~ 10


സ്ഥിരമായ സംഭരണവും പകർപ്പും

റെഡിസ് സ്ട്രീം സ്ലേവ് നോഡുകളിലേക്ക് അസമന്വിതമായി പകർത്തുകയും AOF (എല്ലാ ഡാറ്റയുടെയും സ്നാപ്പ്ഷോട്ട്), RDB (എല്ലാ റൈറ്റ് ഓപ്പറേഷനുകളുടെയും ലോഗ്) പോലുള്ള ഫയലുകളിലേക്ക് സംരക്ഷിക്കുകയും ചെയ്യുന്നു. ഉപഭോക്തൃ ഗ്രൂപ്പുകളുടെ സംസ്ഥാനത്തിന്റെ അനുകരണവും പിന്തുണയ്ക്കുന്നു. അതിനാൽ, ഒരു സന്ദേശം മാസ്റ്റർ നോഡിലെ "തീർച്ചപ്പെടുത്താത്ത" നിലയിലാണെങ്കിൽ, സ്ലേവ് നോഡുകളിൽ ഈ സന്ദേശത്തിന് അതേ സ്റ്റാറ്റസ് ഉണ്ടായിരിക്കും.

ഒരു സ്ട്രീമിൽ നിന്ന് വ്യക്തിഗത ഘടകങ്ങൾ നീക്കംചെയ്യുന്നു

സന്ദേശങ്ങൾ ഇല്ലാതാക്കാൻ ഒരു പ്രത്യേക കമാൻഡ് ഉണ്ട് XDEL. കമാൻഡിന് ത്രെഡിന്റെ പേര് ലഭിക്കുന്നു, തുടർന്ന് ഇല്ലാതാക്കേണ്ട സന്ദേശ ഐഡികൾ:

> XRANGE mystream - + COUNT 2
1) 1) 1526654999635-0
   2) 1) "value"
      2) "2"
2) 1) 1526655000369-0
   2) 1) "value"
      2) "3"
> XDEL mystream 1526654999635-0
(integer) 1
> XRANGE mystream - + COUNT 2
1) 1) 1526655000369-0
   2) 1) "value"
      2) "3"

ഈ കമാൻഡ് ഉപയോഗിക്കുമ്പോൾ, യഥാർത്ഥ മെമ്മറി ഉടനടി റിലീസ് ചെയ്യില്ലെന്ന് നിങ്ങൾ കണക്കിലെടുക്കേണ്ടതുണ്ട്.

പൂജ്യം നീളമുള്ള സ്ട്രീമുകൾ

സ്ട്രീമുകളും മറ്റ് റെഡിസ് ഡാറ്റാ ഘടനകളും തമ്മിലുള്ള വ്യത്യാസം, മറ്റ് ഡാറ്റാ ഘടനകൾക്ക് അവയിൽ ഘടകങ്ങൾ ഇല്ലാതിരിക്കുമ്പോൾ, ഒരു പാർശ്വഫലമായി, ഡാറ്റാ ഘടന തന്നെ മെമ്മറിയിൽ നിന്ന് നീക്കം ചെയ്യപ്പെടും. അതിനാൽ, ഉദാഹരണത്തിന്, ZREM കോൾ അവസാന ഘടകം നീക്കം ചെയ്യുമ്പോൾ അടുക്കിയ സെറ്റ് പൂർണ്ണമായും നീക്കം ചെയ്യപ്പെടും. പകരം, ത്രെഡുകൾ ഉള്ളിൽ ഘടകങ്ങളൊന്നും ഇല്ലാതെ പോലും മെമ്മറിയിൽ നിലനിൽക്കാൻ അനുവദിക്കുന്നു.

തീരുമാനം

സന്ദേശ ബ്രോക്കർമാർ, സന്ദേശ ക്യൂകൾ, ഏകീകൃത ലോഗിംഗ്, ഹിസ്റ്ററി-കീപ്പിംഗ് ചാറ്റ് സിസ്റ്റങ്ങൾ എന്നിവ സൃഷ്ടിക്കുന്നതിന് റെഡിസ് സ്ട്രീം അനുയോജ്യമാണ്.

ഞാൻ ഒരിക്കൽ പറഞ്ഞതുപോലെ നിക്ലസ് വിർത്ത്, പ്രോഗ്രാമുകൾ അൽഗോരിതങ്ങളും ഡാറ്റാ ഘടനകളും ആണ്, കൂടാതെ Redis ഇതിനകം തന്നെ നിങ്ങൾക്ക് രണ്ടും നൽകുന്നു.

അവലംബം: www.habr.com