🥇Tarantool ಕಾರ್ಟ್ರಿಡ್ಜ್: ಮೂರು ಸಾಲುಗಳಲ್ಲಿ ಲುವಾ ಬ್ಯಾಕೆಂಡ್ ಅನ್ನು ಹಂಚುವುದು

Mail.ru ಗುಂಪಿನಲ್ಲಿ ನಾವು Tarantool ಅನ್ನು ಹೊಂದಿದ್ದೇವೆ - ಇದು Lua ನಲ್ಲಿ ಅಪ್ಲಿಕೇಶನ್ ಸರ್ವರ್ ಆಗಿದೆ, ಇದು ಡೇಟಾಬೇಸ್ ಆಗಿ ದ್ವಿಗುಣಗೊಳ್ಳುತ್ತದೆ (ಅಥವಾ ಪ್ರತಿಯಾಗಿ?). ಇದು ವೇಗವಾಗಿ ಮತ್ತು ತಂಪಾಗಿದೆ, ಆದರೆ ಒಂದು ಸರ್ವರ್‌ನ ಸಾಮರ್ಥ್ಯಗಳು ಇನ್ನೂ ಅಪರಿಮಿತವಾಗಿಲ್ಲ. ವರ್ಟಿಕಲ್ ಸ್ಕೇಲಿಂಗ್ ಕೂಡ ರಾಮಬಾಣವಲ್ಲ, ಆದ್ದರಿಂದ ಟ್ಯಾರಂಟೂಲ್ ಸಮತಲ ಸ್ಕೇಲಿಂಗ್‌ಗೆ ಉಪಕರಣಗಳನ್ನು ಹೊಂದಿದೆ - vshard ಮಾಡ್ಯೂಲ್ [1]. ಹಲವಾರು ಸರ್ವರ್‌ಗಳಾದ್ಯಂತ ಡೇಟಾವನ್ನು ಚೂರು ಮಾಡಲು ಇದು ನಿಮ್ಮನ್ನು ಅನುಮತಿಸುತ್ತದೆ, ಆದರೆ ಅದನ್ನು ಹೊಂದಿಸಲು ಮತ್ತು ವ್ಯಾಪಾರ ತರ್ಕವನ್ನು ಲಗತ್ತಿಸಲು ನೀವು ಅದರೊಂದಿಗೆ ಟಿಂಕರ್ ಮಾಡಬೇಕು.

ಒಳ್ಳೆಯ ಸುದ್ದಿ: ನಾವು ಕೆಲವು ದೊಡ್ಡ ಹೊಡೆತಗಳನ್ನು ಸಂಗ್ರಹಿಸಿದ್ದೇವೆ (ಉದಾ [2], [3]) ಮತ್ತು ಈ ಸಮಸ್ಯೆಗೆ ಪರಿಹಾರವನ್ನು ಗಮನಾರ್ಹವಾಗಿ ಸರಳಗೊಳಿಸುವ ಮತ್ತೊಂದು ಚೌಕಟ್ಟನ್ನು ರಚಿಸಲಾಗಿದೆ.

ಟ್ಯಾರಂಟೂಲ್ ಕಾರ್ಟ್ರಿಡ್ಜ್ ಸಂಕೀರ್ಣ ವಿತರಣಾ ವ್ಯವಸ್ಥೆಗಳನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸಲು ಹೊಸ ಚೌಕಟ್ಟಾಗಿದೆ. ಮೂಲಸೌಕರ್ಯ ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸುವ ಬದಲು ವ್ಯವಹಾರ ತರ್ಕವನ್ನು ಬರೆಯುವುದರ ಮೇಲೆ ಕೇಂದ್ರೀಕರಿಸಲು ಇದು ನಿಮ್ಮನ್ನು ಅನುಮತಿಸುತ್ತದೆ. ಈ ಚೌಕಟ್ಟು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಮತ್ತು ಅದನ್ನು ಬಳಸಿಕೊಂಡು ವಿತರಿಸಿದ ಸೇವೆಗಳನ್ನು ಬರೆಯುವುದು ಹೇಗೆ ಎಂದು ಕಟ್ ಕೆಳಗೆ ನಾನು ನಿಮಗೆ ಹೇಳುತ್ತೇನೆ.

ಸಮಸ್ಯೆ ನಿಖರವಾಗಿ ಏನು?

ನಮ್ಮಲ್ಲಿ ಟಾರಂಟುಲಾ ಇದೆ, ನಮ್ಮಲ್ಲಿ ವಿಶಾರ್ಡ್ ಇದೆ - ನಿಮಗೆ ಇನ್ನೇನು ಬೇಕು?

ಮೊದಲನೆಯದಾಗಿ, ಇದು ಅನುಕೂಲತೆಯ ವಿಷಯವಾಗಿದೆ. vshard ಸಂರಚನೆಯನ್ನು Lua ಕೋಷ್ಟಕಗಳ ಮೂಲಕ ಕಾನ್ಫಿಗರ್ ಮಾಡಲಾಗಿದೆ. ಬಹು ಟ್ಯಾರಂಟೂಲ್ ಪ್ರಕ್ರಿಯೆಗಳ ವಿತರಣೆ ವ್ಯವಸ್ಥೆಯು ಸರಿಯಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸಲು, ಸಂರಚನೆಯು ಎಲ್ಲೆಡೆ ಒಂದೇ ಆಗಿರಬೇಕು. ಯಾರೂ ಇದನ್ನು ಹಸ್ತಚಾಲಿತವಾಗಿ ಮಾಡಲು ಬಯಸುವುದಿಲ್ಲ. ಆದ್ದರಿಂದ, ಎಲ್ಲಾ ರೀತಿಯ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳು, ಅನ್ಸಿಬಲ್ ಮತ್ತು ನಿಯೋಜನೆ ವ್ಯವಸ್ಥೆಗಳನ್ನು ಬಳಸಲಾಗುತ್ತದೆ.

ಕಾರ್ಟ್ರಿಡ್ಜ್ ಸ್ವತಃ vshard ಕಾನ್ಫಿಗರೇಶನ್ ಅನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ, ಅದರ ಆಧಾರದ ಮೇಲೆ ಇದನ್ನು ಮಾಡುತ್ತದೆ ಸ್ವಂತ ವಿತರಣೆ ಸಂರಚನೆ. ಇದು ಮೂಲಭೂತವಾಗಿ ಸರಳವಾದ YAML ಫೈಲ್ ಆಗಿದೆ, ಅದರ ನಕಲನ್ನು ಪ್ರತಿ ಟ್ಯಾರಂಟೂಲ್ ನಿದರ್ಶನದಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾಗುತ್ತದೆ. ಸರಳೀಕರಣವೆಂದರೆ ಫ್ರೇಮ್‌ವರ್ಕ್ ಸ್ವತಃ ಅದರ ಸಂರಚನೆಯನ್ನು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡುತ್ತದೆ ಮತ್ತು ಅದು ಎಲ್ಲೆಡೆ ಒಂದೇ ಆಗಿರುವುದನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ.

ಎರಡನೆಯದಾಗಿ, ಇದು ಮತ್ತೊಮ್ಮೆ ಅನುಕೂಲಕರ ವಿಷಯವಾಗಿದೆ. vshard ಸಂರಚನೆಯು ವ್ಯವಹಾರ ತರ್ಕದ ಅಭಿವೃದ್ಧಿಯೊಂದಿಗೆ ಯಾವುದೇ ಸಂಬಂಧವನ್ನು ಹೊಂದಿಲ್ಲ ಮತ್ತು ಪ್ರೋಗ್ರಾಮರ್ ಅನ್ನು ಅವನ ಕೆಲಸದಿಂದ ಮಾತ್ರ ಗಮನ ಸೆಳೆಯುತ್ತದೆ. ನಾವು ಪ್ರಾಜೆಕ್ಟ್‌ನ ವಾಸ್ತುಶಿಲ್ಪವನ್ನು ಚರ್ಚಿಸಿದಾಗ, ನಾವು ಹೆಚ್ಚಾಗಿ ಪ್ರತ್ಯೇಕ ಘಟಕಗಳು ಮತ್ತು ಅವುಗಳ ಪರಸ್ಪರ ಕ್ರಿಯೆಯ ಬಗ್ಗೆ ಮಾತನಾಡುತ್ತೇವೆ. 3 ಡೇಟಾ ಕೇಂದ್ರಗಳಿಗೆ ಕ್ಲಸ್ಟರ್ ಅನ್ನು ಹೊರತರುವ ಬಗ್ಗೆ ಯೋಚಿಸುವುದು ತುಂಬಾ ಮುಂಚೆಯೇ.

ನಾವು ಈ ಸಮಸ್ಯೆಗಳನ್ನು ಪದೇ ಪದೇ ಪರಿಹರಿಸಿದ್ದೇವೆ ಮತ್ತು ಕೆಲವು ಹಂತದಲ್ಲಿ ನಾವು ಅದರ ಸಂಪೂರ್ಣ ಜೀವನ ಚಕ್ರದಲ್ಲಿ ಅಪ್ಲಿಕೇಶನ್‌ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವ ವಿಧಾನವನ್ನು ಸರಳೀಕರಿಸುವ ವಿಧಾನವನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸುವಲ್ಲಿ ಯಶಸ್ವಿಯಾಗಿದ್ದೇವೆ: ರಚನೆ, ಅಭಿವೃದ್ಧಿ, ಪರೀಕ್ಷೆ, CI/CD, ನಿರ್ವಹಣೆ.

ಕಾರ್ಟ್ರಿಡ್ಜ್ ಪ್ರತಿ ಟ್ಯಾರಂಟೂಲ್ ಪ್ರಕ್ರಿಯೆಗೆ ಪಾತ್ರದ ಪರಿಕಲ್ಪನೆಯನ್ನು ಪರಿಚಯಿಸುತ್ತದೆ. ಪಾತ್ರಗಳು ಒಂದು ಪರಿಕಲ್ಪನೆಯಾಗಿದ್ದು ಅದು ಡೆವಲಪರ್‌ಗೆ ಕೋಡ್ ಬರೆಯುವುದರ ಮೇಲೆ ಕೇಂದ್ರೀಕರಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ಪ್ರಾಜೆಕ್ಟ್‌ನಲ್ಲಿ ಲಭ್ಯವಿರುವ ಎಲ್ಲಾ ಪಾತ್ರಗಳನ್ನು ಒಂದು ಟ್ಯಾರಂಟೂಲ್ ನಿದರ್ಶನದಲ್ಲಿ ಚಲಾಯಿಸಬಹುದು ಮತ್ತು ಇದು ಪರೀಕ್ಷೆಗಳಿಗೆ ಸಾಕಾಗುತ್ತದೆ.

ಟ್ಯಾರಂಟೂಲ್ ಕಾರ್ಟ್ರಿಡ್ಜ್ನ ಪ್ರಮುಖ ಲಕ್ಷಣಗಳು:

ಸ್ವಯಂಚಾಲಿತ ಕ್ಲಸ್ಟರ್ ಆರ್ಕೆಸ್ಟ್ರೇಶನ್;
ಹೊಸ ಪಾತ್ರಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಅಪ್ಲಿಕೇಶನ್‌ನ ಕಾರ್ಯವನ್ನು ವಿಸ್ತರಿಸುವುದು;
ಅಭಿವೃದ್ಧಿ ಮತ್ತು ನಿಯೋಜನೆಗಾಗಿ ಅಪ್ಲಿಕೇಶನ್ ಟೆಂಪ್ಲೇಟ್;
ಅಂತರ್ನಿರ್ಮಿತ ಸ್ವಯಂಚಾಲಿತ ಶರ್ಡಿಂಗ್;
ಲುಟೆಸ್ಟ್ ಪರೀಕ್ಷಾ ಚೌಕಟ್ಟಿನೊಂದಿಗೆ ಏಕೀಕರಣ;
WebUI ಮತ್ತು API ಬಳಸಿಕೊಂಡು ಕ್ಲಸ್ಟರ್ ನಿರ್ವಹಣೆ;
ಪ್ಯಾಕೇಜಿಂಗ್ ಮತ್ತು ನಿಯೋಜನೆ ಉಪಕರಣಗಳು.

ಹಲೋ, ವಿಶ್ವ!

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

$ tarantoolctl rocks install cartridge-cli
$ export PATH=$PWD/.rocks/bin/:$PATH

ಈ ಎರಡು ಆಜ್ಞೆಗಳು ಆಜ್ಞಾ ಸಾಲಿನ ಉಪಯುಕ್ತತೆಗಳನ್ನು ಸ್ಥಾಪಿಸುತ್ತವೆ ಮತ್ತು ಟೆಂಪ್ಲೇಟ್‌ನಿಂದ ನಿಮ್ಮ ಮೊದಲ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ರಚಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ:

$ cartridge create --name myapp

ಮತ್ತು ನಾವು ಪಡೆಯುವುದು ಇದನ್ನೇ:

myapp/
├── .git/
├── .gitignore
├── app/roles/custom.lua
├── deps.sh
├── init.lua
├── myapp-scm-1.rockspec
├── test
│   ├── helper
│   │   ├── integration.lua
│   │   └── unit.lua
│   ├── helper.lua
│   ├── integration/api_test.lua
│   └── unit/sample_test.lua
└── tmp/

ಇದು ಸಿದ್ಧವಾದ “ಹಲೋ, ವರ್ಲ್ಡ್!” ಹೊಂದಿರುವ ಜಿಟ್ ರೆಪೊಸಿಟರಿಯಾಗಿದೆ. ಅಪ್ಲಿಕೇಶನ್. ಈ ಹಿಂದೆ ಅವಲಂಬನೆಗಳನ್ನು ಸ್ಥಾಪಿಸಿದ ನಂತರ (ಫ್ರೇಮ್‌ವರ್ಕ್ ಅನ್ನು ಒಳಗೊಂಡಂತೆ) ಅದನ್ನು ಈಗಿನಿಂದಲೇ ಚಲಾಯಿಸಲು ಪ್ರಯತ್ನಿಸೋಣ:

$ tarantoolctl rocks make
$ ./init.lua --http-port 8080

ಆದ್ದರಿಂದ, ಭವಿಷ್ಯದ ಷರ್ಡೆಡ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಾಗಿ ನಾವು ಒಂದು ನೋಡ್ ಅನ್ನು ಹೊಂದಿದ್ದೇವೆ. ಜಿಜ್ಞಾಸೆಯ ಸಾಮಾನ್ಯ ವ್ಯಕ್ತಿ ತಕ್ಷಣವೇ ವೆಬ್ ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ತೆರೆಯಬಹುದು, ಮೌಸ್ನೊಂದಿಗೆ ಒಂದು ನೋಡ್ನ ಕ್ಲಸ್ಟರ್ ಅನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡಬಹುದು ಮತ್ತು ಫಲಿತಾಂಶವನ್ನು ಆನಂದಿಸಬಹುದು, ಆದರೆ ಇದು ಸಂತೋಷಪಡಲು ತುಂಬಾ ಮುಂಚೆಯೇ. ಇಲ್ಲಿಯವರೆಗೆ, ಅಪ್ಲಿಕೇಶನ್ ಉಪಯುಕ್ತವಾದ ಏನನ್ನೂ ಮಾಡಲು ಸಾಧ್ಯವಿಲ್ಲ, ಆದ್ದರಿಂದ ನಾನು ನಂತರ ನಿಯೋಜನೆಯ ಬಗ್ಗೆ ಹೇಳುತ್ತೇನೆ, ಆದರೆ ಈಗ ಕೋಡ್ ಬರೆಯುವ ಸಮಯ.

ಅಪ್ಲಿಕೇಶನ್ ಅಭಿವೃದ್ಧಿ

ಕೇವಲ ಊಹಿಸಿ, ಡೇಟಾವನ್ನು ಸ್ವೀಕರಿಸಲು, ಅದನ್ನು ಉಳಿಸಲು ಮತ್ತು ದಿನಕ್ಕೆ ಒಮ್ಮೆ ವರದಿಯನ್ನು ನಿರ್ಮಿಸಲು ನಾವು ಯೋಜನೆಯನ್ನು ವಿನ್ಯಾಸಗೊಳಿಸುತ್ತಿದ್ದೇವೆ.

ನಾವು ರೇಖಾಚಿತ್ರವನ್ನು ಚಿತ್ರಿಸಲು ಪ್ರಾರಂಭಿಸುತ್ತೇವೆ ಮತ್ತು ಅದರ ಮೇಲೆ ಮೂರು ಘಟಕಗಳನ್ನು ಇರಿಸುತ್ತೇವೆ: ಗೇಟ್ವೇ, ಸಂಗ್ರಹಣೆ ಮತ್ತು ವೇಳಾಪಟ್ಟಿ. ನಾವು ಮತ್ತಷ್ಟು ವಾಸ್ತುಶಿಲ್ಪದಲ್ಲಿ ಕೆಲಸ ಮಾಡುತ್ತಿದ್ದೇವೆ. ನಾವು vshard ಅನ್ನು ಸಂಗ್ರಹಣೆಯಾಗಿ ಬಳಸುವುದರಿಂದ, ನಾವು ಸ್ಕೀಮ್‌ಗೆ vshard-router ಮತ್ತು vshard-storage ಅನ್ನು ಸೇರಿಸುತ್ತೇವೆ. ಗೇಟ್‌ವೇ ಅಥವಾ ಶೆಡ್ಯೂಲರ್ ನೇರವಾಗಿ ಸಂಗ್ರಹಣೆಯನ್ನು ಪ್ರವೇಶಿಸುವುದಿಲ್ಲ, ಅದಕ್ಕಾಗಿಯೇ ರೂಟರ್ ಅನ್ನು ರಚಿಸಲಾಗಿದೆ.

ಈ ರೇಖಾಚಿತ್ರವು ಇನ್ನೂ ನಾವು ಯೋಜನೆಯಲ್ಲಿ ಏನನ್ನು ನಿರ್ಮಿಸಲಿದ್ದೇವೆ ಎಂಬುದನ್ನು ನಿಖರವಾಗಿ ಪ್ರತಿನಿಧಿಸುವುದಿಲ್ಲ ಏಕೆಂದರೆ ಘಟಕಗಳು ಅಮೂರ್ತವಾಗಿ ಕಾಣುತ್ತವೆ. ಇದು ನಿಜವಾದ ಟ್ಯಾರಂಟೂಲ್‌ನಲ್ಲಿ ಹೇಗೆ ಪ್ರಕ್ಷೇಪಿಸಲ್ಪಡುತ್ತದೆ ಎಂಬುದನ್ನು ನಾವು ಇನ್ನೂ ನೋಡಬೇಕಾಗಿದೆ - ಪ್ರಕ್ರಿಯೆಯ ಮೂಲಕ ನಮ್ಮ ಘಟಕಗಳನ್ನು ಗುಂಪು ಮಾಡೋಣ.

ಪ್ರತ್ಯೇಕ ನಿದರ್ಶನಗಳಲ್ಲಿ vshard-router ಮತ್ತು ಗೇಟ್‌ವೇ ಇಡುವುದರಲ್ಲಿ ಸ್ವಲ್ಪ ಅರ್ಥವಿಲ್ಲ. ಇದು ಈಗಾಗಲೇ ರೂಟರ್‌ನ ಜವಾಬ್ದಾರಿಯಾಗಿದ್ದರೆ ನಾವು ಮತ್ತೊಮ್ಮೆ ನೆಟ್‌ವರ್ಕ್ ಅನ್ನು ಏಕೆ ಸರ್ಫ್ ಮಾಡಬೇಕಾಗಿದೆ? ಅವುಗಳನ್ನು ಅದೇ ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ ನಡೆಸಬೇಕು. ಅಂದರೆ, ಗೇಟ್‌ವೇ ಮತ್ತು vshard.router.cfg ಎರಡನ್ನೂ ಒಂದು ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ ಪ್ರಾರಂಭಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಅವು ಸ್ಥಳೀಯವಾಗಿ ಸಂವಹನ ಮಾಡಲಿ.

ವಿನ್ಯಾಸ ಹಂತದಲ್ಲಿ, ಮೂರು ಘಟಕಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಅನುಕೂಲಕರವಾಗಿದೆ, ಆದರೆ ನಾನು, ಡೆವಲಪರ್ ಆಗಿ, ಕೋಡ್ ಬರೆಯುವಾಗ, ಟಾರ್ನಾಟೂಲ್ನ ಮೂರು ನಿದರ್ಶನಗಳನ್ನು ಪ್ರಾರಂಭಿಸುವ ಬಗ್ಗೆ ಯೋಚಿಸಲು ಬಯಸುವುದಿಲ್ಲ. ನಾನು ಪರೀಕ್ಷೆಗಳನ್ನು ನಡೆಸಬೇಕಾಗಿದೆ ಮತ್ತು ನಾನು ಗೇಟ್‌ವೇಯನ್ನು ಸರಿಯಾಗಿ ಬರೆದಿದ್ದೇನೆ ಎಂದು ಪರಿಶೀಲಿಸಬೇಕಾಗಿದೆ. ಅಥವಾ ಬಹುಶಃ ನಾನು ನನ್ನ ಸಹೋದ್ಯೋಗಿಗಳಿಗೆ ವೈಶಿಷ್ಟ್ಯವನ್ನು ಪ್ರದರ್ಶಿಸಲು ಬಯಸುತ್ತೇನೆ. ಮೂರು ಪ್ರತಿಗಳನ್ನು ನಿಯೋಜಿಸುವ ಜಗಳದ ಮೂಲಕ ನಾನು ಏಕೆ ಹೋಗಬೇಕು? ಪಾತ್ರಗಳ ಪರಿಕಲ್ಪನೆ ಹುಟ್ಟಿದ್ದು ಹೀಗೆ. ಒಂದು ಪಾತ್ರವು ನಿಯಮಿತ ಲುಶ್ ಮಾಡ್ಯೂಲ್ ಆಗಿದ್ದು ಅದರ ಜೀವನ ಚಕ್ರವನ್ನು ಕಾರ್ಟ್ರಿಡ್ಜ್ ನಿರ್ವಹಿಸುತ್ತದೆ. ಈ ಉದಾಹರಣೆಯಲ್ಲಿ ಅವುಗಳಲ್ಲಿ ನಾಲ್ಕು ಇವೆ - ಗೇಟ್‌ವೇ, ರೂಟರ್, ಸ್ಟೋರೇಜ್, ಶೆಡ್ಯೂಲರ್. ಇನ್ನೊಂದು ಯೋಜನೆಯಲ್ಲಿ ಇನ್ನಷ್ಟು ಇರಬಹುದು. ಎಲ್ಲಾ ಪಾತ್ರಗಳನ್ನು ಒಂದು ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ ಚಲಾಯಿಸಬಹುದು, ಮತ್ತು ಇದು ಸಾಕಷ್ಟು ಇರುತ್ತದೆ.

ಮತ್ತು ಇದು ಸ್ಟೇಜಿಂಗ್ ಅಥವಾ ಉತ್ಪಾದನೆಗೆ ನಿಯೋಜನೆಗೆ ಬಂದಾಗ, ನಾವು ಹಾರ್ಡ್‌ವೇರ್ ಸಾಮರ್ಥ್ಯಗಳನ್ನು ಅವಲಂಬಿಸಿ ಪ್ರತಿಯೊಂದು ಟ್ಯಾರಂಟೂಲ್ ಪ್ರಕ್ರಿಯೆಗೆ ತನ್ನದೇ ಆದ ಪಾತ್ರಗಳನ್ನು ನಿಯೋಜಿಸುತ್ತೇವೆ:

ಟೋಪೋಲಜಿ ನಿರ್ವಹಣೆ

ಯಾವ ಪಾತ್ರಗಳು ಚಾಲನೆಯಲ್ಲಿವೆ ಎಂಬ ಮಾಹಿತಿಯನ್ನು ಎಲ್ಲೋ ಸಂಗ್ರಹಿಸಬೇಕು. ಮತ್ತು ಇದು "ಎಲ್ಲೋ" ವಿತರಣೆಯ ಸಂರಚನೆಯಾಗಿದೆ, ನಾನು ಈಗಾಗಲೇ ಮೇಲೆ ಉಲ್ಲೇಖಿಸಿದ್ದೇನೆ. ಅದರ ಬಗ್ಗೆ ಅತ್ಯಂತ ಮುಖ್ಯವಾದ ವಿಷಯವೆಂದರೆ ಕ್ಲಸ್ಟರ್ ಟೋಪೋಲಜಿ. 3 ಟ್ಯಾರಂಟೂಲ್ ಪ್ರಕ್ರಿಯೆಗಳ 5 ನಕಲು ಗುಂಪುಗಳು ಇಲ್ಲಿವೆ:

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

ಟೋಪೋಲಜಿ ವಿಭಾಗದಲ್ಲಿ, ಪ್ರತಿ ನಕಲು ಗುಂಪಿನ ನಾಯಕನಂತಹ ಪ್ರಮುಖ ನಿಯತಾಂಕವನ್ನು ಸೂಚಿಸಲಾಗುತ್ತದೆ. ಸಾಮಾನ್ಯವಾಗಿ ಇದು ರೆಕಾರ್ಡ್ ಆಗುತ್ತಿರುವ ಪ್ರತಿಯಾಗಿದೆ. ವಿನಾಯಿತಿಗಳಿದ್ದರೂ ಉಳಿದವುಗಳು ಹೆಚ್ಚಾಗಿ ಓದಲು ಮಾತ್ರ. ಕೆಲವೊಮ್ಮೆ ಕೆಚ್ಚೆದೆಯ ಅಭಿವರ್ಧಕರು ಘರ್ಷಣೆಗಳಿಗೆ ಹೆದರುವುದಿಲ್ಲ ಮತ್ತು ಸಮಾನಾಂತರವಾಗಿ ಹಲವಾರು ಪ್ರತಿಕೃತಿಗಳಿಗೆ ಡೇಟಾವನ್ನು ಬರೆಯಬಹುದು, ಆದರೆ ಕೆಲವು ಕಾರ್ಯಾಚರಣೆಗಳಿವೆ, ಏನೇ ಇರಲಿ, ಎರಡು ಬಾರಿ ನಿರ್ವಹಿಸಬಾರದು. ಇದಕ್ಕಾಗಿ ನಾಯಕನ ಚಿಹ್ನೆ ಇದೆ.

ಪಾತ್ರಗಳ ಜೀವನ

ಅಂತಹ ವಾಸ್ತುಶಿಲ್ಪದಲ್ಲಿ ಅಮೂರ್ತ ಪಾತ್ರವು ಅಸ್ತಿತ್ವದಲ್ಲಿರಲು, ಚೌಕಟ್ಟು ಅವುಗಳನ್ನು ಹೇಗಾದರೂ ನಿರ್ವಹಿಸಬೇಕು. ಸ್ವಾಭಾವಿಕವಾಗಿ, ಟ್ಯಾರಂಟೂಲ್ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಮರುಪ್ರಾರಂಭಿಸದೆಯೇ ನಿಯಂತ್ರಣವು ಸಂಭವಿಸುತ್ತದೆ. ಪಾತ್ರಗಳನ್ನು ನಿರ್ವಹಿಸಲು 4 ಕಾಲ್‌ಬ್ಯಾಕ್‌ಗಳಿವೆ. ಕಾರ್ಟ್ರಿಡ್ಜ್ ಸ್ವತಃ ಅದರ ವಿತರಿಸಿದ ಸಂರಚನೆಯಲ್ಲಿ ಏನು ಬರೆಯಲಾಗಿದೆ ಎಂಬುದರ ಆಧಾರದ ಮೇಲೆ ಅವುಗಳನ್ನು ಕರೆಯುತ್ತದೆ, ಇದರಿಂದಾಗಿ ನಿರ್ದಿಷ್ಟ ಪಾತ್ರಗಳಿಗೆ ಸಂರಚನೆಯನ್ನು ಅನ್ವಯಿಸುತ್ತದೆ.

function init()
function validate_config()
function apply_config()
function stop()

ಪ್ರತಿಯೊಂದು ಪಾತ್ರಕ್ಕೂ ಒಂದು ಕಾರ್ಯವಿದೆ init. ಪಾತ್ರವನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಿದಾಗ ಅಥವಾ ಟ್ಯಾರಂಟೂಲ್ ಅನ್ನು ಮರುಪ್ರಾರಂಭಿಸಿದಾಗ ಇದನ್ನು ಒಮ್ಮೆ ಕರೆಯಲಾಗುತ್ತದೆ. ಅಲ್ಲಿ ಅನುಕೂಲಕರವಾಗಿದೆ, ಉದಾಹರಣೆಗೆ, box.space.create ಅನ್ನು ಪ್ರಾರಂಭಿಸಲು, ಅಥವಾ ಶೆಡ್ಯೂಲರ್ ಕೆಲವು ಹಿನ್ನೆಲೆ ಫೈಬರ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಬಹುದು ಅದು ನಿರ್ದಿಷ್ಟ ಸಮಯದ ಮಧ್ಯಂತರದಲ್ಲಿ ಕೆಲಸ ಮಾಡುತ್ತದೆ.

ಒಂದು ಕಾರ್ಯ init ಸಾಕಾಗದೇ ಇರಬಹುದು. ಕಾರ್ಟ್ರಿಡ್ಜ್ ಟೋಪೋಲಜಿಯನ್ನು ಸಂಗ್ರಹಿಸಲು ಬಳಸುವ ವಿತರಣಾ ಸಂರಚನೆಯ ಲಾಭವನ್ನು ಪಡೆಯಲು ಪಾತ್ರಗಳನ್ನು ಅನುಮತಿಸುತ್ತದೆ. ನಾವು ಅದೇ ಕಾನ್ಫಿಗರೇಶನ್‌ನಲ್ಲಿ ಹೊಸ ವಿಭಾಗವನ್ನು ಘೋಷಿಸಬಹುದು ಮತ್ತು ಅದರಲ್ಲಿ ವ್ಯಾಪಾರ ಕಾನ್ಫಿಗರೇಶನ್‌ನ ತುಣುಕನ್ನು ಸಂಗ್ರಹಿಸಬಹುದು. ನನ್ನ ಉದಾಹರಣೆಯಲ್ಲಿ, ಇದು ಶೆಡ್ಯೂಲರ್ ಪಾತ್ರಕ್ಕಾಗಿ ಡೇಟಾ ಸ್ಕೀಮಾ ಅಥವಾ ವೇಳಾಪಟ್ಟಿ ಸೆಟ್ಟಿಂಗ್‌ಗಳಾಗಿರಬಹುದು.

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

ಪಾತ್ರಗಳಿಗೂ ಒಂದು ವಿಧಾನವಿದೆ stop, ಇದು ಪಾತ್ರದ ಔಟ್‌ಪುಟ್ ಅನ್ನು ಸ್ವಚ್ಛಗೊಳಿಸಲು ಅಗತ್ಯವಿದೆ. ಈ ಸರ್ವರ್‌ನಲ್ಲಿ ಶೆಡ್ಯೂಲರ್ ಇನ್ನು ಮುಂದೆ ಅಗತ್ಯವಿಲ್ಲ ಎಂದು ನಾವು ಹೇಳಿದರೆ, ಅದು ಪ್ರಾರಂಭಿಸಿದ ಫೈಬರ್‌ಗಳನ್ನು ಅದು ನಿಲ್ಲಿಸಬಹುದು init.

ಪಾತ್ರಗಳು ಪರಸ್ಪರ ಸಂವಹನ ನಡೆಸಬಹುದು. ನಾವು ಲುವಾದಲ್ಲಿ ಫಂಕ್ಷನ್ ಕರೆಗಳನ್ನು ಬರೆಯಲು ಬಳಸಲಾಗುತ್ತದೆ, ಆದರೆ ನಿರ್ದಿಷ್ಟ ಪ್ರಕ್ರಿಯೆಯು ನಮಗೆ ಅಗತ್ಯವಿರುವ ಪಾತ್ರವನ್ನು ಹೊಂದಿಲ್ಲ ಎಂದು ಸಂಭವಿಸಬಹುದು. ನೆಟ್‌ವರ್ಕ್ ಮೂಲಕ ಕರೆಗಳನ್ನು ಸುಗಮಗೊಳಿಸಲು, ನಾವು rpc (ರಿಮೋಟ್ ಪ್ರೊಸೀಜರ್ ಕರೆ) ಸಹಾಯಕ ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಬಳಸುತ್ತೇವೆ, ಇದನ್ನು Tarantool ನಲ್ಲಿ ನಿರ್ಮಿಸಲಾದ ಪ್ರಮಾಣಿತ ನೆಟ್‌ಬಾಕ್ಸ್‌ನ ಆಧಾರದ ಮೇಲೆ ನಿರ್ಮಿಸಲಾಗಿದೆ. ಉದಾಹರಣೆಗೆ, ನಿಮ್ಮ ಗೇಟ್‌ವೇ ಒಂದು ದಿನ ಕಾಯುವ ಬದಲು ಇದೀಗ ಕೆಲಸವನ್ನು ಮಾಡಲು ಶೆಡ್ಯೂಲರ್‌ಗೆ ನೇರವಾಗಿ ಕೇಳಲು ಬಯಸಿದರೆ ಇದು ಉಪಯುಕ್ತವಾಗಿರುತ್ತದೆ.

ಮತ್ತೊಂದು ಪ್ರಮುಖ ಅಂಶವೆಂದರೆ ದೋಷ ಸಹಿಷ್ಣುತೆಯನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವುದು. ಕಾರ್ಟ್ರಿಡ್ಜ್ ಆರೋಗ್ಯವನ್ನು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡಲು SWIM ಪ್ರೋಟೋಕಾಲ್ ಅನ್ನು ಬಳಸುತ್ತದೆ [4]. ಸಂಕ್ಷಿಪ್ತವಾಗಿ ಹೇಳುವುದಾದರೆ, ಪ್ರಕ್ರಿಯೆಗಳು UDP ಮೂಲಕ ಪರಸ್ಪರ "ವದಂತಿಗಳನ್ನು" ವಿನಿಮಯ ಮಾಡಿಕೊಳ್ಳುತ್ತವೆ-ಪ್ರತಿಯೊಂದು ಪ್ರಕ್ರಿಯೆಯು ತನ್ನ ನೆರೆಹೊರೆಯವರಿಗೆ ಇತ್ತೀಚಿನ ಸುದ್ದಿಗಳನ್ನು ಹೇಳುತ್ತದೆ ಮತ್ತು ಅವರು ಪ್ರತಿಕ್ರಿಯಿಸುತ್ತಾರೆ. ಇದ್ದಕ್ಕಿದ್ದಂತೆ ಉತ್ತರ ಬರದಿದ್ದರೆ, ಟ್ಯಾರಂಟೂಲ್ ಏನಾದರೂ ತಪ್ಪಾಗಿದೆ ಎಂದು ಅನುಮಾನಿಸಲು ಪ್ರಾರಂಭಿಸುತ್ತದೆ, ಮತ್ತು ಸ್ವಲ್ಪ ಸಮಯದ ನಂತರ ಅದು ಮರಣವನ್ನು ಪಠಿಸುತ್ತದೆ ಮತ್ತು ಈ ಸುದ್ದಿಯನ್ನು ಸುತ್ತಲಿನ ಎಲ್ಲರಿಗೂ ಹೇಳಲು ಪ್ರಾರಂಭಿಸುತ್ತದೆ.

ಈ ಪ್ರೋಟೋಕಾಲ್ ಅನ್ನು ಆಧರಿಸಿ, ಕಾರ್ಟ್ರಿಡ್ಜ್ ಸ್ವಯಂಚಾಲಿತ ವೈಫಲ್ಯ ಸಂಸ್ಕರಣೆಯನ್ನು ಆಯೋಜಿಸುತ್ತದೆ. ಪ್ರತಿಯೊಂದು ಪ್ರಕ್ರಿಯೆಯು ಅದರ ಪರಿಸರವನ್ನು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡುತ್ತದೆ ಮತ್ತು ನಾಯಕನು ಇದ್ದಕ್ಕಿದ್ದಂತೆ ಪ್ರತಿಕ್ರಿಯಿಸುವುದನ್ನು ನಿಲ್ಲಿಸಿದರೆ, ಪ್ರತಿಕೃತಿಯು ಅದರ ಪಾತ್ರವನ್ನು ವಹಿಸಿಕೊಳ್ಳಬಹುದು ಮತ್ತು ಕಾರ್ಟ್ರಿಡ್ಜ್ ಅದಕ್ಕೆ ಅನುಗುಣವಾಗಿ ಚಾಲನೆಯಲ್ಲಿರುವ ಪಾತ್ರಗಳನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡುತ್ತದೆ.

ನೀವು ಇಲ್ಲಿ ಜಾಗರೂಕರಾಗಿರಬೇಕು, ಏಕೆಂದರೆ ಪದೇ ಪದೇ ಹಿಂದಕ್ಕೆ ಮತ್ತು ಮುಂದಕ್ಕೆ ಬದಲಾಯಿಸುವುದು ಪುನರಾವರ್ತನೆಯ ಸಮಯದಲ್ಲಿ ಡೇಟಾ ಸಂಘರ್ಷಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದು. ಸಹಜವಾಗಿ, ನೀವು ಯಾದೃಚ್ಛಿಕವಾಗಿ ಸ್ವಯಂಚಾಲಿತ ವೈಫಲ್ಯವನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಬಾರದು. ಏನಾಗುತ್ತಿದೆ ಎಂಬುದನ್ನು ನಾವು ಸ್ಪಷ್ಟವಾಗಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಬೇಕು ಮತ್ತು ನಾಯಕನನ್ನು ಪುನಃಸ್ಥಾಪಿಸಿದ ನಂತರ ಮತ್ತು ಕಿರೀಟವನ್ನು ಅವನಿಗೆ ಹಿಂತಿರುಗಿಸಿದ ನಂತರ ಪುನರಾವರ್ತನೆಯು ಮುರಿಯುವುದಿಲ್ಲ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.

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

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

ನಿಯೋಜನೆ ಉಪಕರಣಗಳು

ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿಯೋಜಿಸಲು ಕಾರ್ಟ್ರಿಡ್ಜ್ ಹೇಗೆ ಸಹಾಯ ಮಾಡುತ್ತದೆ ಎಂಬುದನ್ನು ತೋರಿಸಲು ನಾನು ಭರವಸೆ ನೀಡಿದ್ದೇನೆ. ಇತರರಿಗೆ ಜೀವನವನ್ನು ಸುಲಭಗೊಳಿಸಲು, ಫ್ರೇಮ್‌ವರ್ಕ್ ಪ್ಯಾಕೇಜ್‌ಗಳು RPM ಪ್ಯಾಕೇಜ್‌ಗಳು:

$ cartridge pack rpm myapp -- упакует для нас ./myapp-0.1.0-1.rpm
$ sudo yum install ./myapp-0.1.0-1.rpm

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

$ sudo tee /etc/tarantool/conf.d/demo.yml <<CONFIG
myapp.router: {"advertise_uri": "localhost:3301", "http_port": 8080}
myapp.storage_A: {"advertise_uri": "localhost:3302", "http_enabled": False}
myapp.storage_B: {"advertise_uri": "localhost:3303", "http_enabled": False}
CONFIG

ಇಲ್ಲಿ ಒಂದು ಆಸಕ್ತಿದಾಯಕ ಸೂಕ್ಷ್ಮ ವ್ಯತ್ಯಾಸವಿದೆ. ಕೇವಲ ಬೈನರಿ ಪ್ರೋಟೋಕಾಲ್ ಪೋರ್ಟ್ ಅನ್ನು ಸೂಚಿಸುವ ಬದಲು, ಹೋಸ್ಟ್ ಹೆಸರನ್ನು ಒಳಗೊಂಡಂತೆ ಪ್ರಕ್ರಿಯೆಯ ಸಂಪೂರ್ಣ ಸಾರ್ವಜನಿಕ ವಿಳಾಸವನ್ನು ನಾವು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತೇವೆ. ಕ್ಲಸ್ಟರ್ ನೋಡ್‌ಗಳು ಪರಸ್ಪರ ಹೇಗೆ ಸಂಪರ್ಕಿಸಬೇಕು ಎಂದು ತಿಳಿಯಲು ಇದು ಅವಶ್ಯಕವಾಗಿದೆ. 0.0.0.0 ಅನ್ನು advertise_uri ವಿಳಾಸವಾಗಿ ಬಳಸುವುದು ಕೆಟ್ಟ ಆಲೋಚನೆಯಾಗಿದೆ, ಅದು ಬಾಹ್ಯ IP ವಿಳಾಸವಾಗಿರಬೇಕು, ಸಾಕೆಟ್ ಬೈಂಡ್ ಅಲ್ಲ. ಇದು ಇಲ್ಲದೆ, ಏನೂ ಕೆಲಸ ಮಾಡುವುದಿಲ್ಲ, ಆದ್ದರಿಂದ ಕಾರ್ಟ್ರಿಡ್ಜ್ ನಿಮಗೆ ತಪ್ಪು advertise_uri ಜೊತೆ ನೋಡ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಲು ಅನುಮತಿಸುವುದಿಲ್ಲ.

ಈಗ ಕಾನ್ಫಿಗರೇಶನ್ ಸಿದ್ಧವಾಗಿದೆ, ನೀವು ಪ್ರಕ್ರಿಯೆಗಳನ್ನು ಪ್ರಾರಂಭಿಸಬಹುದು. ನಿಯಮಿತ systemd ಘಟಕವು ಒಂದಕ್ಕಿಂತ ಹೆಚ್ಚು ಪ್ರಕ್ರಿಯೆಯನ್ನು ಪ್ರಾರಂಭಿಸಲು ಅನುಮತಿಸುವುದಿಲ್ಲವಾದ್ದರಿಂದ, ಕಾರ್ಟ್ರಿಡ್ಜ್‌ನಲ್ಲಿನ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ಕರೆಯಲ್ಪಡುವ ಮೂಲಕ ಸ್ಥಾಪಿಸಲಾಗಿದೆ. ತತ್‌ಕ್ಷಣದ ಘಟಕಗಳು ಈ ರೀತಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ:

$ sudo systemctl start myapp@router
$ sudo systemctl start myapp@storage_A
$ sudo systemctl start myapp@storage_B

ಕಾನ್ಫಿಗರೇಶನ್‌ನಲ್ಲಿ, ನಾವು ಕಾರ್ಟ್ರಿಡ್ಜ್ ವೆಬ್ ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ಒದಗಿಸುವ HTTP ಪೋರ್ಟ್ ಅನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ್ದೇವೆ - 8080. ನಾವು ಅದಕ್ಕೆ ಹೋಗಿ ನೋಡೋಣ:

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

ನಿಮ್ಮ ನೆಚ್ಚಿನ ಪಾನೀಯದ ಗಾಜಿನನ್ನು ಸುರಿಯೋಣ ಮತ್ತು ಸುದೀರ್ಘ ಕೆಲಸದ ವಾರದ ನಂತರ ವಿಶ್ರಾಂತಿ ಪಡೆಯಿರಿ. ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಬಳಸಬಹುದು.