ಪ್ರೊಹೋಸ್ಟರ್ > Блог > ಆಡಳಿತ > ರೆಡಿಸ್ ಸ್ಟ್ರೀಮ್ - ನಿಮ್ಮ ಸಂದೇಶ ವ್ಯವಸ್ಥೆಗಳ ವಿಶ್ವಾಸಾರ್ಹತೆ ಮತ್ತು ಸ್ಕೇಲೆಬಿಲಿಟಿ

ರೆಡಿಸ್ ಸ್ಟ್ರೀಮ್ - ನಿಮ್ಮ ಸಂದೇಶ ವ್ಯವಸ್ಥೆಗಳ ವಿಶ್ವಾಸಾರ್ಹತೆ ಮತ್ತು ಸ್ಕೇಲೆಬಿಲಿಟಿ

ರೆಡಿಸ್ ಸ್ಟ್ರೀಮ್ - ನಿಮ್ಮ ಸಂದೇಶ ವ್ಯವಸ್ಥೆಗಳ ವಿಶ್ವಾಸಾರ್ಹತೆ ಮತ್ತು ಸ್ಕೇಲೆಬಿಲಿಟಿ

ರೆಡಿಸ್ ಸ್ಟ್ರೀಮ್ ಆವೃತ್ತಿ 5.0 ನೊಂದಿಗೆ ರೆಡಿಸ್‌ನಲ್ಲಿ ಪರಿಚಯಿಸಲಾದ ಹೊಸ ಅಮೂರ್ತ ಡೇಟಾ ಪ್ರಕಾರವಾಗಿದೆ
ಕಲ್ಪನಾತ್ಮಕವಾಗಿ, ರೆಡಿಸ್ ಸ್ಟ್ರೀಮ್ ನೀವು ನಮೂದುಗಳನ್ನು ಸೇರಿಸಬಹುದಾದ ಪಟ್ಟಿಯಾಗಿದೆ. ಪ್ರತಿ ನಮೂದು ಅನನ್ಯ ಗುರುತಿಸುವಿಕೆಯನ್ನು ಹೊಂದಿದೆ. ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, ID ಸ್ವಯಂಚಾಲಿತವಾಗಿ ರಚಿಸಲ್ಪಡುತ್ತದೆ ಮತ್ತು ಸಮಯಸ್ಟ್ಯಾಂಪ್ ಅನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ. ಆದ್ದರಿಂದ, ಯುನಿಕ್ಸ್ "ಟೈಲ್ -ಎಫ್" ಆಜ್ಞೆಯು ಲಾಗ್ ಫೈಲ್ ಅನ್ನು ಓದುತ್ತದೆ ಮತ್ತು ಹೊಸ ಡೇಟಾಗಾಗಿ ಕಾಯುತ್ತಿರುವಾಗ ಫ್ರೀಜ್ ಆಗುವಂತೆ ನೀವು ಕಾಲಾನಂತರದಲ್ಲಿ ದಾಖಲೆಗಳ ಶ್ರೇಣಿಗಳನ್ನು ಪ್ರಶ್ನಿಸಬಹುದು ಅಥವಾ ಸ್ಟ್ರೀಮ್‌ಗೆ ಬಂದಂತೆ ಹೊಸ ಡೇಟಾವನ್ನು ಪಡೆಯಬಹುದು. ಅನೇಕ ಕ್ಲೈಂಟ್‌ಗಳು ಒಂದೇ ಸಮಯದಲ್ಲಿ ಥ್ರೆಡ್ ಅನ್ನು ಆಲಿಸಬಹುದು ಎಂಬುದನ್ನು ಗಮನಿಸಿ, ಅನೇಕ "ಟೈಲ್ -ಎಫ್" ಪ್ರಕ್ರಿಯೆಗಳು ಪರಸ್ಪರ ಸಂಘರ್ಷವಿಲ್ಲದೆ ಏಕಕಾಲದಲ್ಲಿ ಫೈಲ್ ಅನ್ನು ಓದಬಹುದು.

ಹೊಸ ಡೇಟಾ ಪ್ರಕಾರದ ಎಲ್ಲಾ ಪ್ರಯೋಜನಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು, ರೆಡಿಸ್ ಸ್ಟ್ರೀಮ್‌ನ ಕ್ರಿಯಾತ್ಮಕತೆಯನ್ನು ಭಾಗಶಃ ಪುನರಾವರ್ತಿಸುವ ದೀರ್ಘಕಾಲದಿಂದ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ರೆಡಿಸ್ ರಚನೆಗಳನ್ನು ತ್ವರಿತವಾಗಿ ನೋಡೋಣ.

ರೆಡಿಸ್ PUB/SUB

ರೆಡಿಸ್ ಪಬ್/ಸಬ್ ಎಂಬುದು ನಿಮ್ಮ ಪ್ರಮುಖ ಮೌಲ್ಯದ ಅಂಗಡಿಯಲ್ಲಿ ಈಗಾಗಲೇ ನಿರ್ಮಿಸಲಾದ ಸರಳ ಸಂದೇಶ ಕಳುಹಿಸುವ ವ್ಯವಸ್ಥೆಯಾಗಿದೆ. ಆದಾಗ್ಯೂ, ಸರಳತೆಯು ವೆಚ್ಚದಲ್ಲಿ ಬರುತ್ತದೆ:

  • ಕೆಲವು ಕಾರಣಗಳಿಗಾಗಿ ಪ್ರಕಾಶಕರು ವಿಫಲವಾದರೆ, ಅವನು ತನ್ನ ಎಲ್ಲಾ ಚಂದಾದಾರರನ್ನು ಕಳೆದುಕೊಳ್ಳುತ್ತಾನೆ
  • ಪ್ರಕಾಶಕರು ಅದರ ಎಲ್ಲಾ ಚಂದಾದಾರರ ನಿಖರವಾದ ವಿಳಾಸವನ್ನು ತಿಳಿದುಕೊಳ್ಳಬೇಕು
  • ಡೇಟಾವನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವುದಕ್ಕಿಂತ ವೇಗವಾಗಿ ಪ್ರಕಟಿಸಿದರೆ ಪ್ರಕಾಶಕರು ಅದರ ಚಂದಾದಾರರನ್ನು ಕೆಲಸದೊಂದಿಗೆ ಓವರ್‌ಲೋಡ್ ಮಾಡಬಹುದು
  • ಎಷ್ಟು ಚಂದಾದಾರರಿಗೆ ತಲುಪಿಸಲಾಗಿದೆ ಮತ್ತು ಎಷ್ಟು ಬೇಗನೆ ಈ ಸಂದೇಶವನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ಸಾಧ್ಯವಾಯಿತು ಎಂಬುದನ್ನು ಲೆಕ್ಕಿಸದೆ, ಪ್ರಕಟಣೆಯ ನಂತರ ತಕ್ಷಣವೇ ಪ್ರಕಾಶಕರ ಬಫರ್‌ನಿಂದ ಸಂದೇಶವನ್ನು ಅಳಿಸಲಾಗುತ್ತದೆ.
  • ಎಲ್ಲಾ ಚಂದಾದಾರರು ಒಂದೇ ಸಮಯದಲ್ಲಿ ಸಂದೇಶವನ್ನು ಸ್ವೀಕರಿಸುತ್ತಾರೆ. ಅದೇ ಸಂದೇಶವನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವ ಕ್ರಮದಲ್ಲಿ ಚಂದಾದಾರರು ತಮ್ಮನ್ನು ಹೇಗಾದರೂ ಒಪ್ಪಿಕೊಳ್ಳಬೇಕು.
  • ಚಂದಾದಾರರು ಸಂದೇಶವನ್ನು ಯಶಸ್ವಿಯಾಗಿ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಿದ್ದಾರೆ ಎಂದು ಖಚಿತಪಡಿಸಲು ಯಾವುದೇ ಅಂತರ್ನಿರ್ಮಿತ ಕಾರ್ಯವಿಧಾನವಿಲ್ಲ. ಚಂದಾದಾರರು ಸಂದೇಶವನ್ನು ಸ್ವೀಕರಿಸಿದರೆ ಮತ್ತು ಪ್ರಕ್ರಿಯೆಯ ಸಮಯದಲ್ಲಿ ಕ್ರ್ಯಾಶ್ ಆಗಿದ್ದರೆ, ಪ್ರಕಾಶಕರಿಗೆ ಅದರ ಬಗ್ಗೆ ತಿಳಿದಿರುವುದಿಲ್ಲ.

ರೆಡಿಸ್ ಪಟ್ಟಿ

ರೆಡಿಸ್ ಪಟ್ಟಿ ಎಂಬುದು ಡೇಟಾ ರಚನೆಯಾಗಿದ್ದು ಅದು ಓದುವ ಆಜ್ಞೆಗಳನ್ನು ನಿರ್ಬಂಧಿಸುವುದನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ. ನೀವು ಪಟ್ಟಿಯ ಪ್ರಾರಂಭ ಅಥವಾ ಅಂತ್ಯದಿಂದ ಸಂದೇಶಗಳನ್ನು ಸೇರಿಸಬಹುದು ಮತ್ತು ಓದಬಹುದು. ಈ ರಚನೆಯ ಆಧಾರದ ಮೇಲೆ, ನಿಮ್ಮ ವಿತರಣಾ ವ್ಯವಸ್ಥೆಗೆ ನೀವು ಉತ್ತಮ ಸ್ಟಾಕ್ ಅಥವಾ ಕ್ಯೂ ಮಾಡಬಹುದು, ಮತ್ತು ಹೆಚ್ಚಿನ ಸಂದರ್ಭಗಳಲ್ಲಿ ಇದು ಸಾಕಷ್ಟು ಇರುತ್ತದೆ. ರೆಡಿಸ್ ಪಬ್/ಉಪದಿಂದ ಮುಖ್ಯ ವ್ಯತ್ಯಾಸಗಳು:

  • ಸಂದೇಶವನ್ನು ಒಬ್ಬ ಕ್ಲೈಂಟ್‌ಗೆ ತಲುಪಿಸಲಾಗುತ್ತದೆ. ಮೊದಲ ಓದು-ನಿರ್ಬಂಧಿತ ಕ್ಲೈಂಟ್ ಮೊದಲು ಡೇಟಾವನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ.
  • ಕ್ಲಿಂಟ್ ಪ್ರತಿ ಸಂದೇಶವನ್ನು ಸ್ವತಃ ಓದುವ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಪ್ರಾರಂಭಿಸಬೇಕು. ಪಟ್ಟಿಗೆ ಗ್ರಾಹಕರ ಬಗ್ಗೆ ಏನೂ ತಿಳಿದಿಲ್ಲ.
  • ಯಾರಾದರೂ ಅವುಗಳನ್ನು ಓದುವವರೆಗೆ ಅಥವಾ ಸ್ಪಷ್ಟವಾಗಿ ಅಳಿಸುವವರೆಗೆ ಸಂದೇಶಗಳನ್ನು ಸಂಗ್ರಹಿಸಲಾಗುತ್ತದೆ. ಡಿಸ್ಕ್ಗೆ ಡೇಟಾವನ್ನು ಫ್ಲಶ್ ಮಾಡಲು ನೀವು Redis ಸರ್ವರ್ ಅನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡಿದರೆ, ಸಿಸ್ಟಮ್ನ ವಿಶ್ವಾಸಾರ್ಹತೆಯು ನಾಟಕೀಯವಾಗಿ ಹೆಚ್ಚಾಗುತ್ತದೆ.

ಸ್ಟ್ರೀಮ್‌ಗೆ ಪರಿಚಯ

ಸ್ಟ್ರೀಮ್‌ಗೆ ನಮೂದನ್ನು ಸೇರಿಸಲಾಗುತ್ತಿದೆ

ತಂಡದ XADD ಸ್ಟ್ರೀಮ್‌ಗೆ ಹೊಸ ಪ್ರವೇಶವನ್ನು ಸೇರಿಸುತ್ತದೆ. ದಾಖಲೆಯು ಕೇವಲ ಸ್ಟ್ರಿಂಗ್ ಅಲ್ಲ, ಇದು ಒಂದು ಅಥವಾ ಹೆಚ್ಚಿನ ಕೀ-ಮೌಲ್ಯದ ಜೋಡಿಗಳನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ. ಹೀಗಾಗಿ, ಪ್ರತಿ ನಮೂದು ಈಗಾಗಲೇ ರಚನೆಯಾಗಿದೆ ಮತ್ತು CSV ಫೈಲ್‌ನ ರಚನೆಯನ್ನು ಹೋಲುತ್ತದೆ.

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

ಮೇಲಿನ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾವು ಸ್ಟ್ರೀಮ್‌ಗೆ ಎರಡು ಕ್ಷೇತ್ರಗಳನ್ನು ಸೇರಿಸುತ್ತೇವೆ (ಕೀಲಿ) “ಮೈಸ್ಟ್ರೀಮ್”: “ಸೆನ್ಸಾರ್-ಐಡಿ” ಮತ್ತು “ತಾಪಮಾನ” ಕ್ರಮವಾಗಿ “1234” ಮತ್ತು “19.8” ಮೌಲ್ಯಗಳೊಂದಿಗೆ. ಎರಡನೇ ವಾದದಂತೆ, ಆಜ್ಞೆಯು ಗುರುತಿಸುವಿಕೆಯನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ, ಅದನ್ನು ಪ್ರವೇಶಕ್ಕೆ ನಿಯೋಜಿಸಲಾಗುವುದು - ಈ ಗುರುತಿಸುವಿಕೆಯು ಸ್ಟ್ರೀಮ್‌ನಲ್ಲಿನ ಪ್ರತಿ ನಮೂದನ್ನು ಅನನ್ಯವಾಗಿ ಗುರುತಿಸುತ್ತದೆ. ಆದಾಗ್ಯೂ, ಈ ಸಂದರ್ಭದಲ್ಲಿ ನಾವು * ಪಾಸ್ ಮಾಡಿದ್ದೇವೆ ಏಕೆಂದರೆ ರೆಡಿಸ್ ನಮಗಾಗಿ ಹೊಸ ಐಡಿಯನ್ನು ರಚಿಸಬೇಕೆಂದು ನಾವು ಬಯಸುತ್ತೇವೆ. ಪ್ರತಿ ಹೊಸ ID ಹೆಚ್ಚಾಗುತ್ತದೆ. ಆದ್ದರಿಂದ, ಪ್ರತಿ ಹೊಸ ನಮೂದು ಹಿಂದಿನ ನಮೂದುಗಳಿಗೆ ಸಂಬಂಧಿಸಿದಂತೆ ಹೆಚ್ಚಿನ ಗುರುತಿಸುವಿಕೆಯನ್ನು ಹೊಂದಿರುತ್ತದೆ.

ಐಡೆಂಟಿಫೈಯರ್ ಫಾರ್ಮ್ಯಾಟ್

ಆಜ್ಞೆಯಿಂದ ಪ್ರವೇಶ ID ಹಿಂತಿರುಗಿದೆ XADD, ಎರಡು ಭಾಗಗಳನ್ನು ಒಳಗೊಂಡಿದೆ:

{millisecondsTime}-{sequenceNumber}

ಮಿಲಿಸೆಕೆಂಡ್ ಸಮಯ - ಯುನಿಕ್ಸ್ ಸಮಯ ಮಿಲಿಸೆಕೆಂಡ್‌ಗಳಲ್ಲಿ (ರೆಡಿಸ್ ಸರ್ವರ್ ಸಮಯ). ಆದಾಗ್ಯೂ, ಪ್ರಸ್ತುತ ಸಮಯವು ಹಿಂದಿನ ರೆಕಾರ್ಡಿಂಗ್‌ನ ಸಮಯಕ್ಕಿಂತ ಒಂದೇ ಅಥವಾ ಕಡಿಮೆಯಿದ್ದರೆ, ನಂತರ ಹಿಂದಿನ ರೆಕಾರ್ಡಿಂಗ್‌ನ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಅನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ಆದ್ದರಿಂದ, ಸರ್ವರ್ ಸಮಯವು ಸಮಯಕ್ಕೆ ಹಿಂತಿರುಗಿದರೆ, ಹೊಸ ಗುರುತಿಸುವಿಕೆ ಇನ್ನೂ ಹೆಚ್ಚಳದ ಆಸ್ತಿಯನ್ನು ಉಳಿಸಿಕೊಳ್ಳುತ್ತದೆ.

ಕ್ರಮ ಸಂಖ್ಯೆ ಅದೇ ಮಿಲಿಸೆಕೆಂಡ್‌ನಲ್ಲಿ ರಚಿಸಲಾದ ದಾಖಲೆಗಳಿಗಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ. ಕ್ರಮ ಸಂಖ್ಯೆ ಹಿಂದಿನ ಪ್ರವೇಶಕ್ಕೆ ಸಂಬಂಧಿಸಿದಂತೆ 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 ದಾಖಲೆಗಳನ್ನು (ಪೇಜಿನೇಶನ್) ಪಡೆಯಬೇಕಾದರೆ, ನಾವು ಕೊನೆಯದಾಗಿ ಸ್ವೀಕರಿಸಿದ ID ಅನ್ನು ಬಳಸಬಹುದು, ಅದನ್ನು ಹೆಚ್ಚಿಸಿ ಕ್ರಮ ಸಂಖ್ಯೆ ಒಂದರಿಂದ ಮತ್ತು ಮತ್ತೆ ಕೇಳಿ. ಕೆಳಗಿನ ಉದಾಹರಣೆಯಲ್ಲಿ ಇದನ್ನು ನೋಡೋಣ. ನಾವು 10 ಅಂಶಗಳನ್ನು ಸೇರಿಸಲು ಪ್ರಾರಂಭಿಸುತ್ತೇವೆ XADD (ಮೈಸ್ಟ್ರೀಮ್ ಈಗಾಗಲೇ 10 ಅಂಶಗಳಿಂದ ತುಂಬಿದೆ ಎಂದು ಊಹಿಸಿ). ಪ್ರತಿ ಆಜ್ಞೆಗೆ 2 ಅಂಶಗಳನ್ನು ಪಡೆಯುವ ಪುನರಾವರ್ತನೆಯನ್ನು ಪ್ರಾರಂಭಿಸಲು, ನಾವು ಪೂರ್ಣ ಶ್ರೇಣಿಯೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸುತ್ತೇವೆ ಆದರೆ COUNT 2 ಗೆ ಸಮಾನವಾಗಿರುತ್ತದೆ.

> 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 ಅನ್ನು ಸೇರಿಸಬೇಕು ಕ್ರಮ ಸಂಖ್ಯೆ.
ಪರಿಣಾಮವಾಗಿ ID, ಈ ಸಂದರ್ಭದಲ್ಲಿ 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 ಬಳಸಿಕೊಂಡು ಹೊಸ ನಮೂದುಗಳನ್ನು ಓದುವುದು

ಸಾಮಾನ್ಯವಾಗಿ ಸ್ಟ್ರೀಮ್‌ಗೆ ಚಂದಾದಾರರಾಗುವ ಮತ್ತು ಹೊಸ ಸಂದೇಶಗಳನ್ನು ಮಾತ್ರ ಸ್ವೀಕರಿಸುವ ಕಾರ್ಯವು ಉದ್ಭವಿಸುತ್ತದೆ. ಈ ಪರಿಕಲ್ಪನೆಯು ರೆಡಿಸ್ ಪಬ್/ಸಬ್ ಅಥವಾ ರೆಡಿಸ್ ಪಟ್ಟಿಯನ್ನು ನಿರ್ಬಂಧಿಸುವಂತೆ ತೋರಬಹುದು, ಆದರೆ ರೆಡಿಸ್ ಸ್ಟ್ರೀಮ್ ಅನ್ನು ಹೇಗೆ ಬಳಸುವುದು ಎಂಬುದರಲ್ಲಿ ಮೂಲಭೂತ ವ್ಯತ್ಯಾಸಗಳಿವೆ:

  1. ಪ್ರತಿ ಹೊಸ ಸಂದೇಶವನ್ನು ಡೀಫಾಲ್ಟ್ ಆಗಿ ಪ್ರತಿ ಚಂದಾದಾರರಿಗೆ ತಲುಪಿಸಲಾಗುತ್ತದೆ. ಈ ನಡವಳಿಕೆಯು ನಿರ್ಬಂಧಿಸುವ Redis ಪಟ್ಟಿಗಿಂತ ಭಿನ್ನವಾಗಿದೆ, ಅಲ್ಲಿ ಹೊಸ ಸಂದೇಶವನ್ನು ಒಬ್ಬ ಚಂದಾದಾರರಿಂದ ಮಾತ್ರ ಓದಲಾಗುತ್ತದೆ.
  2. ರೆಡಿಸ್ ಪಬ್/ಸಬ್‌ನಲ್ಲಿ ಎಲ್ಲಾ ಸಂದೇಶಗಳು ಮರೆತುಹೋಗಿವೆ ಮತ್ತು ಎಂದಿಗೂ ಮುಂದುವರಿಯುವುದಿಲ್ಲ, ಸ್ಟ್ರೀಮ್‌ನಲ್ಲಿ ಎಲ್ಲಾ ಸಂದೇಶಗಳನ್ನು ಅನಿರ್ದಿಷ್ಟವಾಗಿ ಉಳಿಸಿಕೊಳ್ಳಲಾಗುತ್ತದೆ (ಕ್ಲೈಂಟ್ ಸ್ಪಷ್ಟವಾಗಿ ಅಳಿಸುವಿಕೆಗೆ ಕಾರಣವಾಗದ ಹೊರತು).
  3. ಒಂದು ಸ್ಟ್ರೀಮ್‌ನಲ್ಲಿ ಸಂದೇಶಗಳಿಗೆ ಪ್ರವೇಶವನ್ನು ಪ್ರತ್ಯೇಕಿಸಲು ರೆಡಿಸ್ ಸ್ಟ್ರೀಮ್ ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ನಿರ್ದಿಷ್ಟ ಚಂದಾದಾರರು ತಮ್ಮ ವೈಯಕ್ತಿಕ ಸಂದೇಶ ಇತಿಹಾಸವನ್ನು ಮಾತ್ರ ನೋಡಬಹುದು.

ನೀವು ಥ್ರೆಡ್‌ಗೆ ಚಂದಾದಾರರಾಗಬಹುದು ಮತ್ತು ಆಜ್ಞೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಹೊಸ ಸಂದೇಶಗಳನ್ನು ಸ್ವೀಕರಿಸಬಹುದು 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" ಗಿಂತ ಹೆಚ್ಚಿನ ಗುರುತಿಸುವಿಕೆಯೊಂದಿಗೆ ನಾವು ಮೈಸ್ಟ್ರೀಮ್ ಸ್ಟ್ರೀಮ್‌ನ ಎಲ್ಲಾ ದಾಖಲೆಗಳನ್ನು ಸ್ವೀಕರಿಸಲು ಬಯಸುತ್ತೇವೆ. ಉದಾಹರಣೆಯಿಂದ ನೀವು ನೋಡುವಂತೆ, ಆಜ್ಞೆಯು ಥ್ರೆಡ್‌ನ ಹೆಸರನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ ಏಕೆಂದರೆ ನಾವು ಒಂದೇ ಸಮಯದಲ್ಲಿ ಅನೇಕ ಥ್ರೆಡ್‌ಗಳಿಗೆ ಚಂದಾದಾರರಾಗಬಹುದು. ನಾವು ಬರೆಯಬಹುದು, ಉದಾಹರಣೆಗೆ, "ಸ್ಟ್ರೀಮ್ಸ್ ಮೈಸ್ಟ್ರೀಮ್ ಇತರೆಸ್ಟ್ರೀಮ್ 0 0". STREAMS ಆಯ್ಕೆಯ ನಂತರ ನಾವು ಮೊದಲು ಅಗತ್ಯವಿರುವ ಎಲ್ಲಾ ಸ್ಟ್ರೀಮ್‌ಗಳ ಹೆಸರುಗಳನ್ನು ಮತ್ತು ನಂತರ ಮಾತ್ರ ಗುರುತಿಸುವಿಕೆಗಳ ಪಟ್ಟಿಯನ್ನು ಒದಗಿಸಬೇಕಾಗಿದೆ ಎಂಬುದನ್ನು ದಯವಿಟ್ಟು ಗಮನಿಸಿ.

ಈ ಸರಳ ರೂಪದಲ್ಲಿ ಆಜ್ಞೆಯು ಹೋಲಿಸಿದರೆ ವಿಶೇಷವಾದ ಏನನ್ನೂ ಮಾಡುವುದಿಲ್ಲ XRANGE. ಆದಾಗ್ಯೂ, ಆಸಕ್ತಿದಾಯಕ ವಿಷಯವೆಂದರೆ ನಾವು ಸುಲಭವಾಗಿ ತಿರುಗಬಹುದು XREAD ನಿರ್ಬಂಧಿಸುವ ಆಜ್ಞೆಗೆ, BLOCK ಆರ್ಗ್ಯುಮೆಂಟ್ ಅನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ:

> XREAD BLOCK 0 STREAMS mystream $

ಮೇಲಿನ ಉದಾಹರಣೆಯಲ್ಲಿ, ಹೊಸ BLOCK ಆಯ್ಕೆಯನ್ನು 0 ಮಿಲಿಸೆಕೆಂಡ್‌ಗಳ ಕಾಲಾವಧಿಯೊಂದಿಗೆ ನಿರ್ದಿಷ್ಟಪಡಿಸಲಾಗಿದೆ (ಇದರರ್ಥ ಅನಿರ್ದಿಷ್ಟವಾಗಿ ಕಾಯುತ್ತಿದೆ). ಇದಲ್ಲದೆ, ಸ್ಟ್ರೀಮ್ ಮೈಸ್ಟ್ರೀಮ್‌ಗಾಗಿ ಸಾಮಾನ್ಯ ಗುರುತಿಸುವಿಕೆಯನ್ನು ಹಾದುಹೋಗುವ ಬದಲು, ವಿಶೇಷ ಗುರುತಿಸುವಿಕೆ $ ಅನ್ನು ರವಾನಿಸಲಾಗಿದೆ. ಈ ವಿಶೇಷ ಗುರುತಿಸುವಿಕೆ ಎಂದರೆ ಅದು 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)                             
+----------------------------------------+

ಈಗ ಗ್ರಾಹಕ ಗುಂಪಿನ ಮುಖ್ಯ ಆಜ್ಞೆಗಳೊಂದಿಗೆ ಪರಿಚಯ ಮಾಡಿಕೊಳ್ಳುವ ಸಮಯ ಬಂದಿದೆ, ಅವುಗಳೆಂದರೆ:

  • XGROUP ಗುಂಪುಗಳನ್ನು ರಚಿಸಲು, ನಾಶಮಾಡಲು ಮತ್ತು ನಿರ್ವಹಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ
  • XREADGROUP ಗುಂಪಿನ ಮೂಲಕ ಸ್ಟ್ರೀಮ್ ಅನ್ನು ಓದಲು ಬಳಸಲಾಗುತ್ತದೆ
  • XACK - ಈ ಆಜ್ಞೆಯು ಸಂದೇಶವನ್ನು ಯಶಸ್ವಿಯಾಗಿ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲಾಗಿದೆ ಎಂದು ಗುರುತಿಸಲು ಚಂದಾದಾರರಿಗೆ ಅನುಮತಿಸುತ್ತದೆ

ಗ್ರಾಹಕ ಗುಂಪಿನ ರಚನೆ

ಮೈಸ್ಟ್ರೀಮ್ ಈಗಾಗಲೇ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ ಎಂದು ಭಾವಿಸೋಣ. ನಂತರ ಗುಂಪು ರಚನೆ ಆಜ್ಞೆಯು ಈ ರೀತಿ ಕಾಣುತ್ತದೆ:

> 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.

ಆಯ್ಕೆಯಿಲ್ಲದೆ ID 0 ಅನ್ನು ತಕ್ಷಣವೇ ನಿರ್ದಿಷ್ಟಪಡಿಸುವ ಮೂಲಕ ನಾವು ಈ ನಡವಳಿಕೆಯನ್ನು ಪರೀಕ್ಷಿಸಬಹುದು ಎಣಿಕೆ. ನಾವು ಒಂದೇ ಬಾಕಿ ಇರುವ ಸಂದೇಶವನ್ನು ನೋಡುತ್ತೇವೆ, ಅಂದರೆ ಸೇಬು ಸಂದೇಶ:

> 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 ನೀವು ಒಂದೇ ಸಮಯದಲ್ಲಿ ಹಲವಾರು ವಿಭಿನ್ನ ಥ್ರೆಡ್‌ಗಳಿಂದ ಸಂದೇಶಗಳನ್ನು ಓದಬಹುದು, ಆದಾಗ್ಯೂ ಇದು ಕೆಲಸ ಮಾಡಲು ನೀವು ಮೊದಲು ಬಳಸುವ ಪ್ರತಿಯೊಂದು ಥ್ರೆಡ್‌ಗೆ ಒಂದೇ ಹೆಸರಿನ ಗುಂಪುಗಳನ್ನು ರಚಿಸಬೇಕಾಗುತ್ತದೆ XGROUP

ವೈಫಲ್ಯದ ನಂತರ ಚೇತರಿಕೆ

ಚಂದಾದಾರರು ವೈಫಲ್ಯದಿಂದ ಚೇತರಿಸಿಕೊಳ್ಳಬಹುದು ಮತ್ತು "ಬಾಕಿ ಇರುವ" ಸ್ಥಿತಿಯೊಂದಿಗೆ ಅವರ ಸಂದೇಶಗಳ ಪಟ್ಟಿಯನ್ನು ಪುನಃ ಓದಬಹುದು. ಆದಾಗ್ಯೂ, ನೈಜ ಜಗತ್ತಿನಲ್ಲಿ, ಚಂದಾದಾರರು ಅಂತಿಮವಾಗಿ ವಿಫಲರಾಗಬಹುದು. ವೈಫಲ್ಯದಿಂದ ಚಂದಾದಾರರಿಗೆ ಚೇತರಿಸಿಕೊಳ್ಳಲು ಸಾಧ್ಯವಾಗದಿದ್ದರೆ ಚಂದಾದಾರರ ಅಂಟಿಕೊಂಡಿರುವ ಸಂದೇಶಗಳಿಗೆ ಏನಾಗುತ್ತದೆ?
ಗ್ರಾಹಕ ಗುಂಪು ಅಂತಹ ಸಂದರ್ಭಗಳಲ್ಲಿ ಬಳಸಲಾಗುವ ವೈಶಿಷ್ಟ್ಯವನ್ನು ನೀಡುತ್ತದೆ - ನೀವು ಸಂದೇಶಗಳ ಮಾಲೀಕರನ್ನು ಬದಲಾಯಿಸಬೇಕಾದಾಗ.

ನೀವು ಮಾಡಬೇಕಾದ ಮೊದಲನೆಯದು ಆಜ್ಞೆಯನ್ನು ಕರೆಯುವುದು ಕಳೆಯುತ್ತಿದೆ, ಇದು ಗುಂಪಿನಲ್ಲಿರುವ ಎಲ್ಲಾ ಸಂದೇಶಗಳನ್ನು "ಬಾಕಿ" ಸ್ಥಿತಿಯೊಂದಿಗೆ ಪ್ರದರ್ಶಿಸುತ್ತದೆ. ಅದರ ಸರಳ ರೂಪದಲ್ಲಿ, ಆಜ್ಞೆಯನ್ನು ಕೇವಲ ಎರಡು ವಾದಗಳೊಂದಿಗೆ ಕರೆಯಲಾಗುತ್ತದೆ: ಥ್ರೆಡ್ ಹೆಸರು ಮತ್ತು ಗುಂಪಿನ ಹೆಸರು:

> 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

ಈಗ ನಾವು ಪ್ರತಿ ಸಂದೇಶಕ್ಕೆ ವಿವರಗಳನ್ನು ಹೊಂದಿದ್ದೇವೆ: ID, ಚಂದಾದಾರರ ಹೆಸರು, ಮಿಲಿಸೆಕೆಂಡ್‌ಗಳಲ್ಲಿ ನಿಷ್ಕ್ರಿಯ ಸಮಯ ಮತ್ತು ಅಂತಿಮವಾಗಿ ವಿತರಣಾ ಪ್ರಯತ್ನಗಳ ಸಂಖ್ಯೆ. ನಾವು ಬಾಬ್‌ನಿಂದ ಎರಡು ಸಂದೇಶಗಳನ್ನು ಹೊಂದಿದ್ದೇವೆ ಮತ್ತು ಅವು 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"

ಸಂದೇಶವನ್ನು ಆಲಿಸ್ ಅವರು ಯಶಸ್ವಿಯಾಗಿ ಕ್ಲೈಮ್ ಮಾಡಿದ್ದಾರೆ, ಅವರು ಈಗ ಸಂದೇಶವನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಬಹುದು ಮತ್ತು ಅದನ್ನು ಅಂಗೀಕರಿಸಬಹುದು.

ಮೇಲಿನ ಉದಾಹರಣೆಯಿಂದ, ಯಶಸ್ವಿ ವಿನಂತಿಯು ಸಂದೇಶದ ವಿಷಯಗಳನ್ನು ಸ್ವತಃ ಹಿಂದಿರುಗಿಸುತ್ತದೆ ಎಂದು ನೀವು ನೋಡಬಹುದು. ಆದಾಗ್ಯೂ, ಇದು ಅಗತ್ಯವಿಲ್ಲ. ಸಂದೇಶ ID ಗಳನ್ನು ಹಿಂದಿರುಗಿಸಲು 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 ಅನ್ನು ಬಳಸುವಾಗ, ಹಳೆಯ ದಾಖಲೆಗಳು ನಿರ್ದಿಷ್ಟ ಉದ್ದವನ್ನು ತಲುಪಿದಾಗ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಅಳಿಸಲ್ಪಡುತ್ತವೆ, ಆದ್ದರಿಂದ ಸ್ಟ್ರೀಮ್ ಸ್ಥಿರ ಗಾತ್ರವನ್ನು ಹೊಂದಿರುತ್ತದೆ. ಆದಾಗ್ಯೂ, ಈ ಸಂದರ್ಭದಲ್ಲಿ ಸಮರುವಿಕೆಯನ್ನು ರೆಡಿಸ್ ಸ್ಮರಣೆಯಲ್ಲಿ ಅತ್ಯಂತ ಪರಿಣಾಮಕಾರಿ ರೀತಿಯಲ್ಲಿ ಸಂಭವಿಸುವುದಿಲ್ಲ. ನೀವು ಈ ಕೆಳಗಿನಂತೆ ಪರಿಸ್ಥಿತಿಯನ್ನು ಸುಧಾರಿಸಬಹುದು:

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

ಮೇಲಿನ ಉದಾಹರಣೆಯಲ್ಲಿನ ~ ಆರ್ಗ್ಯುಮೆಂಟ್ ಎಂದರೆ ನಾವು ಸ್ಟ್ರೀಮ್ ಉದ್ದವನ್ನು ನಿರ್ದಿಷ್ಟ ಮೌಲ್ಯಕ್ಕೆ ಮಿತಿಗೊಳಿಸುವ ಅಗತ್ಯವಿಲ್ಲ. ನಮ್ಮ ಉದಾಹರಣೆಯಲ್ಲಿ, ಇದು 1000 ಕ್ಕಿಂತ ಹೆಚ್ಚಿನ ಅಥವಾ ಸಮನಾಗಿರುವ ಯಾವುದೇ ಸಂಖ್ಯೆಯಾಗಿರಬಹುದು (ಉದಾಹರಣೆಗೆ, 1000, 1010, ಅಥವಾ 1030). ನಮ್ಮ ಸ್ಟ್ರೀಮ್ ಕನಿಷ್ಠ 1000 ದಾಖಲೆಗಳನ್ನು ಸಂಗ್ರಹಿಸಬೇಕೆಂದು ನಾವು ಬಯಸುತ್ತೇವೆ ಎಂದು ನಾವು ಸ್ಪಷ್ಟವಾಗಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ್ದೇವೆ. ಇದು ರೆಡಿಸ್ ಒಳಗೆ ಮೆಮೊರಿ ನಿರ್ವಹಣೆಯನ್ನು ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಮಾಡುತ್ತದೆ.

ಪ್ರತ್ಯೇಕ ತಂಡವೂ ಇದೆ XTRIM, ಅದೇ ಕೆಲಸವನ್ನು ಮಾಡುತ್ತದೆ:

> XTRIM mystream MAXLEN 10

> XTRIM mystream MAXLEN ~ 10

ನಿರಂತರ ಸಂಗ್ರಹಣೆ ಮತ್ತು ಪುನರಾವರ್ತನೆ

ರೆಡಿಸ್ ಸ್ಟ್ರೀಮ್ ಅನ್ನು ಸ್ಲೇವ್ ನೋಡ್‌ಗಳಿಗೆ ಅಸಮಕಾಲಿಕವಾಗಿ ಪುನರಾವರ್ತಿಸಲಾಗುತ್ತದೆ ಮತ್ತು AOF (ಎಲ್ಲಾ ಡೇಟಾದ ಸ್ನ್ಯಾಪ್‌ಶಾಟ್) ಮತ್ತು RDB (ಎಲ್ಲಾ ಬರೆಯುವ ಕಾರ್ಯಾಚರಣೆಗಳ ಲಾಗ್) ನಂತಹ ಫೈಲ್‌ಗಳಿಗೆ ಉಳಿಸಲಾಗಿದೆ. ಗ್ರಾಹಕ ಗುಂಪುಗಳ ರಾಜ್ಯದ ನಕಲು ಸಹ ಬೆಂಬಲಿತವಾಗಿದೆ. ಆದ್ದರಿಂದ, ಒಂದು ಸಂದೇಶವು ಮಾಸ್ಟರ್ ನೋಡ್‌ನಲ್ಲಿ "ಬಾಕಿ ಇರುವ" ಸ್ಥಿತಿಯಲ್ಲಿದ್ದರೆ, ಸ್ಲೇವ್ ನೋಡ್‌ಗಳಲ್ಲಿ ಈ ಸಂದೇಶವು ಅದೇ ಸ್ಥಿತಿಯನ್ನು ಹೊಂದಿರುತ್ತದೆ.

ಸ್ಟ್ರೀಮ್‌ನಿಂದ ಪ್ರತ್ಯೇಕ ಅಂಶಗಳನ್ನು ತೆಗೆದುಹಾಕುವುದು

ಸಂದೇಶಗಳನ್ನು ಅಳಿಸಲು ವಿಶೇಷ ಆಜ್ಞೆ ಇದೆ XDEL. ಆಜ್ಞೆಯು ಥ್ರೆಡ್‌ನ ಹೆಸರನ್ನು ಪಡೆಯುತ್ತದೆ ನಂತರ ಸಂದೇಶ ID ಗಳನ್ನು ಅಳಿಸಲಾಗುತ್ತದೆ:

> 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 ಕರೆ ಕೊನೆಯ ಅಂಶವನ್ನು ತೆಗೆದುಹಾಕಿದಾಗ ವಿಂಗಡಿಸಲಾದ ಸೆಟ್ ಅನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ತೆಗೆದುಹಾಕಲಾಗುತ್ತದೆ. ಬದಲಾಗಿ, ಎಳೆಗಳನ್ನು ಒಳಗೆ ಯಾವುದೇ ಅಂಶಗಳಿಲ್ಲದೆಯೇ ಮೆಮೊರಿಯಲ್ಲಿ ಉಳಿಯಲು ಅನುಮತಿಸಲಾಗಿದೆ.

ತೀರ್ಮಾನಕ್ಕೆ

ಸಂದೇಶ ದಲ್ಲಾಳಿಗಳು, ಸಂದೇಶ ಸರತಿ ಸಾಲುಗಳು, ಏಕೀಕೃತ ಲಾಗಿಂಗ್ ಮತ್ತು ಇತಿಹಾಸ-ಕೀಪಿಂಗ್ ಚಾಟ್ ವ್ಯವಸ್ಥೆಗಳನ್ನು ರಚಿಸಲು ರೆಡಿಸ್ ಸ್ಟ್ರೀಮ್ ಸೂಕ್ತವಾಗಿದೆ.

ನಾನು ಒಮ್ಮೆ ಹೇಳಿದಂತೆ ನಿಕ್ಲಾಸ್ ವಿರ್ತ್, ಪ್ರೋಗ್ರಾಂಗಳು ಅಲ್ಗಾರಿದಮ್‌ಗಳು ಮತ್ತು ಡೇಟಾ ರಚನೆಗಳು, ಮತ್ತು ರೆಡಿಸ್ ಈಗಾಗಲೇ ನಿಮಗೆ ಎರಡನ್ನೂ ನೀಡುತ್ತದೆ.

ಮೂಲ: www.habr.com

ಕಾಮೆಂಟ್ ಅನ್ನು ಸೇರಿಸಿ