🥇 ಸಮತಲ ಸ್ಕೇಲಿಂಗ್ memcached ಗೆ mcrouter ಅನ್ನು ಬಳಸುವುದು

ಯಾವುದೇ ಭಾಷೆಯಲ್ಲಿ ಹೆಚ್ಚಿನ ಲೋಡ್ ಯೋಜನೆಗಳನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸಲು ವಿಶೇಷ ವಿಧಾನ ಮತ್ತು ವಿಶೇಷ ಪರಿಕರಗಳ ಬಳಕೆಯ ಅಗತ್ಯವಿರುತ್ತದೆ, ಆದರೆ PHP ಯಲ್ಲಿನ ಅಪ್ಲಿಕೇಶನ್‌ಗಳ ವಿಷಯಕ್ಕೆ ಬಂದಾಗ, ನೀವು ಅಭಿವೃದ್ಧಿಪಡಿಸಬೇಕಾದ ಪರಿಸ್ಥಿತಿಯು ತುಂಬಾ ಉಲ್ಬಣಗೊಳ್ಳಬಹುದು, ಉದಾಹರಣೆಗೆ, ಸ್ವಂತ ಅಪ್ಲಿಕೇಶನ್ ಸರ್ವರ್. ಈ ಟಿಪ್ಪಣಿಯಲ್ಲಿ ನಾವು ವಿತರಿಸಿದ ಸೆಷನ್ ಸಂಗ್ರಹಣೆ ಮತ್ತು ಮೆಮ್‌ಕ್ಯಾಶ್ಡ್‌ನಲ್ಲಿ ಡೇಟಾ ಹಿಡಿದಿಟ್ಟುಕೊಳ್ಳುವುದರೊಂದಿಗೆ ಪರಿಚಿತ ನೋವಿನ ಬಗ್ಗೆ ಮಾತನಾಡುತ್ತೇವೆ ಮತ್ತು ಒಂದು "ವಾರ್ಡ್" ಯೋಜನೆಯಲ್ಲಿ ನಾವು ಈ ಸಮಸ್ಯೆಗಳನ್ನು ಹೇಗೆ ಪರಿಹರಿಸಿದ್ದೇವೆ.

ಈ ಸಂದರ್ಭದ ನಾಯಕ ಸಿಂಫೋನಿ 2.3 ಫ್ರೇಮ್‌ವರ್ಕ್ ಅನ್ನು ಆಧರಿಸಿದ ಪಿಎಚ್‌ಪಿ ಅಪ್ಲಿಕೇಶನ್ ಆಗಿದೆ, ಇದನ್ನು ನವೀಕರಿಸಲು ವ್ಯಾಪಾರ ಯೋಜನೆಗಳಲ್ಲಿ ಸೇರಿಸಲಾಗಿಲ್ಲ. ಸಾಕಷ್ಟು ಪ್ರಮಾಣಿತ ಅಧಿವೇಶನ ಸಂಗ್ರಹಣೆಯ ಜೊತೆಗೆ, ಈ ಯೋಜನೆಯು ಸಂಪೂರ್ಣ ಬಳಕೆಯನ್ನು ಮಾಡಿದೆ "ಎಲ್ಲವನ್ನೂ ಹಿಡಿದಿಟ್ಟುಕೊಳ್ಳುವುದು" ನೀತಿ memcached ನಲ್ಲಿ: ಡೇಟಾಬೇಸ್ ಮತ್ತು API ಸರ್ವರ್‌ಗಳಿಗೆ ವಿನಂತಿಗಳಿಗೆ ಪ್ರತಿಕ್ರಿಯೆಗಳು, ವಿವಿಧ ಫ್ಲ್ಯಾಗ್‌ಗಳು, ಕೋಡ್ ಎಕ್ಸಿಕ್ಯೂಶನ್ ಸಿಂಕ್ರೊನೈಸ್ ಮಾಡಲು ಲಾಕ್‌ಗಳು ಮತ್ತು ಇನ್ನಷ್ಟು. ಅಂತಹ ಪರಿಸ್ಥಿತಿಯಲ್ಲಿ, ಮೆಮ್‌ಕ್ಯಾಶ್ಡ್‌ನ ಸ್ಥಗಿತವು ಅಪ್ಲಿಕೇಶನ್‌ನ ಕಾರ್ಯಾಚರಣೆಗೆ ಮಾರಕವಾಗುತ್ತದೆ. ಹೆಚ್ಚುವರಿಯಾಗಿ, ಸಂಗ್ರಹ ನಷ್ಟವು ಗಂಭೀರ ಪರಿಣಾಮಗಳಿಗೆ ಕಾರಣವಾಗುತ್ತದೆ: DBMS ಸ್ತರಗಳಲ್ಲಿ ಸಿಡಿಯಲು ಪ್ರಾರಂಭಿಸುತ್ತದೆ, API ಸೇವೆಗಳು ವಿನಂತಿಗಳನ್ನು ನಿಷೇಧಿಸಲು ಪ್ರಾರಂಭಿಸುತ್ತವೆ, ಇತ್ಯಾದಿ. ಪರಿಸ್ಥಿತಿಯನ್ನು ಸ್ಥಿರಗೊಳಿಸಲು ಹತ್ತಾರು ನಿಮಿಷಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳಬಹುದು, ಮತ್ತು ಈ ಸಮಯದಲ್ಲಿ ಸೇವೆಯು ತುಂಬಾ ನಿಧಾನವಾಗಿರುತ್ತದೆ ಅಥವಾ ಸಂಪೂರ್ಣವಾಗಿ ಲಭ್ಯವಿಲ್ಲ.

ನಾವು ಒದಗಿಸಬೇಕಾಗಿತ್ತು ಕಡಿಮೆ ಪ್ರಯತ್ನದಿಂದ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಅಡ್ಡಲಾಗಿ ಅಳೆಯುವ ಸಾಮರ್ಥ್ಯ, ಅಂದರೆ ಮೂಲ ಕೋಡ್‌ಗೆ ಕನಿಷ್ಠ ಬದಲಾವಣೆಗಳೊಂದಿಗೆ ಮತ್ತು ಸಂಪೂರ್ಣ ಕಾರ್ಯವನ್ನು ಸಂರಕ್ಷಿಸಲಾಗಿದೆ. ಸಂಗ್ರಹವನ್ನು ವೈಫಲ್ಯಗಳಿಗೆ ನಿರೋಧಕವಾಗಿರುವಂತೆ ಮಾಡಿ, ಆದರೆ ಅದರಿಂದ ಡೇಟಾ ನಷ್ಟವನ್ನು ಕಡಿಮೆ ಮಾಡಲು ಪ್ರಯತ್ನಿಸಿ.

ಸ್ವತಃ memcached ತಪ್ಪು ಏನು?

ಸಾಮಾನ್ಯವಾಗಿ, PHP ಗಾಗಿ memcached ವಿಸ್ತರಣೆಯು ಬಾಕ್ಸ್‌ನ ಹೊರಗೆ ವಿತರಿಸಿದ ಡೇಟಾ ಮತ್ತು ಸೆಶನ್ ಸಂಗ್ರಹಣೆಯನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ. ಸ್ಥಿರವಾದ ಕೀ ಹ್ಯಾಶಿಂಗ್‌ನ ಕಾರ್ಯವಿಧಾನವು ಅನೇಕ ಸರ್ವರ್‌ಗಳಲ್ಲಿ ಡೇಟಾವನ್ನು ಸಮವಾಗಿ ವಿತರಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ, ಗುಂಪಿನಿಂದ ನಿರ್ದಿಷ್ಟ ಸರ್ವರ್‌ಗೆ ಪ್ರತಿ ನಿರ್ದಿಷ್ಟ ಕೀಲಿಯನ್ನು ಅನನ್ಯವಾಗಿ ತಿಳಿಸುತ್ತದೆ ಮತ್ತು ಅಂತರ್ನಿರ್ಮಿತ ವಿಫಲ ಸಾಧನಗಳು ಕ್ಯಾಶಿಂಗ್ ಸೇವೆಯ ಹೆಚ್ಚಿನ ಲಭ್ಯತೆಯನ್ನು ಖಚಿತಪಡಿಸುತ್ತವೆ (ಆದರೆ, ದುರದೃಷ್ಟವಶಾತ್, ಮಾಹಿತಿ ಇಲ್ಲ).

ಸೆಷನ್ ಸಂಗ್ರಹಣೆಯೊಂದಿಗೆ ವಿಷಯಗಳು ಸ್ವಲ್ಪ ಉತ್ತಮವಾಗಿವೆ: ನೀವು ಕಾನ್ಫಿಗರ್ ಮಾಡಬಹುದು memcached.sess_number_of_replicas, ಇದರ ಪರಿಣಾಮವಾಗಿ ಡೇಟಾವನ್ನು ಏಕಕಾಲದಲ್ಲಿ ಹಲವಾರು ಸರ್ವರ್‌ಗಳಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಒಂದು ಮೆಮ್‌ಕ್ಯಾಶ್ ಮಾಡಿದ ನಿದರ್ಶನದ ವೈಫಲ್ಯದ ಸಂದರ್ಭದಲ್ಲಿ, ಡೇಟಾವನ್ನು ಇತರರಿಂದ ವರ್ಗಾಯಿಸಲಾಗುತ್ತದೆ. ಆದಾಗ್ಯೂ, ಸರ್ವರ್ ಡೇಟಾ ಇಲ್ಲದೆ ಆನ್‌ಲೈನ್‌ಗೆ ಹಿಂತಿರುಗಿದರೆ (ಸಾಮಾನ್ಯವಾಗಿ ಮರುಪ್ರಾರಂಭಿಸಿದ ನಂತರ ಸಂಭವಿಸುತ್ತದೆ), ಕೆಲವು ಕೀಗಳನ್ನು ಅದರ ಪರವಾಗಿ ಮರುಹಂಚಿಕೆ ಮಾಡಲಾಗುತ್ತದೆ. ವಾಸ್ತವವಾಗಿ ಇದು ಅರ್ಥವಾಗುತ್ತದೆ ಅಧಿವೇಶನ ಡೇಟಾದ ನಷ್ಟ, ತಪ್ಪಿಹೋದ ಸಂದರ್ಭದಲ್ಲಿ ಮತ್ತೊಂದು ಪ್ರತಿಕೃತಿಗೆ "ಹೋಗಲು" ಯಾವುದೇ ಮಾರ್ಗವಿಲ್ಲದ ಕಾರಣ.

ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಲೈಬ್ರರಿ ಉಪಕರಣಗಳು ಮುಖ್ಯವಾಗಿ ಗುರಿಯನ್ನು ಹೊಂದಿವೆ ಸಮತಲ ಸ್ಕೇಲಿಂಗ್: ಸಂಗ್ರಹವನ್ನು ದೈತ್ಯಾಕಾರದ ಗಾತ್ರಗಳಿಗೆ ಹೆಚ್ಚಿಸಲು ಮತ್ತು ವಿವಿಧ ಸರ್ವರ್‌ಗಳಲ್ಲಿ ಹೋಸ್ಟ್ ಮಾಡಲಾದ ಕೋಡ್‌ನಿಂದ ಪ್ರವೇಶವನ್ನು ಒದಗಿಸಲು ಅವು ನಿಮಗೆ ಅವಕಾಶ ಮಾಡಿಕೊಡುತ್ತವೆ. ಆದಾಗ್ಯೂ, ನಮ್ಮ ಪರಿಸ್ಥಿತಿಯಲ್ಲಿ, ಸಂಗ್ರಹಿಸಿದ ಡೇಟಾದ ಪರಿಮಾಣವು ಹಲವಾರು ಗಿಗಾಬೈಟ್ಗಳನ್ನು ಮೀರುವುದಿಲ್ಲ, ಮತ್ತು ಒಂದು ಅಥವಾ ಎರಡು ನೋಡ್ಗಳ ಕಾರ್ಯಕ್ಷಮತೆ ಸಾಕಷ್ಟು ಸಾಕು. ಅಂತೆಯೇ, ಕೆಲಸದ ಸ್ಥಿತಿಯಲ್ಲಿ ಕನಿಷ್ಠ ಒಂದು ಸಂಗ್ರಹ ನಿದರ್ಶನವನ್ನು ನಿರ್ವಹಿಸುವಾಗ ಮೆಮ್‌ಕ್ಯಾಶ್ಡ್ ಲಭ್ಯತೆಯನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವುದು ಮಾತ್ರ ಉಪಯುಕ್ತ ಗುಣಮಟ್ಟದ ಸಾಧನವಾಗಿದೆ. ಆದಾಗ್ಯೂ, ಈ ಅವಕಾಶವನ್ನು ಸಹ ಬಳಸಿಕೊಳ್ಳಲು ಸಾಧ್ಯವಾಗಲಿಲ್ಲ ... ಇಲ್ಲಿ ಯೋಜನೆಯಲ್ಲಿ ಬಳಸಿದ ಚೌಕಟ್ಟಿನ ಪ್ರಾಚೀನತೆಯನ್ನು ನೆನಪಿಸಿಕೊಳ್ಳುವುದು ಯೋಗ್ಯವಾಗಿದೆ, ಅದಕ್ಕಾಗಿಯೇ ಸರ್ವರ್ಗಳ ಪೂಲ್ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಪಡೆಯುವುದು ಅಸಾಧ್ಯವಾಗಿತ್ತು. ಸೆಷನ್ ಡೇಟಾದ ನಷ್ಟದ ಬಗ್ಗೆಯೂ ನಾವು ಮರೆಯಬಾರದು: ಬಳಕೆದಾರರ ಬೃಹತ್ ಲಾಗ್‌ಔಟ್‌ನಿಂದ ಗ್ರಾಹಕರ ಕಣ್ಣುಗಳು ಸೆಟೆದುಕೊಂಡವು.

ತಾತ್ತ್ವಿಕವಾಗಿ ಇದು ಅಗತ್ಯವಾಗಿತ್ತು ಮೆಮ್‌ಕ್ಯಾಶ್ಡ್ ಮತ್ತು ಬೈಪಾಸ್ ಪ್ರತಿಕೃತಿಗಳಲ್ಲಿ ದಾಖಲೆಗಳ ಪ್ರತಿರೂಪ ತಪ್ಪು ಅಥವಾ ತಪ್ಪಿನ ಸಂದರ್ಭದಲ್ಲಿ. ಈ ತಂತ್ರವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ನಮಗೆ ಸಹಾಯ ಮಾಡಿದೆ mcrouter.

mcrouter

ಇದು ತನ್ನ ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸಲು ಫೇಸ್‌ಬುಕ್ ಅಭಿವೃದ್ಧಿಪಡಿಸಿದ ಮೆಮ್‌ಕ್ಯಾಶ್ಡ್ ರೂಟರ್ ಆಗಿದೆ. ಇದು ಅನುಮತಿಸುವ ಮೆಮ್‌ಕ್ಯಾಶ್ಡ್ ಟೆಕ್ಸ್ಟ್ ಪ್ರೋಟೋಕಾಲ್ ಅನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ ಪ್ರಮಾಣದ memcached ಅನುಸ್ಥಾಪನೆಗಳು ಹುಚ್ಚುತನದ ಪ್ರಮಾಣಕ್ಕೆ. Mcrouter ನ ವಿವರವಾದ ವಿವರಣೆಯನ್ನು ಕಾಣಬಹುದು ಈ ಪ್ರಕಟಣೆ. ಇತರ ವಿಷಯಗಳ ನಡುವೆ ವ್ಯಾಪಕ ಕಾರ್ಯವನ್ನು ಇದು ನಮಗೆ ಬೇಕಾದುದನ್ನು ಮಾಡಬಹುದು:

ರೆಕಾರ್ಡ್ ಪುನರಾವರ್ತಿಸಿ;
ದೋಷ ಸಂಭವಿಸಿದಲ್ಲಿ ಗುಂಪಿನಲ್ಲಿರುವ ಇತರ ಸರ್ವರ್‌ಗಳಿಗೆ ಹಿಂತಿರುಗಿ.

ವ್ಯವಹಾರಕ್ಕೆ ಇಳಿಯಿರಿ!

mcrouter ಸಂರಚನೆ

ನಾನು ನೇರವಾಗಿ ಸಂರಚನೆಗೆ ಹೋಗುತ್ತೇನೆ:

{
 "pools": {
   "pool00": {
     "servers": [
       "mc-0.mc:11211",
       "mc-1.mc:11211",
       "mc-2.mc:11211"
   },
   "pool01": {
     "servers": [
       "mc-1.mc:11211",
       "mc-2.mc:11211",
       "mc-0.mc:11211"
   },
   "pool02": {
     "servers": [
       "mc-2.mc:11211",
       "mc-0.mc:11211",
       "mc-1.mc:11211"
 },
 "route": {
   "type": "OperationSelectorRoute",
   "default_policy": "AllMajorityRoute|Pool|pool00",
   "operation_policies": {
     "get": {
       "type": "RandomRoute",
       "children": [
         "MissFailoverRoute|Pool|pool02",
         "MissFailoverRoute|Pool|pool00",
         "MissFailoverRoute|Pool|pool01"
       ]
     }
   }
 }
}

ಮೂರು ಕೊಳಗಳು ಏಕೆ? ಸರ್ವರ್‌ಗಳನ್ನು ಏಕೆ ಪುನರಾವರ್ತಿಸಲಾಗುತ್ತದೆ? ಇದು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡೋಣ.

ಈ ಸಂರಚನೆಯಲ್ಲಿ, ವಿನಂತಿಯ ಆಜ್ಞೆಯ ಆಧಾರದ ಮೇಲೆ ವಿನಂತಿಯನ್ನು ಕಳುಹಿಸುವ ಮಾರ್ಗವನ್ನು mcrouter ಆಯ್ಕೆ ಮಾಡುತ್ತದೆ. ಆ ವ್ಯಕ್ತಿ ಅವನಿಗೆ ಇದನ್ನು ಹೇಳುತ್ತಾನೆ OperationSelectorRoute.
GET ವಿನಂತಿಗಳು ಹ್ಯಾಂಡ್ಲರ್‌ಗೆ ಹೋಗುತ್ತವೆ RandomRouteಇದು ಯಾದೃಚ್ಛಿಕವಾಗಿ ರಚನೆಯ ವಸ್ತುಗಳ ನಡುವೆ ಪೂಲ್ ಅಥವಾ ಮಾರ್ಗವನ್ನು ಆಯ್ಕೆ ಮಾಡುತ್ತದೆ children. ಈ ರಚನೆಯ ಪ್ರತಿಯೊಂದು ಅಂಶವು ಪ್ರತಿಯಾಗಿ ಹ್ಯಾಂಡ್ಲರ್ ಆಗಿದೆ MissFailoverRoute, ಇದು ಡೇಟಾದೊಂದಿಗೆ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಸ್ವೀಕರಿಸುವವರೆಗೆ ಪೂಲ್‌ನಲ್ಲಿರುವ ಪ್ರತಿ ಸರ್ವರ್ ಮೂಲಕ ಹೋಗುತ್ತದೆ, ಅದನ್ನು ಕ್ಲೈಂಟ್‌ಗೆ ಹಿಂತಿರುಗಿಸಲಾಗುತ್ತದೆ.
ನಾವು ಪ್ರತ್ಯೇಕವಾಗಿ ಬಳಸಿದರೆ MissFailoverRoute ಮೂರು ಸರ್ವರ್‌ಗಳ ಪೂಲ್‌ನೊಂದಿಗೆ, ನಂತರ ಎಲ್ಲಾ ವಿನಂತಿಗಳು ಮೊದಲ ಮೆಮ್‌ಕ್ಯಾಶ್ಡ್ ನಿದರ್ಶನಕ್ಕೆ ಬರುತ್ತವೆ ಮತ್ತು ಉಳಿದವು ಯಾವುದೇ ಡೇಟಾ ಇಲ್ಲದಿದ್ದಾಗ ಉಳಿದ ಆಧಾರದ ಮೇಲೆ ವಿನಂತಿಗಳನ್ನು ಸ್ವೀಕರಿಸುತ್ತವೆ. ಅಂತಹ ವಿಧಾನವು ಕಾರಣವಾಗುತ್ತದೆ ಪಟ್ಟಿಯಲ್ಲಿರುವ ಮೊದಲ ಸರ್ವರ್‌ನಲ್ಲಿ ಅತಿಯಾದ ಲೋಡ್, ಆದ್ದರಿಂದ ವಿಭಿನ್ನ ಅನುಕ್ರಮಗಳಲ್ಲಿ ವಿಳಾಸಗಳೊಂದಿಗೆ ಮೂರು ಪೂಲ್‌ಗಳನ್ನು ರಚಿಸಲು ಮತ್ತು ಅವುಗಳನ್ನು ಯಾದೃಚ್ಛಿಕವಾಗಿ ಆಯ್ಕೆ ಮಾಡಲು ನಿರ್ಧರಿಸಲಾಯಿತು.
ಎಲ್ಲಾ ಇತರ ವಿನಂತಿಗಳನ್ನು (ಮತ್ತು ಇದು ದಾಖಲೆಯಾಗಿದೆ) ಬಳಸಿ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲಾಗುತ್ತದೆ AllMajorityRoute. ಈ ಹ್ಯಾಂಡ್ಲರ್ ಪೂಲ್‌ನಲ್ಲಿರುವ ಎಲ್ಲಾ ಸರ್ವರ್‌ಗಳಿಗೆ ವಿನಂತಿಗಳನ್ನು ಕಳುಹಿಸುತ್ತದೆ ಮತ್ತು ಅವುಗಳಲ್ಲಿ ಕನಿಷ್ಠ N/2 + 1 ರಿಂದ ಪ್ರತಿಕ್ರಿಯೆಗಳಿಗಾಗಿ ಕಾಯುತ್ತದೆ. ಬಳಕೆಯಿಂದ AllSyncRoute ಈ ವಿಧಾನಕ್ಕೆ ಸಕಾರಾತ್ಮಕ ಪ್ರತಿಕ್ರಿಯೆಯ ಅಗತ್ಯವಿರುವುದರಿಂದ ಬರೆಯುವ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಕೈಬಿಡಬೇಕಾಗಿತ್ತು всех ಗುಂಪಿನಲ್ಲಿರುವ ಸರ್ವರ್‌ಗಳು - ಇಲ್ಲದಿದ್ದರೆ ಅದು ಹಿಂತಿರುಗುತ್ತದೆ SERVER_ERROR. mcrouter ಲಭ್ಯವಿರುವ ಕ್ಯಾಶ್‌ಗಳಿಗೆ ಡೇಟಾವನ್ನು ಸೇರಿಸುತ್ತದೆಯಾದರೂ, ಕರೆ ಮಾಡುವ PHP ಕಾರ್ಯ ದೋಷವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ ಮತ್ತು ಸೂಚನೆಯನ್ನು ರಚಿಸುತ್ತದೆ. AllMajorityRoute ಅಷ್ಟು ಕಟ್ಟುನಿಟ್ಟಾಗಿಲ್ಲ ಮತ್ತು ಮೇಲೆ ವಿವರಿಸಿದ ಸಮಸ್ಯೆಗಳಿಲ್ಲದೆ ಅರ್ಧದಷ್ಟು ಘಟಕಗಳನ್ನು ಸೇವೆಯಿಂದ ತೆಗೆದುಹಾಕಲು ಅನುಮತಿಸುತ್ತದೆ.

ಮುಖ್ಯ ಅನಾನುಕೂಲತೆ ಈ ಯೋಜನೆಯು ನಿಜವಾಗಿಯೂ ಸಂಗ್ರಹದಲ್ಲಿ ಯಾವುದೇ ಡೇಟಾ ಇಲ್ಲದಿದ್ದರೆ, ಕ್ಲೈಂಟ್‌ನಿಂದ ಪ್ರತಿ ವಿನಂತಿಗೆ N ವಿನಂತಿಗಳನ್ನು memcached ಗೆ ವಾಸ್ತವವಾಗಿ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ - ಗೆ ಎಲ್ಲರಿಗೂ ಕೊಳದಲ್ಲಿ ಸರ್ವರ್ಗಳು. ನಾವು ಪೂಲ್‌ಗಳಲ್ಲಿನ ಸರ್ವರ್‌ಗಳ ಸಂಖ್ಯೆಯನ್ನು ಕಡಿಮೆ ಮಾಡಬಹುದು, ಉದಾಹರಣೆಗೆ, ಎರಡಕ್ಕೆ: ಶೇಖರಣಾ ವಿಶ್ವಾಸಾರ್ಹತೆಯನ್ನು ತ್ಯಾಗ ಮಾಡುವುದು, ನಾವು ಪಡೆಯುತ್ತೇವೆоಹೆಚ್ಚಿನ ವೇಗ ಮತ್ತು ವಿನಂತಿಗಳಿಂದ ಕಾಣೆಯಾದ ಕೀಗಳಿಗೆ ಕಡಿಮೆ ಲೋಡ್.

NB: ನೀವು mcrouter ಕಲಿಯಲು ಉಪಯುಕ್ತ ಲಿಂಕ್‌ಗಳನ್ನು ಸಹ ಕಾಣಬಹುದು ವಿಕಿಯಲ್ಲಿ ದಾಖಲಾತಿ и ಯೋಜನೆಯ ಸಮಸ್ಯೆಗಳು (ಮುಚ್ಚಿದವುಗಳನ್ನು ಒಳಗೊಂಡಂತೆ), ವಿವಿಧ ಸಂರಚನೆಗಳ ಸಂಪೂರ್ಣ ಉಗ್ರಾಣವನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ.

ಮ್ಯಾಕ್ರೂಟರ್ ಅನ್ನು ನಿರ್ಮಿಸುವುದು ಮತ್ತು ಚಾಲನೆ ಮಾಡುವುದು

ನಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ (ಮತ್ತು ಸ್ವತಃ memcached) ಕುಬರ್ನೆಟ್ಸ್ನಲ್ಲಿ ಚಲಿಸುತ್ತದೆ - ಅದರ ಪ್ರಕಾರ, mcrouter ಸಹ ಇದೆ. ಫಾರ್ ಕಂಟೇನರ್ ಜೋಡಣೆ ನಾವು ಬಳಸುತ್ತೇವೆ werf, ಇದಕ್ಕಾಗಿ ಸಂರಚನೆಯು ಈ ರೀತಿ ಕಾಣುತ್ತದೆ:

NB: ಲೇಖನದಲ್ಲಿ ನೀಡಲಾದ ಪಟ್ಟಿಗಳನ್ನು ಭಂಡಾರದಲ್ಲಿ ಪ್ರಕಟಿಸಲಾಗಿದೆ ಫ್ಲಾಂಟ್/ಮ್ಯಾಕ್ರೌಟರ್.

configVersion: 1
project: mcrouter
deploy:
 namespace: '[[ env ]]'
 helmRelease: '[[ project ]]-[[ env ]]'
---
image: mcrouter
from: ubuntu:16.04
mount:
- from: tmp_dir
 to: /var/lib/apt/lists
- from: build_dir
 to: /var/cache/apt
ansible:
 beforeInstall:
 - name: Install prerequisites
   apt:
     name: [ 'apt-transport-https', 'tzdata', 'locales' ]
     update_cache: yes
 - name: Add mcrouter APT key
   apt_key:
     url: https://facebook.github.io/mcrouter/debrepo/xenial/PUBLIC.KEY
 - name: Add mcrouter Repo
   apt_repository:
     repo: deb https://facebook.github.io/mcrouter/debrepo/xenial xenial contrib
     filename: mcrouter
     update_cache: yes
 - name: Set timezone
   timezone:
     name: "Europe/Moscow"
 - name: Ensure a locale exists
   locale_gen:
     name: en_US.UTF-8
     state: present
 install:
 - name: Install mcrouter
   apt:
     name: [ 'mcrouter' ]

(werf.yaml)

... ಮತ್ತು ಅದನ್ನು ಚಿತ್ರಿಸಿ ಹೆಲ್ಮ್ ಚಾರ್ಟ್. ಕುತೂಹಲಕಾರಿ ಸಂಗತಿಯೆಂದರೆ, ಪ್ರತಿಕೃತಿಗಳ ಸಂಖ್ಯೆಯನ್ನು ಆಧರಿಸಿ ಕಾನ್ಫಿಗರ್ ಜನರೇಟರ್ ಮಾತ್ರ ಇದೆ (ಯಾರಾದರೂ ಹೆಚ್ಚು ಲಕೋನಿಕ್ ಮತ್ತು ಸೊಗಸಾದ ಆಯ್ಕೆಯನ್ನು ಹೊಂದಿದ್ದರೆ, ಅದನ್ನು ಕಾಮೆಂಟ್‌ಗಳಲ್ಲಿ ಹಂಚಿಕೊಳ್ಳಿ):

{{- $count := (pluck .Values.global.env .Values.memcached.replicas | first | default .Values.memcached.replicas._default | int) -}}
{{- $pools := dict -}}
{{- $servers := list -}}
{{- /* Заполняем  массив двумя копиями серверов: "0 1 2 0 1 2" */ -}}
{{- range until 2 -}}
 {{- range $i, $_ := until $count -}}
   {{- $servers = append $servers (printf "mc-%d.mc:11211" $i) -}}
 {{- end -}}
{{- end -}}
{{- /* Смещаясь по массиву, получаем N срезов: "[0 1 2] [1 2 0] [2 0 1]" */ -}}
{{- range $i, $_ := until $count -}}
 {{- $pool := dict "servers" (slice $servers $i (add $i $count)) -}}
 {{- $_ := set $pools (printf "MissFailoverRoute|Pool|pool%02d" $i) $pool -}}
{{- end -}}
---
apiVersion: v1
kind: ConfigMap
metadata:
 name: mcrouter
data:
 config.json: |
   {
     "pools": {{- $pools | toJson | replace "MissFailoverRoute|Pool|" "" -}},
     "route": {
       "type": "OperationSelectorRoute",
       "default_policy": "AllMajorityRoute|Pool|pool00",
       "operation_policies": {
         "get": {
           "type": "RandomRoute",
           "children": {{- keys $pools | toJson }}
         }
       }
     }
   }

(10-mcrouter.yaml)

ನಾವು ಅದನ್ನು ಪರೀಕ್ಷಾ ಪರಿಸರಕ್ಕೆ ರೋಲ್ ಮಾಡುತ್ತೇವೆ ಮತ್ತು ಪರಿಶೀಲಿಸುತ್ತೇವೆ:

# php -a
Interactive mode enabled

php > # Проверяем запись и чтение
php > $m = new Memcached();
php > $m->addServer('mcrouter', 11211);
php > var_dump($m->set('test', 'value'));
bool(true)
php > var_dump($m->get('test'));
string(5) "value"
php > # Работает! Тестируем работу сессий:
php > ini_set('session.save_handler', 'memcached');
php > ini_set('session.save_path', 'mcrouter:11211');
php > var_dump(session_start());
PHP Warning:  Uncaught Error: Failed to create session ID: memcached (path: mcrouter:11211) in php shell code:1
Stack trace:
#0 php shell code(1): session_start()
#1 {main}
  thrown in php shell code on line 1
php > # Не заводится… Попробуем задать session_id:
php > session_id("zzz");
php > var_dump(session_start());
PHP Warning:  session_start(): Cannot send session cookie - headers already sent by (output started at php shell code:1) in php shell code on line 1
PHP Warning:  session_start(): Failed to write session lock: UNKNOWN READ FAILURE in php shell code on line 1
PHP Warning:  session_start(): Failed to write session lock: UNKNOWN READ FAILURE in php shell code on line 1
PHP Warning:  session_start(): Failed to write session lock: UNKNOWN READ FAILURE in php shell code on line 1
PHP Warning:  session_start(): Failed to write session lock: UNKNOWN READ FAILURE in php shell code on line 1
PHP Warning:  session_start(): Failed to write session lock: UNKNOWN READ FAILURE in php shell code on line 1
PHP Warning:  session_start(): Failed to write session lock: UNKNOWN READ FAILURE in php shell code on line 1
PHP Warning:  session_start(): Unable to clear session lock record in php shell code on line 1
PHP Warning:  session_start(): Failed to read session data: memcached (path: mcrouter:11211) in php shell code on line 1
bool(false)
php >

ದೋಷದ ಪಠ್ಯವನ್ನು ಹುಡುಕುವುದು ಯಾವುದೇ ಫಲಿತಾಂಶಗಳನ್ನು ನೀಡಲಿಲ್ಲ, ಆದರೆ ಪ್ರಶ್ನೆಗೆ "mcrouter php"ಯೋಜನೆಯ ಹಳೆಯ ಬಗೆಹರಿಯದ ಸಮಸ್ಯೆ ಮುಂಚೂಣಿಯಲ್ಲಿದೆ - ಬೆಂಬಲ ಕೊರತೆ memcached ಬೈನರಿ ಪ್ರೋಟೋಕಾಲ್.

NB: memcached ನಲ್ಲಿರುವ ASCII ಪ್ರೋಟೋಕಾಲ್ ಬೈನರಿ ಒಂದಕ್ಕಿಂತ ನಿಧಾನವಾಗಿರುತ್ತದೆ ಮತ್ತು ಸ್ಥಿರವಾದ ಕೀ ಹ್ಯಾಶಿಂಗ್‌ನ ಪ್ರಮಾಣಿತ ವಿಧಾನಗಳು ಬೈನರಿ ಪ್ರೋಟೋಕಾಲ್‌ನೊಂದಿಗೆ ಮಾತ್ರ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ. ಆದರೆ ಇದು ನಿರ್ದಿಷ್ಟ ಪ್ರಕರಣಕ್ಕೆ ಸಮಸ್ಯೆಗಳನ್ನು ಸೃಷ್ಟಿಸುವುದಿಲ್ಲ.

ಟ್ರಿಕ್ ಬ್ಯಾಗ್‌ನಲ್ಲಿದೆ: ನೀವು ಮಾಡಬೇಕಾಗಿರುವುದು ASCII ಪ್ರೋಟೋಕಾಲ್‌ಗೆ ಬದಲಾಯಿಸುವುದು ಮತ್ತು ಎಲ್ಲವೂ ಕೆಲಸ ಮಾಡುತ್ತದೆ.... ಆದಾಗ್ಯೂ, ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಉತ್ತರಗಳನ್ನು ಹುಡುಕುವ ಅಭ್ಯಾಸ php.net ನಲ್ಲಿ ದಸ್ತಾವೇಜನ್ನು ಕ್ರೂರ ಜೋಕ್ ಆಡಿದರು. ಅಲ್ಲಿ ನೀವು ಸರಿಯಾದ ಉತ್ತರವನ್ನು ಕಾಣುವುದಿಲ್ಲ... ಸಹಜವಾಗಿ, ನೀವು ಕೊನೆಯವರೆಗೂ ಸ್ಕ್ರಾಲ್ ಮಾಡದ ಹೊರತು, ವಿಭಾಗದಲ್ಲಿ ಎಲ್ಲಿ "ಬಳಕೆದಾರರ ಕೊಡುಗೆ ಟಿಪ್ಪಣಿಗಳು" ನಿಷ್ಠಾವಂತ ಮತ್ತು ಇರುತ್ತದೆ ಅನ್ಯಾಯವಾಗಿ ಡೌನ್‌ವೋಟ್ ಮಾಡಿದ ಉತ್ತರ.

ಹೌದು, ಸರಿಯಾದ ಆಯ್ಕೆಯ ಹೆಸರು memcached.sess_binary_protocol. ಇದನ್ನು ನಿಷ್ಕ್ರಿಯಗೊಳಿಸಬೇಕು, ಅದರ ನಂತರ ಸೆಷನ್‌ಗಳು ಕಾರ್ಯನಿರ್ವಹಿಸಲು ಪ್ರಾರಂಭಿಸುತ್ತವೆ. PHP ಯೊಂದಿಗೆ ಪಾಡ್‌ಗೆ mcrouter ನೊಂದಿಗೆ ಧಾರಕವನ್ನು ಹಾಕುವುದು ಮಾತ್ರ ಉಳಿದಿದೆ!

ತೀರ್ಮಾನಕ್ಕೆ

ಹೀಗಾಗಿ, ಕೇವಲ ಮೂಲಸೌಕರ್ಯ ಬದಲಾವಣೆಗಳೊಂದಿಗೆ ನಾವು ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲು ಸಾಧ್ಯವಾಯಿತು: memcached ತಪ್ಪು ಸಹಿಷ್ಣುತೆಯ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲಾಗಿದೆ ಮತ್ತು ಸಂಗ್ರಹ ಸಂಗ್ರಹಣೆಯ ವಿಶ್ವಾಸಾರ್ಹತೆಯನ್ನು ಹೆಚ್ಚಿಸಲಾಗಿದೆ. ಅಪ್ಲಿಕೇಶನ್‌ಗೆ ಸ್ಪಷ್ಟ ಪ್ರಯೋಜನಗಳ ಜೊತೆಗೆ, ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ನಲ್ಲಿ ಕೆಲಸ ಮಾಡುವಾಗ ಇದು ಕುಶಲತೆಗೆ ಅವಕಾಶವನ್ನು ನೀಡಿತು: ಎಲ್ಲಾ ಘಟಕಗಳು ಮೀಸಲು ಹೊಂದಿರುವಾಗ, ನಿರ್ವಾಹಕರ ಜೀವನವನ್ನು ಹೆಚ್ಚು ಸರಳಗೊಳಿಸಲಾಗುತ್ತದೆ. ಹೌದು, ಈ ವಿಧಾನವು ಅದರ ನ್ಯೂನತೆಗಳನ್ನು ಸಹ ಹೊಂದಿದೆ, ಇದು "ಊರುಗೋಲು" ನಂತೆ ಕಾಣಿಸಬಹುದು, ಆದರೆ ಅದು ಹಣವನ್ನು ಉಳಿಸಿದರೆ, ಸಮಸ್ಯೆಯನ್ನು ಹೂತುಹಾಕುತ್ತದೆ ಮತ್ತು ಹೊಸದನ್ನು ಉಂಟುಮಾಡುವುದಿಲ್ಲ - ಏಕೆ?

ಪಿಎಸ್

ನಮ್ಮ ಬ್ಲಾಗ್‌ನಲ್ಲಿಯೂ ಓದಿ:

"ಡಾಪ್‌ನೊಂದಿಗೆ ಅಭ್ಯಾಸ ಮಾಡಿ" (ಉದಾಹರಣೆಯಾಗಿ ಸಿಂಫೋನಿ-ಡೆಮೊ ಬಳಸಿ): ಭಾಗ 1 (ಸರಳ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸುವುದು) и ಭಾಗ 2 (ಹೆಲ್ಮ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಕುಬರ್ನೆಟ್ಸ್ಗೆ ಡಾಕರ್ ಚಿತ್ರಗಳನ್ನು ನಿಯೋಜಿಸುವುದು);
«ಕುಬರ್ನೆಟ್ಸ್ ಜೊತೆಗಿನ ಜೀವನದಿಂದ: HTTP ಸರ್ವರ್ ಸ್ಪೇನ್ ದೇಶದವರಿಗೆ ಹೇಗೆ ಒಲವು ತೋರಲಿಲ್ಲ».

ಮೂಲ: www.habr.com

ಮೆಮ್‌ಕ್ಯಾಶ್ಡ್ ಅನ್ನು ಅಡ್ಡಲಾಗಿ ಅಳೆಯಲು mcrouter ಅನ್ನು ಬಳಸುವುದು