ಸಮ್ಮೇಳನದ ವರದಿಯ ಪ್ರತಿಯನ್ನು ಮತ್ತೊಮ್ಮೆ ಪ್ರಕಟಿಸುತ್ತಿದ್ದೇವೆ ಹೈಲೋಡ್ ++ 2016, ಇದು ಕಳೆದ ವರ್ಷ ನವೆಂಬರ್ 7-8 ರಂದು ಮಾಸ್ಕೋ ಬಳಿಯ ಸ್ಕೋಲ್ಕೊವೊದಲ್ಲಿ ನಡೆಯಿತು. ವ್ಲಾಡಿಮಿರ್ ಪ್ರೊಟಾಸೊವ್ OpenResty ಮತ್ತು Lua ಜೊತೆಗೆ NGINX ಕಾರ್ಯವನ್ನು ಹೇಗೆ ವಿಸ್ತರಿಸುವುದು ಎಂಬುದನ್ನು ವಿವರಿಸುತ್ತದೆ.

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

ಆದ್ದರಿಂದ ಅದು ಎಷ್ಟು ಕೆಟ್ಟದಾಗಿದೆ ಎಂದು ನೀವು ಅರ್ಥಮಾಡಿಕೊಂಡಿದ್ದೀರಿ. ನಾನು ಸ್ವಲ್ಪ ಜೂನಿಯರ್ ಆಗಿದ್ದಾಗ, ನಾನು ಬಂದು ಈ ಎರಡು-ಟೆರಾಬೈಟ್ ಡೇಟಾಬೇಸ್‌ಗಳನ್ನು ನೀಡಿದ್ದೇನೆ. ಈಗ ಇಲ್ಲಿ ಎಲ್ಲರಿಗೂ ಹೆಚ್ಚಿನ ಹೊರೆಯಾಗಿದೆ. ನಾನು ಸಮ್ಮೇಳನಗಳಿಗೆ ಹೋಗಿ ಕೇಳಿದೆ: “ಹುಡುಗರೇ, ಹೇಳಿ, ನಿಮ್ಮ ಬಳಿ ದೊಡ್ಡ ಡೇಟಾ ಇದೆ, ಎಲ್ಲವೂ ತಂಪಾಗಿದೆಯೇ? ಅಲ್ಲಿ ನೀವು ಎಷ್ಟು ಆಧಾರಗಳನ್ನು ಹೊಂದಿದ್ದೀರಿ? ಅವರು ನನಗೆ ಉತ್ತರಿಸಿದರು: "ನಮ್ಮಲ್ಲಿ 100 ಗಿಗಾಬೈಟ್ಗಳಿವೆ!" ನಾನು ಹೇಳಿದೆ: "ಕೂಲ್, 100 ಗಿಗಾಬೈಟ್ಗಳು!" ಮತ್ತು ನನ್ನ ಪೋಕರ್ ಮುಖವನ್ನು ಹೇಗೆ ಎಚ್ಚರಿಕೆಯಿಂದ ನಿರ್ವಹಿಸುವುದು ಎಂದು ನಾನು ಯೋಚಿಸುತ್ತಿದ್ದೆ. ನೀವು ಯೋಚಿಸುತ್ತೀರಿ, ಹೌದು, ಹುಡುಗರು ತಂಪಾಗಿದ್ದಾರೆ, ಮತ್ತು ನಂತರ ನೀವು ಹಿಂತಿರುಗಿ ಮತ್ತು ಈ ಮಲ್ಟಿ-ಟೆರಾಬೈಟ್ ಡೇಟಾಬೇಸ್‌ಗಳೊಂದಿಗೆ ಟಿಂಕರ್ ಮಾಡಿ. ಮತ್ತು ಇದು ಜೂನಿಯರ್ ಆಗಿದೆ. ಇದು ಎಂತಹ ಹೊಡೆತ ಎಂದು ನೀವು ಊಹಿಸಬಲ್ಲಿರಾ?

ನನಗೆ 20ಕ್ಕೂ ಹೆಚ್ಚು ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳು ಗೊತ್ತು. ನಾನು ಕೆಲಸ ಮಾಡುವಾಗ ನಾನು ಲೆಕ್ಕಾಚಾರ ಮಾಡಬೇಕಾದ ವಿಷಯ ಇದು. ಅವರು ನಿಮಗೆ ಎರ್ಲಾಂಗ್, ಸಿ, ಸಿ++, ಲುವಾ, ಪೈಥಾನ್, ರೂಬಿ, ಇನ್ನೇನಾದರೂ ಕೋಡ್ ನೀಡುತ್ತಾರೆ ಮತ್ತು ನೀವು ಎಲ್ಲವನ್ನೂ ಕತ್ತರಿಸಬೇಕು. ಸಾಮಾನ್ಯವಾಗಿ, ನಾನು ಮಾಡಬೇಕಾಗಿತ್ತು. ನಿಖರವಾದ ಸಂಖ್ಯೆಯನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡಲು ಸಾಧ್ಯವಾಗಲಿಲ್ಲ, ಆದರೆ ಎಲ್ಲೋ ಸುಮಾರು 20 ನೇ ಸಂಖ್ಯೆ ಕಳೆದುಹೋಯಿತು.

ಪ್ರಸ್ತುತ ಇರುವ ಪ್ರತಿಯೊಬ್ಬರಿಗೂ ಸಮಾನಾಂತರಗಳು ಮತ್ತು ನಾವು ಏನು ಮಾಡುತ್ತೇವೆ ಎಂದು ತಿಳಿದಿರುವುದರಿಂದ, ನಾವು ಎಷ್ಟು ತಂಪಾಗಿರುತ್ತೇವೆ ಮತ್ತು ನಾವು ಏನು ಮಾಡುತ್ತೇವೆ ಎಂಬುದರ ಕುರಿತು ನಾನು ಮಾತನಾಡುವುದಿಲ್ಲ. ನಾವು ಪ್ರಪಂಚದಾದ್ಯಂತ 13 ಕಚೇರಿಗಳನ್ನು ಹೊಂದಿದ್ದೇವೆ, 300 ಕ್ಕೂ ಹೆಚ್ಚು ಉದ್ಯೋಗಿಗಳು, ಮಾಸ್ಕೋ, ಟ್ಯಾಲಿನ್ ಮತ್ತು ಮಾಲ್ಟಾದಲ್ಲಿ ಅಭಿವೃದ್ಧಿ ಹೊಂದಿದ್ದೇವೆ ಎಂದು ನಾನು ನಿಮಗೆ ಹೇಳುತ್ತೇನೆ. ನೀವು ಬಯಸಿದರೆ, ಚಳಿಗಾಲದಲ್ಲಿ ಶೀತವಾಗಿದ್ದರೆ ಮತ್ತು ನಿಮ್ಮ ಬೆನ್ನನ್ನು ಬೆಚ್ಚಗಾಗಲು ನೀವು ಅದನ್ನು ತೆಗೆದುಕೊಂಡು ಮಾಲ್ಟಾಕ್ಕೆ ಹೋಗಬಹುದು.

ನಿರ್ದಿಷ್ಟವಾಗಿ ಹೇಳುವುದಾದರೆ, ನಮ್ಮ ಇಲಾಖೆಯು ಪೈಥಾನ್ 2 ರಲ್ಲಿ ಬರೆಯುತ್ತದೆ. ನಾವು ವ್ಯವಹಾರದಲ್ಲಿದ್ದೇವೆ ಮತ್ತು ಫ್ಯಾಶನ್ ತಂತ್ರಜ್ಞಾನಗಳನ್ನು ಅಳವಡಿಸಲು ಸಮಯವಿಲ್ಲ, ಆದ್ದರಿಂದ ನಾವು ಬಳಲುತ್ತಿದ್ದೇವೆ. ನಾವು ಜಾಂಗೊವನ್ನು ಬಳಸುತ್ತೇವೆ ಏಕೆಂದರೆ ಅದು ಎಲ್ಲವನ್ನೂ ಹೊಂದಿದೆ, ಮತ್ತು ನಾವು ಅನಗತ್ಯವಾದದ್ದನ್ನು ತೆಗೆದುಕೊಂಡು ಅದನ್ನು ಎಸೆಯುತ್ತೇವೆ. ಜೊತೆಗೆ MySQL, Redis ಮತ್ತು NGINX. ನಮ್ಮಲ್ಲಿ ಇನ್ನೂ ಅನೇಕ ತಂಪಾದ ವಿಷಯಗಳಿವೆ. ನಮ್ಮಲ್ಲಿ ಮೊಂಗೋಡಿಬಿ ಇದೆ, ನಮ್ಮಲ್ಲಿ ಮೊಲಗಳು ಓಡುತ್ತಿವೆ, ನಮ್ಮಲ್ಲಿ ಎಲ್ಲವೂ ಇದೆ - ಆದರೆ ಇದು ನನ್ನದಲ್ಲ, ಮತ್ತು ನಾನು ಅದನ್ನು ಮಾಡುವುದಿಲ್ಲ.

ಓಪನ್ ರೆಸ್ಟಿ

ನಾನು ನನ್ನ ಬಗ್ಗೆ ಹೇಳಿದೆ. ನಾನು ಇಂದು ಏನು ಮಾತನಾಡುತ್ತೇನೆ ಎಂದು ಲೆಕ್ಕಾಚಾರ ಮಾಡೋಣ:

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

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

NGINX ಈಗಾಗಲೇ ಹಿಡಿದಿಟ್ಟುಕೊಳ್ಳುವಿಕೆ ಮತ್ತು ಸ್ಥಿರ ವಿಷಯವನ್ನು ಹೊಂದಿದೆ. ಇದನ್ನು ಮಾನವೀಯವಾಗಿ ಹೇಗೆ ಮಾಡಬೇಕೆಂದು ನೀವು ಚಿಂತಿಸಬೇಕಾಗಿಲ್ಲ, ಇದರಿಂದ ನೀವು ಎಲ್ಲೋ ನಿಧಾನಗೊಳಿಸುವುದಿಲ್ಲ, ಆದ್ದರಿಂದ ನೀವು ಎಲ್ಲೋ ವಿವರಣೆಯನ್ನು ಕಳೆದುಕೊಳ್ಳುವುದಿಲ್ಲ. Nginx ಅನ್ನು ನಿಯೋಜಿಸಲು ತುಂಬಾ ಅನುಕೂಲಕರವಾಗಿದೆ, ನೀವು ಏನು ತೆಗೆದುಕೊಳ್ಳಬೇಕೆಂದು ಯೋಚಿಸುವ ಅಗತ್ಯವಿಲ್ಲ - WSGI, PHP-FPM, Gunicorn, Unicorn. Nginx ಅನ್ನು ಸ್ಥಾಪಿಸಲಾಗಿದೆ, ನಿರ್ವಾಹಕರಿಗೆ ನೀಡಲಾಗಿದೆ, ಅದರೊಂದಿಗೆ ಹೇಗೆ ಕೆಲಸ ಮಾಡಬೇಕೆಂದು ಅವರಿಗೆ ತಿಳಿದಿದೆ. Nginx ವಿನಂತಿಗಳನ್ನು ರಚನಾತ್ಮಕ ರೀತಿಯಲ್ಲಿ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುತ್ತದೆ. ನಾನು ಈ ಬಗ್ಗೆ ಸ್ವಲ್ಪ ನಂತರ ಮಾತನಾಡುತ್ತೇನೆ. ಸಂಕ್ಷಿಪ್ತವಾಗಿ ಹೇಳುವುದಾದರೆ, ಅದು ವಿನಂತಿಯನ್ನು ಸ್ವೀಕರಿಸಿದಾಗ, ಅದನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಿದಾಗ ಮತ್ತು ಬಳಕೆದಾರರಿಗೆ ವಿಷಯವನ್ನು ಒದಗಿಸಿದಾಗ ಅದು ಒಂದು ಹಂತವನ್ನು ಹೊಂದಿದೆ.

Nginx ತಂಪಾಗಿದೆ, ಆದರೆ ಒಂದು ಸಮಸ್ಯೆ ಇದೆ: ಅದನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡಬಹುದಾದರೂ ಸಹ, ಹುಡುಗರು ಕಾನ್ಫಿಗರ್‌ನಲ್ಲಿ ತುಂಬಿರುವ ಎಲ್ಲಾ ತಂಪಾದ ವೈಶಿಷ್ಟ್ಯಗಳೊಂದಿಗೆ ಸಹ ಇದು ಸಾಕಷ್ಟು ಹೊಂದಿಕೊಳ್ಳುವುದಿಲ್ಲ. ಈ ಶಕ್ತಿ ಸಾಕಾಗುವುದಿಲ್ಲ. ಅದಕ್ಕಾಗಿಯೇ ಟಾವೊಬಾವೊದ ವ್ಯಕ್ತಿಗಳು, ಬಹಳ ಹಿಂದೆಯೇ, ಎಂಟು ವರ್ಷಗಳ ಹಿಂದೆ, ಲುವಾವನ್ನು ಅದರೊಳಗೆ ನಿರ್ಮಿಸಿದಂತೆ ತೋರುತ್ತದೆ. ಅದು ಏನು ನೀಡುತ್ತದೆ?

• ಗಾತ್ರ. ಇದು ಚಿಕ್ಕದಾಗಿದೆ. LuaJIT ಸುಮಾರು 100-200 ಕಿಲೋಬೈಟ್‌ಗಳ ಮೆಮೊರಿ ಓವರ್‌ಹೆಡ್ ಮತ್ತು ಕನಿಷ್ಠ ಕಾರ್ಯಕ್ಷಮತೆ ಓವರ್‌ಹೆಡ್ ನೀಡುತ್ತದೆ.
• ವೇಗ. LuaJIT ಇಂಟರ್ಪ್ರಿಟರ್ ಅನೇಕ ಸಂದರ್ಭಗಳಲ್ಲಿ C ಗೆ ಹತ್ತಿರದಲ್ಲಿದೆ, ಕೆಲವು ಸಂದರ್ಭಗಳಲ್ಲಿ ಅದು ಜಾವಾವನ್ನು ಕಳೆದುಕೊಳ್ಳುತ್ತದೆ, ಇತರರಲ್ಲಿ ಅದು ಅದನ್ನು ಮೀರಿಸುತ್ತದೆ. ಸ್ವಲ್ಪ ಸಮಯದವರೆಗೆ ಇದನ್ನು ಕಲೆಯ ರಾಜ್ಯವೆಂದು ಪರಿಗಣಿಸಲಾಗಿದೆ, ತಂಪಾದ JIT ಕಂಪೈಲರ್. ಈಗ ತಂಪಾದವುಗಳಿವೆ, ಆದರೆ ಅವು ತುಂಬಾ ಭಾರವಾಗಿವೆ, ಉದಾಹರಣೆಗೆ, ಅದೇ ವಿ 8. ಕೆಲವು JS ಇಂಟರ್ಪ್ರಿಟರ್‌ಗಳು ಮತ್ತು ಜಾವಾ ಹಾಟ್‌ಸ್ಪಾಟ್ ಕೆಲವು ಹಂತಗಳಲ್ಲಿ ವೇಗವಾಗಿರುತ್ತದೆ, ಆದರೆ ಕೆಲವು ಸ್ಥಳಗಳಲ್ಲಿ ಅವರು ಇನ್ನೂ ಕಳೆದುಕೊಳ್ಳುತ್ತಾರೆ.
• ಕಲಿಯಲು ಸುಲಭ. ನೀವು ಪರ್ಲ್ ಕೋಡ್ ಬೇಸ್ ಅನ್ನು ಹೊಂದಿದ್ದರೆ ಮತ್ತು ನೀವು ಬುಕಿಂಗ್ ಮಾಡದಿದ್ದರೆ, ನೀವು ಪರ್ಲ್ ಪ್ರೋಗ್ರಾಮರ್‌ಗಳನ್ನು ಕಾಣುವುದಿಲ್ಲ. ಅವರು ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲದ ಕಾರಣ, ಅವರೆಲ್ಲರನ್ನೂ ತೆಗೆದುಕೊಳ್ಳಲಾಗಿದೆ, ಮತ್ತು ಅವರಿಗೆ ಕಲಿಸುವುದು ದೀರ್ಘ ಮತ್ತು ಕಷ್ಟಕರವಾಗಿದೆ. ನೀವು ಬೇರೆ ಯಾವುದಾದರೂ ಪ್ರೋಗ್ರಾಮರ್‌ಗಳನ್ನು ಬಯಸಿದರೆ, ನೀವು ಅವರಿಗೆ ಮರುತರಬೇತಿ ನೀಡಬೇಕಾಗಬಹುದು ಅಥವಾ ಅವರನ್ನು ಹುಡುಕಬೇಕಾಗಬಹುದು. ಲುವಾ ವಿಷಯದಲ್ಲಿ, ಎಲ್ಲವೂ ಸರಳವಾಗಿದೆ. ಯಾವುದೇ ಜೂನಿಯರ್ ಮೂರು ದಿನಗಳಲ್ಲಿ ಲುವಾ ಕಲಿಯಬಹುದು. ಅದನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡಲು ನನಗೆ ಸುಮಾರು ಎರಡು ಗಂಟೆಗಳು ಬೇಕಾಯಿತು. ಎರಡು ಗಂಟೆಗಳ ನಂತರ ನಾನು ಈಗಾಗಲೇ ಉತ್ಪಾದನೆಯಲ್ಲಿ ಕೋಡ್ ಬರೆಯುತ್ತಿದ್ದೇನೆ. ಸುಮಾರು ಒಂದು ವಾರದ ನಂತರ ಅವರು ನೇರವಾಗಿ ನಿರ್ಮಾಣಕ್ಕೆ ಹೋಗಿ ಬಿಟ್ಟರು.

ಪರಿಣಾಮವಾಗಿ, ಇದು ಈ ರೀತಿ ಕಾಣುತ್ತದೆ:

ಇಲ್ಲಿ ಬಹಳಷ್ಟು ಇದೆ. OpenResty luash ಮತ್ತು ಎಂಜಿನ್ ಎರಡೂ ಮಾಡ್ಯೂಲ್‌ಗಳ ಗುಂಪನ್ನು ಸಂಗ್ರಹಿಸಿದೆ. ಮತ್ತು ನೀವು ಎಲ್ಲವನ್ನೂ ಸಿದ್ಧಪಡಿಸಿದ್ದೀರಿ - ನಿಯೋಜಿಸಲಾಗಿದೆ ಮತ್ತು ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿದೆ.

ಉದಾಹರಣೆಗಳು

ಸಾಹಿತ್ಯ ಸಾಕು, ಕೋಡ್‌ಗೆ ಹೋಗೋಣ. ಸ್ವಲ್ಪ ಹಲೋ ವರ್ಲ್ಡ್ ಇಲ್ಲಿದೆ:

ಅಲ್ಲಿ ಏನಿದೆ? ಇದು ಎಂಜಿನ್ ಸ್ಥಳವಾಗಿದೆ. ನಾವು ಚಿಂತಿಸಬೇಡಿ, ನಾವು ನಮ್ಮ ಸ್ವಂತ ರೂಟಿಂಗ್ ಅನ್ನು ಬರೆಯುವುದಿಲ್ಲ, ನಾವು ಕೆಲವು ರೆಡಿಮೇಡ್ ಒಂದನ್ನು ತೆಗೆದುಕೊಳ್ಳುವುದಿಲ್ಲ - ನಾವು ಈಗಾಗಲೇ NGINX ನಲ್ಲಿ ಅದನ್ನು ಹೊಂದಿದ್ದೇವೆ, ನಾವು ಉತ್ತಮ ಮತ್ತು ಸೋಮಾರಿಯಾದ ಜೀವನವನ್ನು ನಡೆಸುತ್ತೇವೆ.

content_by_lua_block ನಾವು ಲುವಾ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ವಿಷಯವನ್ನು ಒದಗಿಸುತ್ತಿದ್ದೇವೆ ಎಂದು ಹೇಳುವ ಬ್ಲಾಕ್ ಆಗಿದೆ. ನಾವು ಎಂಜಿನ್ ವೇರಿಯಬಲ್ ಅನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತೇವೆ remote_addr ಮತ್ತು ಅದನ್ನು ಹಾಕಿ string.format. ಇದು ಒಂದೇ sprintf, ಲುವಾದಲ್ಲಿ ಮಾತ್ರ, ಸರಿಯಾಗಿದೆ. ಮತ್ತು ನಾವು ಅದನ್ನು ಗ್ರಾಹಕರಿಗೆ ನೀಡುತ್ತೇವೆ.

ಪರಿಣಾಮವಾಗಿ, ಇದು ಈ ರೀತಿ ಕಾಣುತ್ತದೆ:

ಆದರೆ ವಾಸ್ತವ ಜಗತ್ತಿಗೆ ಹಿಂತಿರುಗೋಣ. ಯಾರೂ ಹಲೋ ವರ್ಲ್ಡ್ ಅನ್ನು ಉತ್ಪಾದನೆಗೆ ನಿಯೋಜಿಸುವುದಿಲ್ಲ. ನಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಸಾಮಾನ್ಯವಾಗಿ ಡೇಟಾಬೇಸ್ ಅಥವಾ ಬೇರೆಡೆಗೆ ಹೋಗುತ್ತದೆ ಮತ್ತು ಹೆಚ್ಚಿನ ಸಮಯ ಪ್ರತಿಕ್ರಿಯೆಗಾಗಿ ಕಾಯುತ್ತದೆ.

ಅವನು ಸುಮ್ಮನೆ ಕುಳಿತು ಕಾಯುತ್ತಾನೆ. ಇದು ತುಂಬಾ ಒಳ್ಳೆಯದಲ್ಲ. 100.000 ಬಳಕೆದಾರರು ಬಂದಾಗ, ಅದು ನಮಗೆ ತುಂಬಾ ಕಷ್ಟ. ಆದ್ದರಿಂದ ಸರಳವಾದ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಉದಾಹರಣೆಯಾಗಿ ಬಳಸೋಣ. ನಾವು ಚಿತ್ರಗಳನ್ನು ಹುಡುಕುತ್ತೇವೆ, ಉದಾಹರಣೆಗೆ, ಬೆಕ್ಕುಗಳು. ಆದರೆ ನಾವು ಕೇವಲ ಹುಡುಕುವುದಿಲ್ಲ, ನಾವು ಕೀವರ್ಡ್‌ಗಳನ್ನು ವಿಸ್ತರಿಸುತ್ತೇವೆ ಮತ್ತು ಬಳಕೆದಾರರು “ಕಿಟೆನ್ಸ್” ಗಾಗಿ ಹುಡುಕಿದರೆ ನಾವು ಬೆಕ್ಕುಗಳು, ತುಪ್ಪುಳಿನಂತಿರುವ ಬೆಕ್ಕುಗಳು ಇತ್ಯಾದಿಗಳನ್ನು ಕಾಣಬಹುದು. ಮೊದಲಿಗೆ, ನಾವು ಬ್ಯಾಕೆಂಡ್‌ನಲ್ಲಿ ವಿನಂತಿಯ ಡೇಟಾವನ್ನು ಪಡೆಯಬೇಕು. ಇದು ಈ ರೀತಿ ಕಾಣುತ್ತದೆ:

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

ಗ್ರಂಥಾಲಯವನ್ನು ಸಂಪರ್ಕಿಸಲಾಗುತ್ತಿದೆ resty.mysql, ನಾವು ಈಗಾಗಲೇ ಕಿಟ್‌ನಲ್ಲಿ ಹೊಂದಿದ್ದೇವೆ. ನಾವು ಏನನ್ನೂ ಸ್ಥಾಪಿಸುವ ಅಗತ್ಯವಿಲ್ಲ, ಎಲ್ಲವೂ ಸಿದ್ಧವಾಗಿದೆ. SQL ಪ್ರಶ್ನೆಯನ್ನು ಹೇಗೆ ಸಂಪರ್ಕಿಸುವುದು ಮತ್ತು ಮಾಡುವುದು ಹೇಗೆ ಎಂದು ನಾವು ಸೂಚಿಸುತ್ತೇವೆ:

ಇಲ್ಲಿ ಸ್ವಲ್ಪ ಭಯಾನಕವಾಗಿದೆ, ಆದರೆ ಎಲ್ಲವೂ ಕೆಲಸ ಮಾಡುತ್ತದೆ. ಇಲ್ಲಿ 10 ಮಿತಿಯಾಗಿದೆ. ನಾವು 10 ನಮೂದುಗಳನ್ನು ಹೊರತೆಗೆಯುತ್ತೇವೆ, ನಾವು ಸೋಮಾರಿಯಾಗಿದ್ದೇವೆ, ಹೆಚ್ಚಿನದನ್ನು ತೋರಿಸಲು ನಾವು ಬಯಸುವುದಿಲ್ಲ. ನಾನು SQL ನಲ್ಲಿ ಮಿತಿಯನ್ನು ಮರೆತಿದ್ದೇನೆ.

ಮುಂದೆ ನಾವು ಎಲ್ಲಾ ಪ್ರಶ್ನೆಗಳಿಗೆ ಚಿತ್ರಗಳನ್ನು ಹುಡುಕುತ್ತೇವೆ. ನಾವು ವಿನಂತಿಗಳ ಗುಂಪನ್ನು ಸಂಗ್ರಹಿಸುತ್ತೇವೆ ಮತ್ತು ಲುವಾ ಟೇಬಲ್ ಅನ್ನು ಭರ್ತಿ ಮಾಡುತ್ತೇವೆ reqs, ಮತ್ತು ನಾವು ಮಾಡುತ್ತೇವೆ ngx.location.capture_multi.

ಈ ಎಲ್ಲಾ ವಿನಂತಿಗಳನ್ನು ಸಮಾನಾಂತರವಾಗಿ ಕಳುಹಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಉತ್ತರಗಳನ್ನು ನಮಗೆ ಹಿಂತಿರುಗಿಸಲಾಗುತ್ತದೆ. ಕಾರ್ಯಾಚರಣೆಯ ಸಮಯವು ನಿಧಾನಗತಿಯ ಪ್ರತಿಕ್ರಿಯೆಯ ಸಮಯಕ್ಕೆ ಸಮಾನವಾಗಿರುತ್ತದೆ. ನಾವೆಲ್ಲರೂ 50 ಮಿಲಿಸೆಕೆಂಡ್‌ಗಳಲ್ಲಿ ಶೂಟ್ ಮಾಡಿದರೆ ಮತ್ತು ನಾವು ನೂರು ವಿನಂತಿಗಳನ್ನು ಕಳುಹಿಸಿದರೆ, ನಾವು 50 ಮಿಲಿಸೆಕೆಂಡ್‌ಗಳಲ್ಲಿ ಉತ್ತರವನ್ನು ಸ್ವೀಕರಿಸುತ್ತೇವೆ.

ನಾವು ಸೋಮಾರಿಯಾಗಿರುವುದರಿಂದ ಮತ್ತು HTTP ಮತ್ತು ಕ್ಯಾಶಿಂಗ್ ಹ್ಯಾಂಡ್ಲಿಂಗ್ ಅನ್ನು ಬರೆಯಲು ಬಯಸುವುದಿಲ್ಲವಾದ್ದರಿಂದ, ನಾವು NGINX ನಮಗೆ ಎಲ್ಲವನ್ನೂ ಮಾಡುವಂತೆ ಮಾಡುತ್ತೇವೆ. ನೀವು ನೋಡಿದಂತೆ, ಒಂದು ವಿನಂತಿ ಇತ್ತು url/fetch, ಇಲ್ಲಿ ಅವನು:

ನಾವು ಅದನ್ನು ಸರಳಗೊಳಿಸುತ್ತೇವೆ proxy_pass, ಎಲ್ಲಿ ಸಂಗ್ರಹಿಸಬೇಕು, ಅದನ್ನು ಹೇಗೆ ಮಾಡಬೇಕೆಂದು ನಾವು ಸೂಚಿಸುತ್ತೇವೆ ಮತ್ತು ಎಲ್ಲವೂ ನಮಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ.

ಆದರೆ ಇದು ಸಾಕಾಗುವುದಿಲ್ಲ, ನಾವು ಇನ್ನೂ ಬಳಕೆದಾರರಿಗೆ ಡೇಟಾವನ್ನು ನೀಡಬೇಕಾಗಿದೆ. JSON ನಲ್ಲಿ ಎಲ್ಲವನ್ನೂ ಸುಲಭವಾಗಿ, ಎರಡು ಸಾಲುಗಳಲ್ಲಿ ಧಾರಾವಾಹಿ ಮಾಡುವುದು ಸರಳವಾದ ಉಪಾಯವಾಗಿದೆ. ನಾವು ವಿಷಯ-ಪ್ರಕಾರವನ್ನು ನೀಡುತ್ತೇವೆ, ನಾವು JSON ಅನ್ನು ನೀಡುತ್ತೇವೆ.

ಆದರೆ ಒಂದು ತೊಂದರೆ ಇದೆ: ಬಳಕೆದಾರರು JSON ಅನ್ನು ಓದಲು ಬಯಸುವುದಿಲ್ಲ. ನಾವು ಮುಂಭಾಗದ ಡೆವಲಪರ್‌ಗಳನ್ನು ಆಕರ್ಷಿಸಬೇಕಾಗಿದೆ. ಕೆಲವೊಮ್ಮೆ ನಾವು ಮೊದಲಿಗೆ ಇದನ್ನು ಮಾಡಲು ಬಯಸುವುದಿಲ್ಲ. ಮತ್ತು ಎಸ್‌ಇಒ ತಜ್ಞರು ನಾವು ಚಿತ್ರಗಳನ್ನು ಹುಡುಕುತ್ತಿದ್ದರೆ, ಅದು ಅವರಿಗೆ ಅಪ್ರಸ್ತುತವಾಗುತ್ತದೆ ಎಂದು ಹೇಳುತ್ತಾರೆ. ಮತ್ತು ನಾವು ಅವರಿಗೆ ಕೆಲವು ವಿಷಯವನ್ನು ನೀಡಿದರೆ, ನಮ್ಮ ಸರ್ಚ್ ಇಂಜಿನ್ಗಳು ಏನನ್ನೂ ಸೂಚಿಸುವುದಿಲ್ಲ ಎಂದು ಅವರು ಹೇಳುತ್ತಾರೆ.

ಅದಕ್ಕೆ ಏನು ಮಾಡಬೇಕು? ಸಹಜವಾಗಿ, ನಾವು ಬಳಕೆದಾರರಿಗೆ HTML ಅನ್ನು ನೀಡುತ್ತೇವೆ. ಕೈಯಿಂದ ಉತ್ಪಾದಿಸುವುದು comme il faut ಅಲ್ಲ, ಆದ್ದರಿಂದ ನಾವು ಟೆಂಪ್ಲೆಟ್ಗಳನ್ನು ಬಳಸಲು ಬಯಸುತ್ತೇವೆ. ಇದಕ್ಕಾಗಿ ಗ್ರಂಥಾಲಯವಿದೆ lua-resty-template.

ನೀವು ಬಹುಶಃ OPM ಎಂಬ ಮೂರು ಭಯಾನಕ ಅಕ್ಷರಗಳನ್ನು ನೋಡಿರಬಹುದು. OpenResty ತನ್ನದೇ ಆದ ಪ್ಯಾಕೇಜ್ ಮ್ಯಾನೇಜರ್‌ನೊಂದಿಗೆ ಬರುತ್ತದೆ, ಅದರ ಮೂಲಕ ನೀವು ವಿವಿಧ ಮಾಡ್ಯೂಲ್‌ಗಳ ಗುಂಪನ್ನು ಸ್ಥಾಪಿಸಬಹುದು, ನಿರ್ದಿಷ್ಟವಾಗಿ, lua-resty-template. ಇದು ಜಾಂಗೊ ಟೆಂಪ್ಲೇಟ್‌ಗಳಂತೆಯೇ ಸರಳ ಟೆಂಪ್ಲೇಟ್ ಎಂಜಿನ್ ಆಗಿದೆ. ಅಲ್ಲಿ ನೀವು ಕೋಡ್ ಬರೆಯಬಹುದು ಮತ್ತು ವೇರಿಯಬಲ್ ಪರ್ಯಾಯವನ್ನು ಮಾಡಬಹುದು.

ಪರಿಣಾಮವಾಗಿ, ಎಲ್ಲವೂ ಈ ರೀತಿ ಕಾಣುತ್ತದೆ:

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

ಎಲ್ಲವೂ ತಂಪಾಗಿದೆ, ಆದರೆ ನಾವು ಅಭಿವೃದ್ಧಿಯಲ್ಲಿದ್ದೇವೆ ಮತ್ತು ಅದನ್ನು ಇನ್ನೂ ಬಳಕೆದಾರರಿಗೆ ತೋರಿಸಲು ಬಯಸುವುದಿಲ್ಲ. ಅಧಿಕಾರವನ್ನು ಮಾಡೋಣ. ಇದನ್ನು ಮಾಡಲು, OpenResty ನಿಯಮಗಳಲ್ಲಿ NGINX ವಿನಂತಿಯನ್ನು ಹೇಗೆ ನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ನೋಡೋಣ:

• ಮೊದಲ ಹಂತ - ಪ್ರವೇಶ, ಬಳಕೆದಾರರು ಈಗಷ್ಟೇ ಬಂದಾಗ, ಮತ್ತು ನಾವು ಹೆಡರ್‌ಗಳ ಮೂಲಕ, IP ವಿಳಾಸದ ಮೂಲಕ ಮತ್ತು ಇತರ ಡೇಟಾದ ಮೂಲಕ ಅವನನ್ನು ನೋಡಿದ್ದೇವೆ. ನಮಗೆ ಇಷ್ಟವಿಲ್ಲದಿದ್ದರೆ ನಾವು ತಕ್ಷಣ ಅದನ್ನು ಕತ್ತರಿಸಬಹುದು. ಇದನ್ನು ದೃಢೀಕರಣಕ್ಕಾಗಿ ಬಳಸಬಹುದು ಅಥವಾ ನಾವು ಬಹಳಷ್ಟು ವಿನಂತಿಗಳನ್ನು ಸ್ವೀಕರಿಸಿದರೆ, ಈ ಹಂತದಲ್ಲಿ ನಾವು ಅವುಗಳನ್ನು ಸುಲಭವಾಗಿ ಕಡಿತಗೊಳಿಸಬಹುದು.
• ಪುನಃ ಬರೆಯಿರಿ. ನಾವು ಕೆಲವು ವಿನಂತಿ ಡೇಟಾವನ್ನು ಪುನಃ ಬರೆಯುತ್ತೇವೆ.
• ವಿಷಯ. ನಾವು ಬಳಕೆದಾರರಿಗೆ ವಿಷಯವನ್ನು ತಲುಪಿಸುತ್ತೇವೆ.
• ಹೆಡರ್ ಫಿಲ್ಟರ್. ನಾವು ಪ್ರತಿಕ್ರಿಯೆ ಹೆಡರ್ಗಳನ್ನು ಬದಲಾಯಿಸುತ್ತೇವೆ. ನಾವು ಬಳಸಿದರೆ proxy_pass, ಬಳಕೆದಾರರಿಗೆ ನೀಡುವ ಮೊದಲು ನಾವು ಕೆಲವು ಹೆಡರ್‌ಗಳನ್ನು ಪುನಃ ಬರೆಯಬಹುದು.
• ದೇಹದ ಫಿಲ್ಟರ್. ನಾವು ದೇಹವನ್ನು ಬದಲಾಯಿಸಬಹುದು.
• ಲಾಗ್ - ಲಾಗಿಂಗ್. ಹೆಚ್ಚುವರಿ ಲೇಯರ್ ಇಲ್ಲದೆ ನೀವು ಎಲಾಸ್ಟಿಕ್ ಸರ್ಚ್‌ನಲ್ಲಿ ಲಾಗ್‌ಗಳನ್ನು ಬರೆಯಬಹುದು.

ನಮ್ಮ ದೃಢೀಕರಣವು ಈ ರೀತಿ ಕಾಣುತ್ತದೆ:

ನಾವು ಇದಕ್ಕೆ ಇದನ್ನು ಸೇರಿಸುತ್ತೇವೆ location, ನಾವು ಮೊದಲು ವಿವರಿಸಿದ ಮತ್ತು ಕೆಳಗಿನ ಕೋಡ್ ಅನ್ನು ಅಲ್ಲಿ ಇರಿಸಿ:

ನಮ್ಮಲ್ಲಿ ಕುಕೀ ಟೋಕನ್ ಇದೆಯೇ ಎಂದು ನಾವು ನೋಡುತ್ತೇವೆ. ಇಲ್ಲದಿದ್ದರೆ, ನಾವು ಅಧಿಕಾರವನ್ನು ಕೇಳುತ್ತೇವೆ. ಬಳಕೆದಾರರು ಕುತಂತ್ರಿಗಳು ಮತ್ತು ಅವರು ಕುಕೀ ಟೋಕನ್ ಅನ್ನು ಹೊಂದಿಸಬೇಕಾಗಿದೆ ಎಂದು ಊಹಿಸಬಹುದು. ಆದ್ದರಿಂದ, ನಾವು ಅದನ್ನು ರೆಡಿಸ್‌ನಲ್ಲಿ ಸಹ ಹಾಕುತ್ತೇವೆ:

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

ಅಧಿಕಾರವನ್ನು ಸ್ವತಃ ಮಾಡೋಣ:

ನಾವು ವಿನಂತಿಯ ದೇಹವನ್ನು ಓದಬೇಕಾಗಿದೆ ಎಂದು ನಾವು ಹೇಳುತ್ತೇವೆ. ನಾವು POST ವಾದಗಳನ್ನು ಸ್ವೀಕರಿಸುತ್ತೇವೆ ಮತ್ತು ಲಾಗಿನ್ ಮತ್ತು ಪಾಸ್‌ವರ್ಡ್ ಸರಿಯಾಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತೇವೆ. ಅವು ತಪ್ಪಾಗಿದ್ದರೆ, ದೃಢೀಕರಣಕ್ಕಾಗಿ ನಾವು ನಿಮ್ಮನ್ನು ಸವಾಲು ಮಾಡುತ್ತೇವೆ. ಮತ್ತು ಸರಿಯಾಗಿದ್ದರೆ, ಟೋಕನ್ ಅನ್ನು ರೆಡಿಸ್‌ನಲ್ಲಿ ಬರೆಯಿರಿ:

ಕುಕೀಯನ್ನು ಹೊಂದಿಸಲು ಮರೆಯಬೇಡಿ, ಇದನ್ನು ಎರಡು ಸಾಲುಗಳಲ್ಲಿ ಮಾಡಲಾಗುತ್ತದೆ:

ಉದಾಹರಣೆ ಸರಳ ಮತ್ತು ಊಹಾತ್ಮಕವಾಗಿದೆ. ಸಹಜವಾಗಿ, ನಾವು ಜನರಿಗೆ ಬೆಕ್ಕುಗಳನ್ನು ತೋರಿಸುವ ಸೇವೆಯನ್ನು ಮಾಡುವುದಿಲ್ಲ. ಆದರೆ ನಮ್ಮನ್ನು ಯಾರು ಬಲ್ಲರು. ಆದ್ದರಿಂದ ಉತ್ಪಾದನೆಯಲ್ಲಿ ಏನು ಮಾಡಬಹುದು ಎಂಬುದನ್ನು ನೋಡೋಣ.

• ಕನಿಷ್ಠ ಬ್ಯಾಕೆಂಡ್. ಕೆಲವೊಮ್ಮೆ ನಾವು ಬ್ಯಾಕೆಂಡ್‌ಗೆ ಸ್ವಲ್ಪ ಡೇಟಾವನ್ನು ಔಟ್‌ಪುಟ್ ಮಾಡಬೇಕಾಗುತ್ತದೆ: ಎಲ್ಲೋ ನಾವು ದಿನಾಂಕವನ್ನು ಸೇರಿಸಬೇಕಾಗಿದೆ, ಎಲ್ಲೋ ನಾವು ಪಟ್ಟಿಯನ್ನು ಪ್ರದರ್ಶಿಸಬೇಕಾಗಿದೆ, ಈಗ ಸೈಟ್‌ನಲ್ಲಿ ಎಷ್ಟು ಬಳಕೆದಾರರು ಇದ್ದಾರೆ ಎಂದು ಹೇಳಿ, ಕೌಂಟರ್ ಅಥವಾ ಅಂಕಿಅಂಶಗಳನ್ನು ಲಗತ್ತಿಸಿ. ಏನೋ ಚಿಕ್ಕದು. ಕೆಲವು ಕನಿಷ್ಠ ತುಣುಕುಗಳನ್ನು ಬಹಳ ಸುಲಭವಾಗಿ ಮಾಡಬಹುದು. ಇದು ತ್ವರಿತ, ಸುಲಭ ಮತ್ತು ಉತ್ತಮಗೊಳಿಸುತ್ತದೆ.
• ಡೇಟಾ ಪೂರ್ವ ಸಂಸ್ಕರಣೆ. ಕೆಲವೊಮ್ಮೆ ನಾವು ನಮ್ಮ ಪುಟದಲ್ಲಿ ಜಾಹೀರಾತನ್ನು ಎಂಬೆಡ್ ಮಾಡಲು ಬಯಸುತ್ತೇವೆ ಮತ್ತು API ವಿನಂತಿಗಳನ್ನು ಬಳಸಿಕೊಂಡು ನಾವು ಈ ಜಾಹೀರಾತನ್ನು ಸ್ವೀಕರಿಸುತ್ತೇವೆ. ಇದನ್ನು ಇಲ್ಲಿ ಮಾಡುವುದು ತುಂಬಾ ಸುಲಭ. ಈಗಾಗಲೇ ಕುಳಿತು ಕಷ್ಟಪಟ್ಟು ಕೆಲಸ ಮಾಡುತ್ತಿರುವ ನಮ್ಮ ಬ್ಯಾಕೆಂಡ್ ಅನ್ನು ನಾವು ಲೋಡ್ ಮಾಡುವುದಿಲ್ಲ. ನೀವು ಅದನ್ನು ಎತ್ತಿಕೊಂಡು ಇಲ್ಲಿ ಸಂಗ್ರಹಿಸಬಹುದು. ನಾವು ಕೆಲವು JS ಅನ್ನು ಒಟ್ಟಿಗೆ ಜೋಡಿಸಬಹುದು ಅಥವಾ ಇದಕ್ಕೆ ವಿರುದ್ಧವಾಗಿ, ಅದನ್ನು ಅನ್ಕಪಲ್ ಮಾಡಬಹುದು ಮತ್ತು ಬಳಕೆದಾರರಿಗೆ ನೀಡುವ ಮೊದಲು ಏನನ್ನಾದರೂ ಪೂರ್ವಪ್ರಕ್ರಿಯೆಗೊಳಿಸಬಹುದು.
• ಸೂಕ್ಷ್ಮ ಸೇವೆಗಾಗಿ ಮುಂಭಾಗ. ಇದು ತುಂಬಾ ಒಳ್ಳೆಯ ಪ್ರಕರಣ, ನಾನು ಅದನ್ನು ಜಾರಿಗೆ ತಂದಿದ್ದೇನೆ. ಅದಕ್ಕೂ ಮೊದಲು, ನಾನು ಎಲೆಕ್ಟ್ರಾನಿಕ್ ರಿಪೋರ್ಟಿಂಗ್‌ನೊಂದಿಗೆ ವ್ಯವಹರಿಸುವ ಮತ್ತು ದೇಶದ ಸರಿಸುಮಾರು ಅರ್ಧದಷ್ಟು ಕಾನೂನು ಘಟಕಗಳಿಗೆ ವರದಿ ಮಾಡುವ ಕಂಪನಿಯಾದ ಟೆನ್‌ಜೋರ್‌ನಲ್ಲಿ ಕೆಲಸ ಮಾಡಿದ್ದೇನೆ. ನಾವು ಸೇವೆಯನ್ನು ರಚಿಸಿದ್ದೇವೆ, ಅದೇ ಕಾರ್ಯವಿಧಾನವನ್ನು ಬಳಸಿಕೊಂಡು ಅಲ್ಲಿ ಅನೇಕ ಕೆಲಸಗಳನ್ನು ಮಾಡಲಾಗಿದೆ: ರೂಟಿಂಗ್, ದೃಢೀಕರಣ ಮತ್ತು ಇನ್ನಷ್ಟು.
  OpenResty ಅನ್ನು ನಿಮ್ಮ ಮೈಕ್ರೋ ಸರ್ವೀಸ್‌ಗಳಿಗೆ ಅಂಟು ಆಗಿ ಬಳಸಬಹುದು, ಎಲ್ಲದಕ್ಕೂ ಒಂದೇ ಪ್ರವೇಶವನ್ನು ಮತ್ತು ಒಂದೇ ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ಒದಗಿಸುತ್ತದೆ. ನೀವು ಇಲ್ಲಿ Node.js, ಇಲ್ಲಿ PHP, ಇಲ್ಲಿ ಪೈಥಾನ್, ಇಲ್ಲಿ ಕೆಲವು Erlang ವಿಷಯಗಳನ್ನು ಹೊಂದಿರುವ ರೀತಿಯಲ್ಲಿ ಮೈಕ್ರೊ ಸರ್ವಿಸ್‌ಗಳನ್ನು ಬರೆಯಬಹುದಾದ್ದರಿಂದ, ನಾವು ಒಂದೇ ಕೋಡ್ ಅನ್ನು ಎಲ್ಲೆಡೆ ಪುನಃ ಬರೆಯಲು ಬಯಸುವುದಿಲ್ಲ ಎಂದು ನಾವು ಅರ್ಥಮಾಡಿಕೊಂಡಿದ್ದೇವೆ. ಆದ್ದರಿಂದ, ಓಪನ್ ರೆಸ್ಟಿ ಅನ್ನು ಮುಂಭಾಗಕ್ಕೆ ಪ್ಲಗ್ ಮಾಡಬಹುದು.

• ಅಂಕಿಅಂಶಗಳು ಮತ್ತು ವಿಶ್ಲೇಷಣೆಗಳು. ಸಾಮಾನ್ಯವಾಗಿ NGINX ಪ್ರವೇಶದ್ವಾರದಲ್ಲಿದೆ, ಮತ್ತು ಎಲ್ಲಾ ವಿನಂತಿಗಳು ಅದರ ಮೂಲಕ ಹೋಗುತ್ತವೆ. ಈ ಸ್ಥಳದಲ್ಲಿಯೇ ಸಂಗ್ರಹಿಸಲು ತುಂಬಾ ಅನುಕೂಲಕರವಾಗಿದೆ. ನೀವು ತಕ್ಷಣ ಏನನ್ನಾದರೂ ಲೆಕ್ಕಾಚಾರ ಮಾಡಬಹುದು ಮತ್ತು ಅದನ್ನು ಎಲ್ಲೋ ಅಪ್‌ಲೋಡ್ ಮಾಡಬಹುದು, ಉದಾಹರಣೆಗೆ, ಸ್ಥಿತಿಸ್ಥಾಪಕ ಹುಡುಕಾಟ, ಲಾಗ್‌ಸ್ಟ್ಯಾಶ್, ಅಥವಾ ಅದನ್ನು ಸರಳವಾಗಿ ಲಾಗ್‌ಗೆ ಬರೆಯಿರಿ ಮತ್ತು ನಂತರ ಅದನ್ನು ಎಲ್ಲೋ ಕಳುಹಿಸಿ.
• ಬಹು-ಬಳಕೆದಾರ ವ್ಯವಸ್ಥೆಗಳು. ಉದಾಹರಣೆಗೆ, ಆನ್‌ಲೈನ್ ಆಟಗಳನ್ನು ಮಾಡುವುದು ತುಂಬಾ ಒಳ್ಳೆಯದು. ಇಂದು ಕೇಪ್ ಟೌನ್‌ನಲ್ಲಿ, ಅಲೆಕ್ಸಾಂಡರ್ ಗ್ಲಾಡಿಶ್ ಓಪನ್ ರೆಸ್ಟಿಯನ್ನು ಬಳಸಿಕೊಂಡು ಮಲ್ಟಿಪ್ಲೇಯರ್ ಆಟವನ್ನು ತ್ವರಿತವಾಗಿ ಮೂಲಮಾದರಿ ಮಾಡುವುದು ಹೇಗೆ ಎಂಬುದರ ಕುರಿತು ಮಾತನಾಡುತ್ತಾರೆ.
• ವಿನಂತಿ ಫಿಲ್ಟರಿಂಗ್ (WAF). ಇತ್ತೀಚಿನ ದಿನಗಳಲ್ಲಿ ಎಲ್ಲಾ ರೀತಿಯ ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್ ಫೈರ್‌ವಾಲ್‌ಗಳನ್ನು ಮಾಡುವುದು ಫ್ಯಾಶನ್ ಆಗಿದೆ; ಅವುಗಳನ್ನು ಒದಗಿಸುವ ಹಲವಾರು ಸೇವೆಗಳಿವೆ. OpenResty ಅನ್ನು ಬಳಸಿಕೊಂಡು, ನಿಮ್ಮ ಅವಶ್ಯಕತೆಗಳಿಗೆ ಅನುಗುಣವಾಗಿ ವಿನಂತಿಗಳನ್ನು ಸರಳವಾಗಿ ಮತ್ತು ಸುಲಭವಾಗಿ ಫಿಲ್ಟರ್ ಮಾಡುವ ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್ ಫೈರ್ವಾಲ್ ಅನ್ನು ನೀವೇ ಮಾಡಿಕೊಳ್ಳಬಹುದು. ನೀವು ಪೈಥಾನ್ ಹೊಂದಿದ್ದರೆ, ನೀವು ಕನ್ಸೋಲ್‌ನಿಂದ ಎಲ್ಲಿಯಾದರೂ ಅದನ್ನು ಹುಟ್ಟುಹಾಕದ ಹೊರತು, PHP ಖಂಡಿತವಾಗಿಯೂ ನಿಮ್ಮೊಳಗೆ ಚುಚ್ಚುವುದಿಲ್ಲ ಎಂದು ನೀವು ಅರ್ಥಮಾಡಿಕೊಂಡಿದ್ದೀರಿ. ನೀವು MySQL ಮತ್ತು ಪೈಥಾನ್ ಹೊಂದಿರುವಿರಿ ಎಂದು ನಿಮಗೆ ತಿಳಿದಿದೆ. ಬಹುಶಃ, ಅವರು ಕೆಲವು ರೀತಿಯ ಡೈರೆಕ್ಟರಿ ಟ್ರಾವರ್ಸಲ್ ಮಾಡಲು ಪ್ರಯತ್ನಿಸಬಹುದು ಮತ್ತು ಡೇಟಾಬೇಸ್‌ಗೆ ಏನನ್ನಾದರೂ ಸೇರಿಸಬಹುದು. ಆದ್ದರಿಂದ, ನೀವು ವಿಲಕ್ಷಣ ಪ್ರಶ್ನೆಗಳನ್ನು ತ್ವರಿತವಾಗಿ ಮತ್ತು ಅಗ್ಗವಾಗಿ ಮುಂಭಾಗದಲ್ಲಿಯೇ ಫಿಲ್ಟರ್ ಮಾಡಬಹುದು.
• ಸಮುದಾಯ. OpenResty ಅನ್ನು NGINX ನಲ್ಲಿ ನಿರ್ಮಿಸಲಾಗಿರುವುದರಿಂದ, ಇದು ಬೋನಸ್ ಅನ್ನು ಹೊಂದಿದೆ - ಇದು NGINX ಸಮುದಾಯ. ಇದು ತುಂಬಾ ದೊಡ್ಡದಾಗಿದೆ ಮತ್ತು ನೀವು ಮೊದಲು ಹೊಂದಿರುವ ಪ್ರಶ್ನೆಗಳ ಯೋಗ್ಯವಾದ ಭಾಗವನ್ನು ಈಗಾಗಲೇ NGINX ಸಮುದಾಯವು ಪರಿಹರಿಸಿದೆ.

  ಲುವಾ ಅಭಿವರ್ಧಕರು. ನಿನ್ನೆ ನಾನು ಹೈಲೋಡ್ ++ ತರಬೇತಿ ದಿನಕ್ಕೆ ಬಂದ ಹುಡುಗರೊಂದಿಗೆ ಮಾತನಾಡಿದೆ ಮತ್ತು ಲುವಾದಲ್ಲಿ ಟ್ಯಾರಂಟೂಲ್ ಅನ್ನು ಮಾತ್ರ ಬರೆಯಲಾಗಿದೆ ಎಂದು ಕೇಳಿದೆ. ಇದು ನಿಜವಲ್ಲ, ಲುವಾದಲ್ಲಿ ಬಹಳಷ್ಟು ವಿಷಯಗಳನ್ನು ಬರೆಯಲಾಗಿದೆ. ಉದಾಹರಣೆಗಳು: OpenResty, Prosody XMPP ಸರ್ವರ್, Love2D ಗೇಮ್ ಎಂಜಿನ್, ವಾರ್ಕ್ರಾಫ್ಟ್ನಲ್ಲಿ ಮತ್ತು ಇತರೆಡೆಗಳಲ್ಲಿ ಸ್ಕ್ರಿಪ್ಟ್ ಮಾಡಲಾದ Lua. ಬಹಳಷ್ಟು ಲುವಾ ಡೆವಲಪರ್‌ಗಳಿದ್ದಾರೆ, ಅವರು ದೊಡ್ಡ ಮತ್ತು ಸ್ಪಂದಿಸುವ ಸಮುದಾಯವನ್ನು ಹೊಂದಿದ್ದಾರೆ. ನನ್ನ ಎಲ್ಲಾ ಲುವಾ ಪ್ರಶ್ನೆಗಳನ್ನು ಕೆಲವೇ ಗಂಟೆಗಳಲ್ಲಿ ಪರಿಹರಿಸಲಾಗಿದೆ. ನೀವು ಮೇಲಿಂಗ್ ಪಟ್ಟಿಗೆ ಬರೆಯುವಾಗ, ಅಕ್ಷರಶಃ ಕೆಲವೇ ನಿಮಿಷಗಳಲ್ಲಿ ಈಗಾಗಲೇ ಪ್ರತಿಕ್ರಿಯೆಗಳ ಸಮೂಹವಿದೆ, ಏನು ಮತ್ತು ಹೇಗೆ, ಏನು ಎಂಬುದನ್ನು ವಿವರಿಸುತ್ತದೆ. ಇದು ಅದ್ಭುತವಾಗಿದೆ. ದುರದೃಷ್ಟವಶಾತ್, ಅಂತಹ ರೀತಿಯ, ಆಧ್ಯಾತ್ಮಿಕ ಸಮುದಾಯವು ಎಲ್ಲೆಡೆ ಇಲ್ಲ.
  OpenResty ಗಾಗಿ GitHub ಇದೆ, ಅಲ್ಲಿ ಏನಾದರೂ ಮುರಿದುಹೋದರೆ ನೀವು ಸಮಸ್ಯೆಯನ್ನು ತೆರೆಯಬಹುದು. Google ಗುಂಪುಗಳಲ್ಲಿ ಮೇಲಿಂಗ್ ಪಟ್ಟಿ ಇದೆ, ಅಲ್ಲಿ ನೀವು ಸಾಮಾನ್ಯ ಸಮಸ್ಯೆಗಳನ್ನು ಚರ್ಚಿಸಬಹುದು, ಚೈನೀಸ್‌ನಲ್ಲಿ ಮೇಲಿಂಗ್ ಪಟ್ಟಿ ಇದೆ - ನಿಮಗೆ ಗೊತ್ತಿಲ್ಲ, ಬಹುಶಃ ನೀವು ಇಂಗ್ಲಿಷ್ ಮಾತನಾಡುವುದಿಲ್ಲ, ಆದರೆ ನಿಮಗೆ ಚೈನೀಸ್ ತಿಳಿದಿದೆ.

ಫಲಿತಾಂಶಗಳು

• ಓಪನ್‌ರೆಸ್ಟಿ ವೆಬ್‌ಗೆ ಅನುಗುಣವಾಗಿ ಅತ್ಯಂತ ಅನುಕೂಲಕರ ಚೌಕಟ್ಟಾಗಿದೆ ಎಂದು ನಾನು ತಿಳಿಸಲು ಸಾಧ್ಯವಾಯಿತು ಎಂದು ನಾನು ಭಾವಿಸುತ್ತೇನೆ.
• ಇದು ಪ್ರವೇಶಕ್ಕೆ ಕಡಿಮೆ ತಡೆಗೋಡೆ ಹೊಂದಿದೆ, ಏಕೆಂದರೆ ಕೋಡ್ ನಾವು ಬರೆಯುವಂತೆಯೇ ಇರುತ್ತದೆ, ಭಾಷೆ ತುಂಬಾ ಸರಳವಾಗಿದೆ ಮತ್ತು ಕನಿಷ್ಠವಾಗಿದೆ.
• ಇದು ಕಾಲ್‌ಬ್ಯಾಕ್‌ಗಳಿಲ್ಲದೆ ಅಸಮಕಾಲಿಕ I/O ಅನ್ನು ಒದಗಿಸುತ್ತದೆ, ನಾವು ಕೆಲವೊಮ್ಮೆ NodeJS ನಲ್ಲಿ ಬರೆಯಬಹುದಾದಂತಹ ಯಾವುದೇ ನೂಡಲ್ಸ್ ಅನ್ನು ನಾವು ಹೊಂದಿರುವುದಿಲ್ಲ.
• ಇದು ಸುಲಭವಾದ ನಿಯೋಜನೆಯನ್ನು ಹೊಂದಿದೆ, ಏಕೆಂದರೆ ನಮಗೆ ಅಗತ್ಯವಾದ ಮಾಡ್ಯೂಲ್ ಮತ್ತು ನಮ್ಮ ಕೋಡ್‌ನೊಂದಿಗೆ NGINX ಮಾತ್ರ ಅಗತ್ಯವಿದೆ ಮತ್ತು ಎಲ್ಲವೂ ತಕ್ಷಣವೇ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ.
• ದೊಡ್ಡ ಮತ್ತು ಸ್ಪಂದಿಸುವ ಸಮುದಾಯ.

ರೂಟಿಂಗ್ ಅನ್ನು ಹೇಗೆ ಮಾಡಲಾಗುತ್ತದೆ ಎಂದು ನಾನು ವಿವರವಾಗಿ ಹೇಳಲಿಲ್ಲ, ಇದು ಬಹಳ ದೀರ್ಘವಾದ ಕಥೆಯಾಗಿದೆ.

ನಿಮ್ಮ ಗಮನಕ್ಕೆ ಧನ್ಯವಾದಗಳು!

ವ್ಲಾಡಿಮಿರ್ ಪ್ರೊಟಾಸೊವ್ - ಓಪನ್ ರೆಸ್ಟಿ: NGINX ಅನ್ನು ಪೂರ್ಣ ಪ್ರಮಾಣದ ಅಪ್ಲಿಕೇಶನ್ ಸರ್ವರ್ ಆಗಿ ಪರಿವರ್ತಿಸುವುದು

ಮೂಲ: www.habr.com